ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.deriv2_negMulLog
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv^[2] negMulLog x = -x⁻¹
state_after: x : ℝ
hx : x ≠ 0
⊢ deriv^[2] (fun x => -(x * log x)) x = -x⁻¹
tactic: rw [negMulLog_eq_neg]
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv^[2] (fun x => -(x * log x)) x = -x⁻¹
state_after: x : ℝ
hx : x ≠ 0
h : deriv^[2] (fun x => x * log x) x = x⁻¹
⊢ deriv^[2] (fun x => -(x * log x)) x = -x⁻¹
tactic: have h := deriv2_mul_log hx
state_before: x : ℝ
hx : x ≠ 0
h : deriv^[2] (fun x => x * log x) x = x⁻¹
⊢ deriv^[2] (fun x => -(x * log x)) x = -x⁻¹
state_after: x : ℝ
hx : x ≠ 0
h : deriv (deriv fun x => x * log x) x = x⁻¹
⊢ -deriv (deriv fun y => y * log y) x = -x⁻¹
tactic: simp only [Function.iterate_succ, Function.iterate_zero, Function.id_comp,
    Function.comp_apply, deriv.neg', differentiableAt_id', differentiableAt_log_iff, ne_eq] at h ⊢
state_before: x : ℝ
hx : x ≠ 0
h : deriv (deriv fun x => x * log x) x = x⁻¹
⊢ -deriv (deriv fun y => y * log y) x = -x⁻¹
state_after: no goals
tactic: rw [h]
Theorem: Num.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : Num
⊢ ↑m = ↑n ↔ m = n
state_after: no goals
tactic: rw [← cast_to_nat m, ← cast_to_nat n, Nat.cast_inj, to_nat_inj]
Theorem: Set.not_subsingleton_iff
File: Mathlib/Data/Set/Subsingleton.lean

Proof steps:
state_before: α : Type u
a : α
s t : Set α
⊢ ¬s.Subsingleton ↔ s.Nontrivial
state_after: no goals
tactic: simp_rw [Set.Subsingleton, Set.Nontrivial, not_forall, exists_prop]
Theorem: Function.Antiperiodic.div
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝² : Add α
inst✝¹ : DivisionMonoid β
inst✝ : HasDistribNeg β
hf : Antiperiodic f c
hg : Antiperiodic g c
⊢ Periodic (f / g) c
state_after: no goals
tactic: simp_all [neg_div_neg_eq]
Theorem: smul_neg_of_neg_of_pos
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : Zero α
inst✝⁴ : Zero β
inst✝³ : SMulWithZero α β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : SMulPosStrictMono α β
ha : a < 0
hb : 0 < b
⊢ a • b < 0
state_after: no goals
tactic: simpa only [zero_smul] using smul_lt_smul_of_pos_right ha hb
Theorem: Subgroup.index_inf_le
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ (H ⊓ K).index ≤ H.index * K.index
state_after: no goals
tactic: simp_rw [← relindex_top_right, relindex_inf_le]
Theorem: CategoryTheory.Limits.isIsoZeroEquiv_apply
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ IsIso 0 → 𝟙 X = 0 ∧ 𝟙 Y = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0
tactic: intro i
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ 𝟙 Y = 0
tactic: rw [← IsIso.hom_inv_id (0 : X ⟶ Y)]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ 𝟙 Y = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ inv 0 ≫ 0 = 0
tactic: rw [← IsIso.inv_hom_id (0 : X ⟶ Y)]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ inv 0 ≫ 0 = 0
state_after: no goals
tactic: simp only [eq_self_iff_true,comp_zero,and_self,zero_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
h : 𝟙 X = 0 ∧ 𝟙 Y = 0
⊢ 0 ≫ 0 = 𝟙 X ∧ 0 ≫ 0 = 𝟙 Y
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ Function.LeftInverse ⋯ ⋯
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ Function.RightInverse ⋯ ⋯
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.ShortComplex.opMap_τ₁
File: Mathlib/Algebra/Homology/ShortComplex/Basic.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₃.op ≫ S₁.op.f = S₂.op.f ≫ φ.τ₂.op
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₃.op ≫ S₁.g.op = S₂.g.op ≫ φ.τ₂.op
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₃.op ≫ S₁.g.op = S₂.g.op ≫ φ.τ₂.op
state_after: no goals
tactic: simp only [← op_comp, φ.comm₂₃]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₂.op ≫ S₁.op.g = S₂.op.g ≫ φ.τ₁.op
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₂.op ≫ S₁.f.op = S₂.f.op ≫ φ.τ₁.op
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.59011, u_1} C
inst✝² : Category.{?u.59015, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
φ : S₁ ⟶ S₂
⊢ φ.τ₂.op ≫ S₁.f.op = S₂.f.op ≫ φ.τ₁.op
state_after: no goals
tactic: simp only [← op_comp, φ.comm₁₂]
Theorem: rel_sup_add
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s₁ s₂ : α
⊢ R (m (s₁ ⊔ s₂)) (m s₁ * m s₂)
state_after: case h.e'_1.h.e'_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s₁ s₂ : α
⊢ s₁ ⊔ s₂ = ⨆ b, bif b then s₁ else s₂

case h.e'_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s₁ s₂ : α
⊢ m s₁ * m s₂ = ∏' (b : Bool), m (bif b then s₁ else s₂)
tactic: convert rel_iSup_tprod m m0 R m_iSup fun b ↦ cond b s₁ s₂
Theorem: BoolRing.Iso.mk_inv
File: Mathlib/Algebra/Category/BoolRing.lean

Proof steps:
state_before: α β : BoolRing
e : ↑α ≃+* ↑β
⊢ ↑e ≫ ↑e.symm = 𝟙 α
state_after: case w
α β : BoolRing
e : ↑α ≃+* ↑β
x✝ : (forget BoolRing).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : BoolRing
e : ↑α ≃+* ↑β
x✝ : (forget BoolRing).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : BoolRing
e : ↑α ≃+* ↑β
⊢ ↑e.symm ≫ ↑e = 𝟙 β
state_after: case w
α β : BoolRing
e : ↑α ≃+* ↑β
x✝ : (forget BoolRing).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : BoolRing
e : ↑α ≃+* ↑β
x✝ : (forget BoolRing).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Polynomial.coeff_C_mul
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ (C a * p).coeff n = a * p.coeff n
state_after: case ofFinsupp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
p : R[ℕ]
⊢ (C a * { toFinsupp := p }).coeff n = a * { toFinsupp := p }.coeff n
tactic: rcases p with ⟨p⟩
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
p : R[ℕ]
⊢ (C a * { toFinsupp := p }).coeff n = a * { toFinsupp := p }.coeff n
state_after: case ofFinsupp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
p : R[ℕ]
⊢ (Finsupp.single 0 a * p) n = a * p n
tactic: simp_rw [← monomial_zero_left, ← ofFinsupp_single, ← ofFinsupp_mul, coeff]
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
p : R[ℕ]
⊢ (Finsupp.single 0 a * p) n = a * p n
state_after: no goals
tactic: exact AddMonoidAlgebra.single_zero_mul_apply p a n
Theorem: multiplesEquivMultiples_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (powersEquivPowers h) ⟨x ^ n, ⋯⟩ = ⟨y ^ n, ⋯⟩
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩
tactic: rw [powersEquivPowers, Equiv.trans_apply, Equiv.trans_apply, finEquivPowers_symm_apply, ←
    Equiv.eq_symm_apply, finEquivPowers_symm_apply]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LeftCancelMonoid G
inst✝ : Finite G
x y : G
n✝ : ℕ
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩
state_after: no goals
tactic: simp [h]
Theorem: Algebra.Generators.Hom.sub_one_tmul
File: Mathlib/RingTheory/Kaehler/CotangentComplex.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹⁴ : CommRing R
inst✝¹³ : CommRing S
inst✝¹² : Algebra R S
P : Generators R S
R' : Type u'
S' : Type v'
inst✝¹¹ : CommRing R'
inst✝¹⁰ : CommRing S'
inst✝⁹ : Algebra R' S'
P' : Generators R' S'
inst✝⁸ : Algebra R R'
inst✝⁷ : Algebra S S'
inst✝⁶ : Algebra R S'
inst✝⁵ : IsScalarTower R R' S'
inst✝⁴ : IsScalarTower R S S'
T : Type uT
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
f g : P.Hom P'
x : P.Ring
⊢ (f.sub g) (1 ⊗ₜ[P.Ring] (D R P.Ring) x) = Cotangent.mk ((f.subToKer g) x)
state_after: no goals
tactic: simp only [sub, LinearMap.liftBaseChange_tmul, Derivation.liftKaehlerDifferential_comp_D,
    Derivation.mk_coe, LinearMap.coe_comp, LinearMap.coe_restrictScalars, Function.comp_apply,
    one_smul]
Theorem: ZMod.cast_add
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
h : m ∣ n
a b : ZMod n
⊢ (a + b).cast = a.cast + b.cast
state_after: case zero
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
h : m ∣ 0
a b : ZMod 0
⊢ (a + b).cast = a.cast + b.cast

case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ (a + b).cast = a.cast + b.cast
tactic: cases n
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ (a + b).cast = a.cast + b.cast
state_after: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ a.cast + b.cast = (a + b).cast
tactic: symm
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ a.cast + b.cast = (a + b).cast
state_after: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ ↑a.val + ↑b.val = ↑(val (a + b))
tactic: dsimp [ZMod, ZMod.cast]
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ ↑a.val + ↑b.val = ↑(val (a + b))
state_after: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ m ∣ a.val + b.val - (a.val + b.val) % n✝.succ
tactic: erw [← Nat.cast_add, ← sub_eq_zero, ← Nat.cast_sub (Nat.mod_le _ _),
    @CharP.cast_eq_zero_iff R _ m]
state_before: case succ
R : Type u_1
inst✝¹ : Ring R
m : ℕ
inst✝ : CharP R m
n✝ : ℕ
h : m ∣ n✝ + 1
a b : ZMod (n✝ + 1)
⊢ m ∣ a.val + b.val - (a.val + b.val) % n✝.succ
state_after: no goals
tactic: exact h.trans (Nat.dvd_sub_mod _)
Theorem: CliffordAlgebra.map_mul_map_of_isOrtho_of_mem_evenOdd
File: Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
f₁ : Q₁ →qᵢ Qₙ
f₂ : Q₂ →qᵢ Qₙ
hf : ∀ (x : M₁) (y : M₂), QuadraticMap.IsOrtho Qₙ (f₁ x) (f₂ y)
m₁ : CliffordAlgebra Q₁
m₂ : CliffordAlgebra Q₂
i₁ i₂ : ZMod 2
hm₁ : m₁ ∈ evenOdd Q₁ i₁
hm₂ : m₂ ∈ evenOdd Q₂ i₂
⊢ (map f₁) m₁ * (map f₂) m₂ = (-1) ^ (i₂ * i₁) • ((map f₂) m₂ * (map f₁) m₁)
state_after: no goals
tactic: induction hm₁ using Submodule.iSup_induction' with
  | zero => rw [map_zero, zero_mul, mul_zero, smul_zero]
  | add _ _ _ _ ihx ihy => rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
  | mem i₁' m₁' hm₁ =>
    obtain ⟨i₁n, rfl⟩ := i₁'
    dsimp only at *
    induction hm₁ using Submodule.pow_induction_on_left' with
    | algebraMap =>
      rw [AlgHom.commutes, Nat.cast_zero, mul_zero, uzpow_zero, one_smul, Algebra.commutes]
    | add _ _ _ _ _ ihx ihy =>
      rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
    | mem_mul m₁ hm₁ i x₁ _hx₁ ih₁ =>
      obtain ⟨v₁, rfl⟩ := hm₁
      -- this is the first interesting goal
      rw [map_mul, mul_assoc, ih₁, mul_smul_comm, map_apply_ι, Nat.cast_succ, mul_add_one,
        uzpow_add, mul_smul, ← mul_assoc, ← mul_assoc, ← smul_mul_assoc ((-1) ^ i₂)]
      clear ih₁
      congr 2
      induction hm₂ using Submodule.iSup_induction' with
      | zero => rw [map_zero, zero_mul, mul_zero, smul_zero]
      | add _ _ _ _ ihx ihy => rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
      | mem i₂' m₂' hm₂ =>
        clear m₂
        obtain ⟨i₂n, rfl⟩ := i₂'
        dsimp only at *
        induction hm₂ using Submodule.pow_induction_on_left' with
        | algebraMap =>
          rw [AlgHom.commutes, Nat.cast_zero, uzpow_zero, one_smul, Algebra.commutes]
        | add _ _ _ _ _ ihx ihy =>
          rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
        | mem_mul m₂ hm₂ i x₂ _hx₂ ih₂ =>
          obtain ⟨v₂, rfl⟩ := hm₂
          -- this is the second interesting goal
          rw [map_mul, map_apply_ι, Nat.cast_succ, ← mul_assoc,
            ι_mul_ι_comm_of_isOrtho (hf _ _), neg_mul, mul_assoc, ih₂, mul_smul_comm,
            ← mul_assoc, ← Units.neg_smul, uzpow_add, uzpow_one, mul_neg_one]
Theorem: Turing.Tape.move_left_right
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ move Dir.right (move Dir.left T) = T
state_after: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.right (move Dir.left { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
tactic: cases T
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.right (move Dir.left { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
state_after: no goals
tactic: simp [Tape.move]
Theorem: CliffordAlgebra.changeForm_ι
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 Q' Q'' : QuadraticForm R M
B B' : BilinForm R M
h : BilinMap.toQuadraticMap B = Q' - Q
h' : BilinMap.toQuadraticMap B' = Q'' - Q'
m : M
⊢ (ι Q') m = ((changeFormAux Q' B) m) 1
state_after: no goals
tactic: rw [changeFormAux_apply_apply, mul_one, contractLeft_one, sub_zero]
Theorem: mem_ball_iff_norm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ ball a r ↔ ‖a / b‖ < r
state_after: no goals
tactic: rw [mem_ball', dist_eq_norm_div]
Theorem: Ordnode.insert'.valid
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : t.Valid
⊢ (insert' x t).Valid
state_after: α : Type u_1
inst✝² : Preorder α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : t.Valid
⊢ (insertWith id x t).Valid
tactic: rw [insert'_eq_insertWith]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : t.Valid
⊢ (insertWith id x t).Valid
state_after: no goals
tactic: exact insertWith.valid _ _ (fun _ => id) h
Theorem: Polynomial.iterate_derivative_X_sub_pow_self
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
n : ℕ
c : R
⊢ (⇑derivative)^[n] ((X - C c) ^ n) = ↑n.factorial
state_after: no goals
tactic: rw [iterate_derivative_X_sub_pow, n.sub_self, pow_zero, nsmul_one, n.descFactorial_self]
Theorem: RatFunc.ofFractionRing_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : FractionRing K[X]
⊢ { toFractionRing := p / q } = { toFractionRing := p } / { toFractionRing := q }
state_after: no goals
tactic: simp only [Div.div, HDiv.hDiv, RatFunc.div]
Theorem: Affine.Simplex.affineSpan_pair_eq_altitude_iff
File: Mathlib/Geometry/Euclidean/MongePoint.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ affineSpan ℝ {p, s.points i} = s.altitude i ↔
    p ≠ s.points i ∧
      p ∈ affineSpan ℝ (Set.range s.points) ∧ p -ᵥ s.points i ∈ (affineSpan ℝ (s.points '' ↑(univ.erase i))).directionᗮ
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ vectorSpan ℝ {p, s.points i} = (s.altitude i).direction ↔
    p ≠ s.points i ∧
      p -ᵥ s.points i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ s.points i ∈ (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ
tactic: rw [eq_iff_direction_eq_of_mem (mem_affineSpan ℝ (Set.mem_insert_of_mem _ (Set.mem_singleton _)))
      (s.mem_altitude _),
    ← vsub_right_mem_direction_iff_mem (mem_affineSpan ℝ (Set.mem_range_self i)) p,
    direction_affineSpan, direction_affineSpan, direction_affineSpan]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ vectorSpan ℝ {p, s.points i} = (s.altitude i).direction ↔
    p ≠ s.points i ∧
      p -ᵥ s.points i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ s.points i ∈ (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ
state_after: case mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ vectorSpan ℝ {p, s.points i} = (s.altitude i).direction →
    p ≠ s.points i ∧
      p -ᵥ s.points i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ s.points i ∈ (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ

case mpr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ p ≠ s.points i ∧
      p -ᵥ s.points i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ s.points i ∈ (vectorSpan ℝ (s.points '' ↑(univ.erase i)))ᗮ →
    vectorSpan ℝ {p, s.points i} = (s.altitude i).direction
tactic: constructor
Theorem: AddSubmonoid.coe_iInf
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S✝ : Submonoid M
ι : Sort u_4
S : ι → Submonoid M
⊢ ↑(⨅ i, S i) = ⋂ i, ↑(S i)
state_after: no goals
tactic: simp only [iInf, coe_sInf, Set.biInter_range]
Theorem: RingCon.sSup_def
File: Mathlib/RingTheory/Congruence/Basic.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
⊢ sSup S = ringConGen (sSup (DFunLike.coe '' S))
state_after: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
⊢ (ringConGen fun x y => ∃ c ∈ S, c x y) = ringConGen (⨆ a ∈ S, ⇑a)
tactic: rw [sSup_eq_ringConGen, sSup_image]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
⊢ (ringConGen fun x y => ∃ c ∈ S, c x y) = ringConGen (⨆ a ∈ S, ⇑a)
state_after: case e_r.h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x y : R
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y
tactic: congr with (x y)
state_before: case e_r.h.h.a
α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x y : R
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y
state_after: no goals
tactic: simp only [sSup_image, iSup_apply, iSup_Prop_eq, exists_prop, rel_eq_coe]
Theorem: LieSubmodule.lowerCentralSeries_map_eq_lcs
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
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
k : ℕ
N : LieSubmodule R L M
⊢ map N.incl (lowerCentralSeries R L (↥↑N) k) = lcs k N
state_after: R : Type u
L : Type v
M : Type w
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
k : ℕ
N : LieSubmodule R L M
⊢ lcs k N ≤ N
tactic: rw [lowerCentralSeries_eq_lcs_comap, LieSubmodule.map_comap_incl, inf_eq_right]
state_before: R : Type u
L : Type v
M : Type w
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
k : ℕ
N : LieSubmodule R L M
⊢ lcs k N ≤ N
state_after: no goals
tactic: apply lcs_le_self
Theorem: toIocMod_sub'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (a - p) b = toIocMod hp a b - p
state_after: no goals
tactic: simpa only [one_zsmul] using toIocMod_sub_zsmul' hp a b 1