ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CliffordAlgebra.contractRight_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : M
⊢ (contractRight ((ι Q) x)) d = (algebraMap R (CliffordAlgebra Q)) (d x)
state_after: no goals
tactic: rw [contractRight_eq, reverse_ι, contractLeft_ι, reverse.commutes]
Theorem: norm_add_mul_self_real
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
h : ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
tactic: have h := @norm_add_mul_self ℝ _ _ _ _ x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
h : ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * ⟪x, y⟫_ℝ + ‖y‖ * ‖y‖
state_after: no goals
tactic: simpa using h
Theorem: TopCat.Presheaf.pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk
File: Mathlib/Topology/Sheaves/Stalks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
V : (Opens ↑Y)ᵒᵖ
x : ↥((Opens.map f).obj (unop V))
⊢ ((pushforwardPullbackAdjunction C f).unit.app F).app V ≫ germToPullbackStalk C f F ((Opens.map f).obj (unop V)) x =
    F.germ ⟨f ↑x, ⋯⟩
state_after: no goals
tactic: simpa using pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
    C f F ((Opens.map f).obj V.unop) x V.unop (by rfl)
Theorem: nhds_translation_mul_inv₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ 𝓝 ((Homeomorph.mulRight₀ a ha).symm.symm 1) = 𝓝 a
state_after: no goals
tactic: simp
Theorem: Multiset.Icc_eq_zero_iff
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Icc a b = 0 ↔ ¬a ≤ b
state_after: no goals
tactic: rw [Icc, Finset.val_eq_zero, Finset.Icc_eq_empty_iff]
Theorem: CategoryTheory.Functor.strongEpi_map_iff_strongEpi_of_isEquivalence
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
F : C ⥤ D
A B : C
f : A ⟶ B
inst✝ : F.IsEquivalence
⊢ StrongEpi (F.map f) ↔ StrongEpi f
state_after: case mp
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
F : C ⥤ D
A B : C
f : A ⟶ B
inst✝ : F.IsEquivalence
⊢ StrongEpi (F.map f) → StrongEpi f

case mpr
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
F : C ⥤ D
A B : C
f : A ⟶ B
inst✝ : F.IsEquivalence
⊢ StrongEpi f → StrongEpi (F.map f)
tactic: constructor
Theorem: MeasureTheory.OuterMeasure.trim_anti_measurableSpace
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
m0 m1 : MeasurableSpace α
h : m0 ≤ m1
⊢ m.trim ≤ m.trim
state_after: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
m0 m1 : MeasurableSpace α
h : m0 ≤ m1
⊢ ∀ (s : Set α), MeasurableSet s → m.trim s ≤ m s
tactic: simp only [le_trim_iff]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
m0 m1 : MeasurableSpace α
h : m0 ≤ m1
⊢ ∀ (s : Set α), MeasurableSet s → m.trim s ≤ m s
state_after: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
m0 m1 : MeasurableSpace α
h : m0 ≤ m1
s : Set α
hs : MeasurableSet s
⊢ m.trim s ≤ m s
tactic: intro s hs
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
m0 m1 : MeasurableSpace α
h : m0 ≤ m1
s : Set α
hs : MeasurableSet s
⊢ m.trim s ≤ m s
state_after: no goals
tactic: rw [trim_eq _ (h s hs)]
Theorem: SuccOrder.limitRecOn_limit
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : WellFoundedLT α
H_succ : (a : α) → ¬IsMax a → C a → C (succ a)
H_lim : (a : α) → IsSuccLimit a → ((b : α) → b < a → C b) → C a
ha : IsSuccLimit a
⊢ SuccOrder.limitRecOn a H_succ H_lim = H_lim a ha fun x x_1 => SuccOrder.limitRecOn x H_succ H_lim
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : WellFoundedLT α
H_succ : (a : α) → ¬IsMax a → C a → C (succ a)
H_lim : (a : α) → IsSuccLimit a → ((b : α) → b < a → C b) → C a
ha : IsSuccLimit a
⊢ (H_lim a ha fun y x =>
      ⋯.fix
        (fun a IH =>
          if h : IsSuccLimit a then H_lim a h IH
          else
            let x := Classical.indefiniteDescription (fun x => ¬IsMax x ∧ succ x = a) ⋯;
            ⋯ ▸ H_succ ↑x ⋯ (IH ↑x ⋯))
        y) =
    H_lim a ha fun x x_1 => SuccOrder.limitRecOn x H_succ H_lim
tactic: rw [SuccOrder.limitRecOn, WellFounded.fix_eq, dif_pos ha]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : WellFoundedLT α
H_succ : (a : α) → ¬IsMax a → C a → C (succ a)
H_lim : (a : α) → IsSuccLimit a → ((b : α) → b < a → C b) → C a
ha : IsSuccLimit a
⊢ (H_lim a ha fun y x =>
      ⋯.fix
        (fun a IH =>
          if h : IsSuccLimit a then H_lim a h IH
          else
            let x := Classical.indefiniteDescription (fun x => ¬IsMax x ∧ succ x = a) ⋯;
            ⋯ ▸ H_succ ↑x ⋯ (IH ↑x ⋯))
        y) =
    H_lim a ha fun x x_1 => SuccOrder.limitRecOn x H_succ H_lim
state_after: no goals
tactic: rfl
Theorem: PartENat.toWithTop_zero'
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: h : Decidable (Dom 0)
⊢ toWithTop 0 = 0
state_after: no goals
tactic: convert toWithTop_zero
Theorem: SimpleGraph.IsNClique.mono
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G ≤ H
⊢ G.IsNClique n s → H.IsNClique n s
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G ≤ H
⊢ G.IsClique ↑s ∧ s.card = n → H.IsClique ↑s ∧ s.card = n
tactic: simp_rw [isNClique_iff]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G ≤ H
⊢ G.IsClique ↑s ∧ s.card = n → H.IsClique ↑s ∧ s.card = n
state_after: no goals
tactic: exact And.imp_left (IsClique.mono h)
Theorem: Nat.range_mul_add
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m k : ℕ
⊢ (Set.range fun n => m * n + k) = {n | ↑n = ↑k ∧ k ≤ n}
state_after: case h
m k n : ℕ
⊢ (n ∈ Set.range fun n => m * n + k) ↔ n ∈ {n | ↑n = ↑k ∧ k ≤ n}
tactic: ext n
state_before: case h
m k n : ℕ
⊢ (n ∈ Set.range fun n => m * n + k) ↔ n ∈ {n | ↑n = ↑k ∧ k ≤ n}
state_after: case h
m k n : ℕ
⊢ (∃ y, m * y + k = n) ↔ ↑n = ↑k ∧ k ≤ n
tactic: simp only [Set.mem_range, Set.mem_setOf_eq]
state_before: case h
m k n : ℕ
⊢ (∃ y, m * y + k = n) ↔ ↑n = ↑k ∧ k ≤ n
state_after: case h
m k n : ℕ
⊢ (∃ y, n = k + m * y) ↔ ↑n = ↑k ∧ k ≤ n
tactic: conv => enter [1, 1, y]; rw [add_comm, eq_comm]
state_before: case h
m k n : ℕ
⊢ (∃ y, n = k + m * y) ↔ ↑n = ↑k ∧ k ≤ n
state_after: case h.refine_1
m k n : ℕ
x✝ : ∃ y, n = k + m * y
a : ℕ
ha : n = k + m * a
⊢ ↑n = ↑k

case h.refine_2
m k n : ℕ
x✝ : ↑n = ↑k ∧ k ≤ n
H₁ : ↑n = ↑k
H₂ : k ≤ n
⊢ ∃ y, n = k + m * y
tactic: refine ⟨fun ⟨a, ha⟩ ↦ ⟨?_, le_iff_exists_add.mpr ⟨_, ha⟩⟩, fun ⟨H₁, H₂⟩ ↦ ?_⟩
Theorem: Nat.unpair_zero
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: ⊢ unpair 0 = 0
state_after: ⊢ (let s := sqrt 0;
    if 0 - s * s < s then (0 - s * s, s) else (s, 0 - s * s - s)) =
    0
tactic: rw [unpair]
state_before: ⊢ (let s := sqrt 0;
    if 0 - s * s < s then (0 - s * s, s) else (s, 0 - s * s - s)) =
    0
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.absolutelyContinuous_isHaarMeasure
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
⊢ μ ≪ ν
state_after: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
⊢ μ ≪ ν
tactic: have K : PositiveCompacts G := Classical.arbitrary _
state_before: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
⊢ μ ≪ ν
state_after: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
h : haarMeasure K = ↑((haarMeasure K).haarScalarFactor ν) • ν
⊢ μ ≪ ν
tactic: have h : haarMeasure K = (haarScalarFactor (haarMeasure K) ν : ℝ≥0∞) • ν :=
    isMulLeftInvariant_eq_smul (haarMeasure K) ν
state_before: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
h : haarMeasure K = ↑((haarMeasure K).haarScalarFactor ν) • ν
⊢ μ ≪ ν
state_after: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
h : haarMeasure K = ↑((haarMeasure K).haarScalarFactor ν) • ν
⊢ (μ ↑K * ↑((haarMeasure K).haarScalarFactor ν)) • ν ≪ ν
tactic: rw [haarMeasure_unique μ K, h, smul_smul]
state_before: G : Type u_1
inst✝⁹ : TopologicalSpace G
inst✝⁸ : Group G
inst✝⁷ : TopologicalGroup G
inst✝⁶ : MeasurableSpace G
inst✝⁵ : BorelSpace G
inst✝⁴ : LocallyCompactSpace G
inst✝³ : SecondCountableTopology G
μ ν : Measure G
inst✝² : SigmaFinite μ
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsHaarMeasure
K : PositiveCompacts G
h : haarMeasure K = ↑((haarMeasure K).haarScalarFactor ν) • ν
⊢ (μ ↑K * ↑((haarMeasure K).haarScalarFactor ν)) • ν ≪ ν
state_after: no goals
tactic: exact AbsolutelyContinuous.smul (Eq.absolutelyContinuous rfl) _
Theorem: MeasureTheory.le_iInf_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ∫⁻ (a : α), ⨅ i, f i a ∂μ ≤ ⨅ i, ∫⁻ (a : α), f i a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ∫⁻ (a : α), (⨅ i, f i) a ∂μ ≤ ⨅ i, ∫⁻ (a : α), f i a ∂μ
tactic: simp only [← iInf_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_5
f : ι → α → ℝ≥0∞
⊢ ∫⁻ (a : α), (⨅ i, f i) a ∂μ ≤ ⨅ i, ∫⁻ (a : α), f i a ∂μ
state_after: no goals
tactic: exact (monotone_lintegral μ).map_iInf_le
Theorem: LieModule.injOn_weightSpace
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
⊢ InjOn (fun χ => weightSpace M χ) {χ | weightSpace M χ ≠ ⊥}
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₂ : χ₂ ∈ {χ | weightSpace M χ ≠ ⊥}
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
⊢ χ₁ = χ₂
tactic: rintro χ₁ _ χ₂ hχ₂ (hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂)
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₂ : χ₂ ∈ {χ | weightSpace M χ ≠ ⊥}
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
⊢ χ₁ = χ₂
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
hχ₂ : χ₁ ≠ χ₂
⊢ χ₂ ∉ {χ | weightSpace M χ ≠ ⊥}
tactic: contrapose! hχ₂
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
hχ₂ : χ₁ ≠ χ₂
⊢ χ₂ ∉ {χ | weightSpace M χ ≠ ⊥}
state_after: no goals
tactic: simpa [hχ₁₂] using disjoint_weightSpace R L M hχ₂
Theorem: Set.kernImage_union_preimage
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : Set α
t : Set β
⊢ kernImage f (s ∪ f ⁻¹' t) = kernImage f s ∪ t
state_after: no goals
tactic: rw [kernImage_eq_compl, kernImage_eq_compl, compl_union, ← preimage_compl, image_inter_preimage,
      compl_inter, compl_compl]
Theorem: AlgebraicTopology.DoldKan.Compatibility.equivalence₁UnitIso_eq
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

Proof steps:
state_before: A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_5, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{?u.18557, u_3} B
inst✝ : Category.{u_6, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
⊢ (equivalence₁ hF).unitIso = equivalence₁UnitIso hF
state_after: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_5, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{?u.18557, u_3} B
inst✝ : Category.{u_6, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X
tactic: ext X
state_before: case w.w.h
A : Type u_1
A' : Type u_2
B : Type u_3
B' : Type u_4
inst✝³ : Category.{u_5, u_1} A
inst✝² : Category.{u_7, u_2} A'
inst✝¹ : Category.{?u.18557, u_3} B
inst✝ : Category.{u_6, u_4} B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X
state_after: no goals
tactic: simp [equivalence₁]
Theorem: BoxIntegral.Prepartition.single_boxes
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I✝ J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I✝
x : ι → ℝ
I J : Box ι
h : J ≤ I
⊢ ∀ J_1 ∈ {J}, J_1 ≤ I
state_after: no goals
tactic: simpa
state_before: ι : Type u_1
I✝ J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I✝
x : ι → ℝ
I J : Box ι
h : J ≤ I
⊢ (↑{J}).Pairwise (Disjoint on Box.toSet)
state_after: no goals
tactic: simp
Theorem: Mathlib.Meta.NormNum.IsNat.to_isRat
File: Mathlib/Tactic/NormNum/Result.lean

Proof steps:
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ 1 * ↑1 = 1
state_after: no goals
tactic: simp
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑1 * 1 = 1
state_after: no goals
tactic: simp
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n✝ : ℕ
⊢ ↑n✝ = ↑(Int.ofNat n✝) * ⅟↑1
state_after: no goals
tactic: simp
Theorem: Int.fract_zero
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ fract 0 = 0
state_after: no goals
tactic: rw [fract, floor_zero, cast_zero, sub_self]
Theorem: CochainComplex.HomComplex.Cocycle.cochain_ofHom_homOf_eq_coe
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z : Cocycle F G 0
⊢ Cochain.ofHom z.homOf = ↑z
state_after: no goals
tactic: simpa only [Cocycle.ext_iff] using ofHom_homOf_eq_self z
Theorem: LSeriesHasSum_congr
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f g : ℕ → ℂ
s a : ℂ
h : ∀ {n : ℕ}, n ≠ 0 → f n = g n
⊢ LSeriesHasSum f s a ↔ LSeriesHasSum g s a
state_after: no goals
tactic: simp only [LSeriesHasSum_iff, LSeriesSummable_congr s h, LSeries_congr s h]
Theorem: MeasureTheory.eLpNorm_indicator_eq_restrict
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
s : Set α
hs : MeasurableSet s
⊢ eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
state_after: case inl
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
s : Set α
hs : MeasurableSet s
⊢ eLpNorm (s.indicator f) ⊤ μ = eLpNorm f ⊤ (μ.restrict s)

case inr
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
s : Set α
hs : MeasurableSet s
hp : p ≠ ⊤
⊢ eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s)
tactic: rcases eq_or_ne p ∞ with rfl | hp
Theorem: CategoryTheory.Subobject.arrow_congr
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
X Y : Subobject A
h : X = Y
⊢ eqToHom ⋯ ≫ Y.arrow = X.arrow
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
X Y : Subobject A
⊢ eqToHom ⋯ ≫ X.arrow = X.arrow
tactic: induction h
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
X Y : Subobject A
⊢ eqToHom ⋯ ≫ X.arrow = X.arrow
state_after: no goals
tactic: simp
Theorem: SemilatInfCat.Iso.mk_inv_toInfHom_toFun
File: Mathlib/Order/Category/Semilat.lean

Proof steps:
state_before: α β : SemilatInfCat
e : α.X ≃o β.X
⊢ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } = 𝟙 α
state_after: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj α
⊢ ({ toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : SemilatInfCat
e : α.X ≃o β.X
⊢ { toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ } = 𝟙 β
state_after: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : SemilatInfCat
e : α.X ≃o β.X
x✝ : (forget SemilatInfCat).obj β
⊢ ({ toFun := ⇑e.symm, map_inf' := ⋯, map_top' := ⋯ } ≫ { toFun := ⇑e, map_inf' := ⋯, map_top' := ⋯ }) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Num.castNum_shiftLeft
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m : Num
n : ℕ
⊢ ↑(m <<< n) = ↑m <<< n
state_after: case zero
α : Type u_1
n : ℕ
⊢ ↑0 = ↑zero <<< n

case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(pos (a✝ <<< n)) = ↑(pos a✝) <<< n
tactic: cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
state_before: case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(pos (a✝ <<< n)) = ↑(pos a✝) <<< n
state_after: case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(a✝ <<< n) = ↑a✝ <<< n
tactic: simp only [cast_pos]
state_before: case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(a✝ <<< n) = ↑a✝ <<< n
state_after: case pos.zero
α : Type u_1
a✝ : PosNum
⊢ ↑(a✝ <<< 0) = ↑a✝ <<< 0

case pos.succ
α : Type u_1
a✝ : PosNum
n : ℕ
IH : ↑(a✝ <<< n) = ↑a✝ <<< n
⊢ ↑(a✝ <<< (n + 1)) = ↑a✝ <<< (n + 1)
tactic: induction' n with n IH
state_before: case pos.succ
α : Type u_1
a✝ : PosNum
n : ℕ
IH : ↑(a✝ <<< n) = ↑a✝ <<< n
⊢ ↑(a✝ <<< (n + 1)) = ↑a✝ <<< (n + 1)
state_after: no goals
tactic: simp [PosNum.shiftl_succ_eq_bit0_shiftl, Nat.shiftLeft_succ, IH, pow_succ, ← mul_assoc, mul_comm,
        -shiftl_eq_shiftLeft, -PosNum.shiftl_eq_shiftLeft, shiftl, mul_two]
Theorem: CategoryTheory.Reflective.comparison_full
File: Mathlib/CategoryTheory/Monad/Adjunction.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L✝ : C ⥤ D
R : D ⥤ C
inst✝ : R.Full
L : C ⥤ D
adj : L ⊣ R
X✝ Y✝ : D
f : (Monad.comparison adj).obj X✝ ⟶ (Monad.comparison adj).obj Y✝
⊢ (Monad.comparison adj).map (R.preimage f.f) = f
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.ComposableArrows.Precomp.map_zero_one'
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.96531, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ F.left
⊢ 0 + 1 < n + 1 + 1
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝ : Category.{?u.96531, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ F.left
⊢ 0 ≤ ⟨0 + 1, ⋯⟩
state_after: no goals
tactic: simp