ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.infix_cons_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂
state_after: case mp
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+: a :: l₂ → l₁ <+: a :: l₂ ∨ l₁ <:+: l₂

case mpr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂ → l₁ <:+: a :: l₂
tactic: constructor
Theorem: CliffordAlgebraQuaternion.toQuaternion_star
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (star c) = star (toQuaternion c)
state_after: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (involute (reverse c)) = star (toQuaternion c)
tactic: simp only [CliffordAlgebra.star_def']
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
c : CliffordAlgebra (Q c₁ c₂)
⊢ toQuaternion (involute (reverse c)) = star (toQuaternion c)
state_after: no goals
tactic: induction c using CliffordAlgebra.induction with
  | algebraMap r =>
    simp only [reverse.commutes, AlgHom.commutes, QuaternionAlgebra.coe_algebraMap,
      QuaternionAlgebra.star_coe]
  | ι x =>
    rw [reverse_ι, involute_ι, toQuaternion_ι, map_neg, toQuaternion_ι,
      QuaternionAlgebra.neg_mk, star_mk, neg_zero]
  | mul x₁ x₂ hx₁ hx₂ => simp only [reverse.map_mul, map_mul, hx₁, hx₂, star_mul]
  | add x₁ x₂ hx₁ hx₂ => simp only [reverse.map_add, map_add, hx₁, hx₂, star_add]
Theorem: Pretrivialization.apply_mk_symm
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y✝ : E b✝
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
b : B
hb : b ∈ e.baseSet
y : F
⊢ ↑e { proj := b, snd := e.symm b y } = (b, y)
state_after: no goals
tactic: rw [e.mk_symm hb, e.apply_symm_apply (e.mk_mem_target.mpr hb)]
Theorem: CategoryTheory.Monad.ofMon_η
File: Mathlib/CategoryTheory/Monad/EquivMon.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.one.app (M.X.obj X) ≫ M.mul.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.rightUnitor M.X).hom.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
tactic: erw [← whiskerLeft_app, ← NatTrans.comp_app, M.mul_one]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.rightUnitor M.X).hom.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
state_after: no goals
tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.X.map (M.one.app X) ≫ M.mul.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.leftUnitor M.X).hom.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
tactic: erw [← whiskerRight_app, ← NatTrans.comp_app, M.one_mul]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.leftUnitor M.X).hom.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
state_after: no goals
tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.X.map (M.mul.app X) ≫ M.mul.app X = M.mul.app (M.X.obj X) ≫ M.mul.app X
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (whiskerRight M.mul M.X ≫ M.mul).app X = (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
tactic: rw [← whiskerLeft_app, ← whiskerRight_app, ← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (whiskerRight M.mul M.X ≫ M.mul).app X = (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ ((MonoidalCategory.associator M.X M.X M.X).hom ≫ MonoidalCategory.whiskerLeft M.X M.mul ≫ M.mul).app X =
    (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
tactic: erw [M.mul_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ ((MonoidalCategory.associator M.X M.X M.X).hom ≫ MonoidalCategory.whiskerLeft M.X M.mul ≫ M.mul).app X =
    (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.inr_comp_pushoutSymmetry_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : HasPushout f g
⊢ pushout.inr g f ≫ (pushoutSymmetry f g).inv = pushout.inl f g
state_after: no goals
tactic: simp [Iso.comp_inv_eq]
Theorem: PadicInt.exists_pow_neg_lt_rat
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
tactic: obtain ⟨k, hk⟩ := @exists_pow_neg_lt p _ ε (mod_cast hε)
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
tactic: use k
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
tactic: rw [show (p : ℝ) = (p : ℚ) by simp] at hk
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℚ
hε : 0 < ε
k : ℕ
hk : ↑↑p ^ (-↑k) < ↑ε
⊢ ↑p ^ (-↑k) < ε
state_after: no goals
tactic: exact mod_cast hk
Theorem: HasDerivAt.clog
File: Mathlib/Analysis/SpecialFunctions/Complex/LogDeriv.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasDerivAt (fun t => log (f t)) (f' / f x) x
state_after: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x
tactic: rw [div_eq_inv_mul]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h₁ : HasDerivAt f f' x
h₂ : f x ∈ slitPlane
⊢ HasDerivAt (fun t => log (f t)) ((f x)⁻¹ * f') x
state_after: no goals
tactic: exact (hasStrictDerivAt_log h₂).hasDerivAt.comp x h₁
Theorem: realPart_ofReal
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ ↑(ℜ ↑r) = ↑r
state_after: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ 2⁻¹ • 2 • ↑r = ↑r
tactic: rw [realPart_apply_coe, star_def, conj_ofReal, ← two_smul ℝ (r : ℂ)]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ 2⁻¹ • 2 • ↑r = ↑r
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.sum_coe_finset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
s : Finset ι
μ : ι → Measure α
⊢ (sum fun i => μ ↑i) = ∑ i ∈ s, μ i
state_after: no goals
tactic: rw [sum_fintype, Finset.sum_coe_sort s μ]
Theorem: CategoryTheory.Limits.isIso_ι_of_isTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
⊢ colimit.ι F j ≫ colimit.desc F (coconeOfDiagramTerminal I F) = 𝟙 (F.obj j)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
⊢ colimit.desc F (coconeOfDiagramTerminal I F) ≫ colimit.ι F j = 𝟙 (colimit F)
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
j✝ : J
⊢ colimit.ι F j✝ ≫ colimit.desc F (coconeOfDiagramTerminal I F) ≫ colimit.ι F j = colimit.ι F j✝ ≫ 𝟙 (colimit F)
tactic: ext
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsTerminal j
F : J ⥤ C
inst✝ : HasColimit F
j✝ : J
⊢ colimit.ι F j✝ ≫ colimit.desc F (coconeOfDiagramTerminal I F) ≫ colimit.ι F j = colimit.ι F j✝ ≫ 𝟙 (colimit F)
state_after: no goals
tactic: simp
Theorem: AdjoinRoot.minpoly_root
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
⊢ minpoly K (root f) = f * C f.leadingCoeff⁻¹
state_after: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
⊢ minpoly K (root f) = f * C f.leadingCoeff⁻¹
tactic: have f'_monic : Monic _ := monic_mul_leadingCoeff_inv hf
state_before: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
⊢ minpoly K (root f) = f * C f.leadingCoeff⁻¹
state_after: case refine_1
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
⊢ (aeval (root f)) (f * C f.leadingCoeff⁻¹) = 0

case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
⊢ ∀ (q : K[X]), q.Monic → (aeval (root f)) q = 0 → (f * C f.leadingCoeff⁻¹).degree ≤ q.degree
tactic: refine (minpoly.unique K _ f'_monic ?_ ?_).symm
state_before: case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
⊢ ∀ (q : K[X]), q.Monic → (aeval (root f)) q = 0 → (f * C f.leadingCoeff⁻¹).degree ≤ q.degree
state_after: case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
q : K[X]
q_monic : q.Monic
q_aeval : (aeval (root f)) q = 0
⊢ (f * C f.leadingCoeff⁻¹).degree ≤ q.degree
tactic: intro q q_monic q_aeval
state_before: case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
q : K[X]
q_monic : q.Monic
q_aeval : (aeval (root f)) q = 0
commutes : (lift (algebraMap K (AdjoinRoot f)) (root f) q_aeval).comp (mk q) = mk f
⊢ (f * C f.leadingCoeff⁻¹).degree ≤ q.degree
state_after: case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
q : K[X]
q_monic : q.Monic
q_aeval : (aeval (root f)) q = 0
commutes : (lift (algebraMap K (AdjoinRoot f)) (root f) q_aeval).comp (mk q) = mk f
⊢ f.natDegree ≤ q.natDegree

case refine_2
R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
f'_monic : (f * C f.leadingCoeff⁻¹).Monic
q : K[X]
q_monic : q.Monic
q_aeval : (aeval (root f)) q = 0
commutes : (lift (algebraMap K (AdjoinRoot f)) (root f) q_aeval).comp (mk q) = mk f
⊢ C f.leadingCoeff⁻¹ ≠ 0
tactic: rw [degree_eq_natDegree f'_monic.ne_zero, degree_eq_natDegree q_monic.ne_zero,
    Nat.cast_le, natDegree_mul hf, natDegree_C, add_zero]
Theorem: ContinuousLinearMap.continuous_det
File: Mathlib/Analysis/Normed/Module/FiniteDimension.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
⊢ Continuous fun f => f.det
state_after: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
⊢ Continuous fun f => LinearMap.det ↑f
tactic: change Continuous fun f : E →L[𝕜] E => LinearMap.det (f : E →ₗ[𝕜] E)
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
⊢ Continuous fun f => LinearMap.det ↑f
state_after: case pos
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ∃ s, Nonempty (Basis { x // x ∈ s } 𝕜 E)
⊢ Continuous fun f => LinearMap.det ↑f

case neg
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
h : ¬∃ s, Nonempty (Basis { x // x ∈ s } 𝕜 E)
⊢ Continuous fun f => LinearMap.det ↑f
tactic: by_cases h : ∃ s : Finset E, Nonempty (Basis (↥s) 𝕜 E)
Theorem: HomologicalComplex.iCycles_d
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝ : K.HasHomology i
⊢ K.iCycles i ≫ K.d i j = 0
state_after: case pos
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝ : K.HasHomology i
hij : c.Rel i j
⊢ K.iCycles i ≫ K.d i j = 0

case neg
C : Type u_1
inst✝² : Category.{u_3, u_1} C
inst✝¹ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝ : K.HasHomology i
hij : ¬c.Rel i j
⊢ K.iCycles i ≫ K.d i j = 0
tactic: by_cases hij : c.Rel i j
Theorem: Filter.principal_le_iff
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t s : Set α
f : Filter α
⊢ 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V
state_after: no goals
tactic: simp_rw [le_def, mem_principal]
Theorem: ONote.repr_scale
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: x : ONote
inst✝¹ : x.NF
o : ONote
inst✝ : o.NF
⊢ (x.scale o).repr = ω ^ x.repr * o.repr
state_after: no goals
tactic: simp only [scale_eq_mul, repr_mul, repr, PNat.one_coe, Nat.cast_one, mul_one, add_zero]
Theorem: CompleteLattice.independent_pair
File: Mathlib/Order/SupIndep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Independent t ↔ Disjoint (t i) (t j)
state_after: case mp
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Independent t → Disjoint (t i) (t j)

case mpr
α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Disjoint (t i) (t j) → Independent t
tactic: constructor
Theorem: Real.tendsto_cos_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Tendsto cos (𝓝[<] (π / 2)) (𝓝[>] 0)
state_after: case h1

⊢ Tendsto cos (𝓝[<] (π / 2)) (𝓝 0)

case h2

⊢ ∀ᶠ (x : ℝ) in 𝓝[<] (π / 2), cos x ∈ Ioi 0
tactic: apply tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within
Theorem: quadraticChar_one_iff_isSquare
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
a : F
ha : a ≠ 0
⊢ (quadraticChar F) a = 1 ↔ IsSquare a
state_after: no goals
tactic: simp only [quadraticChar_apply, quadraticCharFun, ha, if_false, ite_eq_left_iff,
    (by omega : (-1 : ℤ) ≠ 1), imp_false, not_not]
Theorem: CochainComplex.HomComplex.Cochain.map_ofHom
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 : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ (ofHom f).map Φ = ofHom ((Φ.mapHomologicalComplex (ComplexShape.up ℤ)).map f)
state_after: no goals
tactic: aesop_cat
Theorem: inner_self_eq_norm_mul_norm
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 : E
⊢ re ⟪x, x⟫_𝕜 = ‖x‖ * ‖x‖
state_after: no goals
tactic: rw [@norm_eq_sqrt_inner 𝕜, ← sqrt_mul inner_self_nonneg (re ⟪x, x⟫),
    sqrt_mul_self inner_self_nonneg]
Theorem: multipliable_mabs_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : LinearOrderedCommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
inst✝ : CompleteSpace α
f : ι → α
s : Set ι := {x | 1 ≤ f x}
h1 : ∀ (x : ↑s), mabs (f ↑x) = f ↑x
h2 : ∀ (x : ↑sᶜ), mabs (f ↑x) = (f ↑x)⁻¹
⊢ ((Multipliable fun x => mabs (f ↑x)) ∧ Multipliable fun x => mabs (f ↑x)) ↔
    (Multipliable fun x => f ↑x) ∧ Multipliable fun x => (f ↑x)⁻¹
state_after: no goals
tactic: simp only [h1, h2]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : LinearOrderedCommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
inst✝ : CompleteSpace α
f : ι → α
s : Set ι := {x | 1 ≤ f x}
h1 : ∀ (x : ↑s), mabs (f ↑x) = f ↑x
h2 : ∀ (x : ↑sᶜ), mabs (f ↑x) = (f ↑x)⁻¹
⊢ ((Multipliable fun x => f ↑x) ∧ Multipliable fun x => (f ↑x)⁻¹) ↔ Multipliable f
state_after: no goals
tactic: simp only [multipliable_inv_iff, multipliable_subtype_and_compl]
Theorem: FreeGroup.lift_eq_prod_map
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ (lift f) x = prod ((map f) x)
state_after: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ (prod.comp (map f)) x = prod ((map f) x)

case hg
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
inst✝ : Group β
f : α → β
x : FreeGroup α
⊢ ∀ (x : α), (prod.comp (map f)) (of x) = f x
tactic: rw [← lift.unique (prod.comp (map f))]
Theorem: Finset.cast_card_union
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
inst✝¹ : DecidableEq α
inst✝ : AddGroupWithOne R
⊢ ↑(s ∪ t).card = ↑s.card + ↑t.card - ↑(s ∩ t).card
state_after: no goals
tactic: rw [eq_sub_iff_add_eq, ← cast_add, card_union_add_card_inter, cast_add]
Theorem: IsSl2Triple.HasPrimitiveVectorWith.lie_e_pow_succ_toEnd_f
File: Mathlib/Algebra/Lie/Sl2.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h e f : L
m : M
μ : R
t : IsSl2Triple h e f
P : t.HasPrimitiveVectorWith m μ
n : ℕ
⊢ ⁅e, ((toEnd R L M) f ^ (n + 1)) m⁆ = ((↑n + 1) * (μ - ↑n)) • ((toEnd R L M) f ^ n) m
state_after: case zero
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h e f : L
m : M
μ : R
t : IsSl2Triple h e f
P : t.HasPrimitiveVectorWith m μ
⊢ ⁅e, ((toEnd R L M) f ^ (0 + 1)) m⁆ = ((↑0 + 1) * (μ - ↑0)) • ((toEnd R L M) f ^ 0) m

case succ
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h e f : L
m : M
μ : R
t : IsSl2Triple h e f
P : t.HasPrimitiveVectorWith m μ
n : ℕ
ih : ⁅e, ((toEnd R L M) f ^ (n + 1)) m⁆ = ((↑n + 1) * (μ - ↑n)) • ((toEnd R L M) f ^ n) m
⊢ ⁅e, ((toEnd R L M) f ^ (n + 1 + 1)) m⁆ = ((↑(n + 1) + 1) * (μ - ↑(n + 1))) • ((toEnd R L M) f ^ (n + 1)) m
tactic: induction' n with n ih
Theorem: MvPFunctor.comp.mk_get
File: Mathlib/Data/PFunctor/Multivariate/Basic.lean

Proof steps:
state_before: n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α β : TypeVec.{u} m
x : ↑(P.comp Q) α
⊢ mk (get x) = x
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.setIntegral_compProd_univ_left
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : NormedAddCommGroup E
κ : Kernel α β
inst✝⁵ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝⁴ : IsSFiniteKernel η
a : α
inst✝³ : NormedSpace ℝ E
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : β × γ → E
t : Set γ
ht : MeasurableSet t
hf : IntegrableOn f (univ ×ˢ t) ((κ ⊗ₖ η) a)
⊢ ∫ (z : β × γ) in univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ (x : β), ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
tactic: simp_rw [setIntegral_compProd MeasurableSet.univ ht hf, Measure.restrict_univ]
Theorem: List.aestronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : List (α → M)
hl : ∀ f ∈ l, AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => (List.map (fun f => f x) l).prod) μ
state_after: no goals
tactic: simpa only [← Pi.list_prod_apply] using l.aestronglyMeasurable_prod' hl
Theorem: MeasurableEquiv.eq_image_iff_symm_image_eq
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set β
t : Set α
⊢ s = ⇑e '' t ↔ ⇑e.symm '' s = t
state_after: no goals
tactic: rw [← coe_toEquiv, Equiv.eq_image_iff_symm_image_eq, coe_toEquiv_symm]
Theorem: Int.dist_cast_rat
File: Mathlib/Topology/Instances/Rat.lean

Proof steps:
state_before: x y : ℤ
⊢ dist ↑x ↑y = dist x y
state_after: x y : ℤ
⊢ dist ↑↑x ↑↑y = dist ↑x ↑y
tactic: rw [← Int.dist_cast_real, ← Rat.dist_cast]
state_before: x y : ℤ
⊢ dist ↑↑x ↑↑y = dist ↑x ↑y
state_after: no goals
tactic: congr