ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: String.extract.go₂_append_left
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: t : List Char
i : Nat
⊢ go₂ ([] ++ t) { byteIdx := i } { byteIdx := utf8Len [] + i } = []
state_after: no goals
tactic: cases t <;> simp [go₂]
state_before: c : Char
cs t : List Char
i : Nat
⊢ go₂ (c :: cs ++ t) { byteIdx := i } { byteIdx := utf8Len (c :: cs) + i } = c :: cs
state_after: c : Char
cs t : List Char
i : Nat
⊢ go₂ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } = cs
tactic: simp only [go₂, utf8Len_cons, Pos.ext_iff, ne_add_csize_add_self, ↓reduceIte, List.append_eq,
    Pos.addChar_eq, List.cons.injEq, true_and]
state_before: c : Char
cs t : List Char
i : Nat
⊢ go₂ (cs ++ t) { byteIdx := i + c.utf8Size } { byteIdx := utf8Len cs + c.utf8Size + i } = cs
state_after: case a
c : Char
cs t : List Char
i : Nat
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
tactic: apply go₂_append_left
state_before: case a
c : Char
cs t : List Char
i : Nat
⊢ utf8Len cs + c.utf8Size + i = utf8Len cs + (i + c.utf8Size)
state_after: no goals
tactic: rw [Nat.add_right_comm, Nat.add_assoc]
Theorem: Ordinal.op_eq_self_of_principal
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
a o : Ordinal.{u}
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : o.IsLimit
⊢ op a o = o
state_after: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
a o : Ordinal.{u}
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : o.IsLimit
⊢ op a o ≤ o
tactic: refine le_antisymm ?_ (H.self_le _)
state_before: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
a o : Ordinal.{u}
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : o.IsLimit
⊢ op a o ≤ o
state_after: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
a o : Ordinal.{u}
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : o.IsLimit
⊢ ∀ i < o, op a i ≤ o
tactic: rw [← IsNormal.bsup_eq.{u, u} H ho', bsup_le_iff]
state_before: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
a o : Ordinal.{u}
hao : a < o
H : IsNormal (op a)
ho : Principal op o
ho' : o.IsLimit
⊢ ∀ i < o, op a i ≤ o
state_after: no goals
tactic: exact fun b hbo => (ho hao hbo).le
Theorem: PowerSeries.exp_pow_sum
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ Finset.range n, exp A ^ k = mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ Finset.range n,
      { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        (exp A) =
    mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹
tactic: simp only [exp_pow_eq_rescale_exp, rescale]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ Finset.range n,
      { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        (exp A) =
    mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹
state_after: case h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n n✝ : ℕ
⊢ (coeff A n✝)
      (∑ x ∈ Finset.range n,
        { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
            map_add' := ⋯ }
          (exp A)) =
    (coeff A n✝) (mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹)
tactic: ext
state_before: case h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n n✝ : ℕ
⊢ (coeff A n✝)
      (∑ x ∈ Finset.range n,
        { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
            map_add' := ⋯ }
          (exp A)) =
    (coeff A n✝) (mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹)
state_after: no goals
tactic: simp only [one_div, coeff_mk, cast_pow, coe_mk, MonoidHom.coe_mk, OneHom.coe_mk,
    coeff_exp, factorial, map_sum]
Theorem: Finset.zero_mul_subset
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : MulZeroClass α
s✝ t s : Finset α
⊢ 0 * s ⊆ 0
state_after: no goals
tactic: simp [subset_iff, mem_mul]
Theorem: Function.Periodic.nat_mul_sub_eq
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✝ : Ring α
h : Periodic f c
n : ℕ
⊢ f (↑n * c - x) = f (-x)
state_after: no goals
tactic: simpa only [sub_eq_neg_add] using h.nat_mul n (-x)
Theorem: CategoryTheory.Functor.eqToHom_proj
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
x x' : (i : I) → C i
h : x = x'
i : I
⊢ eqToHom h i = eqToHom ⋯
state_after: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
x : (i : I) → C i
i : I
⊢ eqToHom ⋯ i = eqToHom ⋯
tactic: subst h
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
x : (i : I) → C i
i : I
⊢ eqToHom ⋯ i = eqToHom ⋯
state_after: no goals
tactic: rfl
Theorem: contDiffAt_one_iff
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiffAt 𝕜 1 f x ↔ ∃ f', ∃ u ∈ 𝓝 x, ContinuousOn f' u ∧ ∀ x ∈ u, HasFDerivAt f (f' x) x
state_after: no goals
tactic: simp_rw [show (1 : ℕ∞) = (0 + 1 : ℕ) from (zero_add 1).symm, contDiffAt_succ_iff_hasFDerivAt,
    show ((0 : ℕ) : ℕ∞) = 0 from rfl, contDiffAt_zero,
    exists_mem_and_iff antitone_bforall antitone_continuousOn, and_comm]
Theorem: CategoryTheory.Square.toArrowArrowFunctor_obj_right_hom
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Algebra.adjoin_nonUnitalSubalgebra_eq_span
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
s : NonUnitalSubalgebra R A
⊢ Subalgebra.toSubmodule (adjoin R ↑s) = span R {1} ⊔ s.toSubmodule
state_after: no goals
tactic: rw [adjoin_eq_span, Submonoid.closure_eq_one_union, span_union, ← NonUnitalAlgebra.adjoin_eq_span,
      NonUnitalAlgebra.adjoin_eq]
Theorem: CategoryTheory.ShortComplex.SnakeInput.op_v₂₃
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.op.g
state_after: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.f.op
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Epi S.L₂.f.op
state_after: no goals
tactic: infer_instance
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.op.f
state_after: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.g.op
tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.4837, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ Mono S.L₁.g.op
state_after: no goals
tactic: infer_instance
Theorem: AffineBasis.coord_apply_centroid
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : DivisionRing k
inst✝¹ : Module k V
inst✝ : CharZero k
b : AffineBasis ι k P
s : Finset ι
i : ι
hi : i ∈ s
⊢ (b.coord i) (Finset.centroid k s ⇑b) = (↑s.card)⁻¹
state_after: no goals
tactic: rw [Finset.centroid,
    b.coord_apply_combination_of_mem hi (s.sum_centroidWeights_eq_one_of_nonempty _ ⟨i, hi⟩),
    Finset.centroidWeights, Function.const_apply]
Theorem: AddAction.le_stabilizer_vadd_right
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ stabilizer G b ≤ stabilizer G (a • b)
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ ∀ ⦃x : G⦄, x • b = b → a • x • b = a • b
tactic: simp_rw [SetLike.le_def, mem_stabilizer_iff, smul_comm]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ ∀ ⦃x : G⦄, x • b = b → a • x • b = a • b
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a✝ : α
b : β
a : G
h : a • b = b
⊢ a✝ • a • b = a✝ • b
tactic: rintro a h
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a✝ : α
b : β
a : G
h : a • b = b
⊢ a✝ • a • b = a✝ • b
state_after: no goals
tactic: rw [h]
Theorem: PiTensorProduct.liftIsometry_apply_apply
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : ContinuousMultilinearMap 𝕜 E F
x : ⨂[𝕜] (i : ι), E i
⊢ ((liftIsometry 𝕜 E F) f) x = (lift f.toMultilinearMap) x
state_after: no goals
tactic: simp only [liftIsometry, LinearIsometryEquiv.coe_mk, liftEquiv_apply,
    LinearMap.mkContinuous_apply]
Theorem: Real.tanh_zero
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ tanh 0 = 0
state_after: no goals
tactic: simp [tanh]
Theorem: NNReal.tsum_eq_toNNReal_tsum
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : β → ℝ≥0
⊢ ∑' (b : β), f b = (∑' (b : β), ↑(f b)).toNNReal
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → ℝ≥0
h : Summable f
⊢ ∑' (b : β), f b = (∑' (b : β), ↑(f b)).toNNReal

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → ℝ≥0
h : ¬Summable f
⊢ ∑' (b : β), f b = (∑' (b : β), ↑(f b)).toNNReal
tactic: by_cases h : Summable f
Theorem: Metric.closure_eq_iInter_cthickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
E : Set α
⊢ closure E = ⋂ δ, ⋂ (_ : 0 < δ), cthickening δ E
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
E : Set α
⊢ cthickening 0 E = ⋂ δ, ⋂ (_ : 0 < δ), cthickening δ E
tactic: rw [← cthickening_zero]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
E : Set α
⊢ cthickening 0 E = ⋂ δ, ⋂ (_ : 0 < δ), cthickening δ E
state_after: no goals
tactic: exact cthickening_eq_iInter_cthickening E
Theorem: CompositionSeries.ext
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : ∀ (x : X), x ∈ s₁ ↔ x ∈ s₂
⊢ (toList s₁).Perm (toList s₂)
state_after: no goals
tactic: classical
        exact List.perm_of_nodup_nodup_toFinset_eq s₁.toList_nodup s₂.toList_nodup
          (Finset.ext <| by simpa only [List.mem_toFinset, RelSeries.mem_toList])
Theorem: iteratedFDerivWithin_of_isOpen
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : IsOpen s
⊢ EqOn (iteratedFDerivWithin 𝕜 n f s) (iteratedFDeriv 𝕜 n f) s
state_after: case zero
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : IsOpen s
⊢ EqOn (iteratedFDerivWithin 𝕜 0 f s) (iteratedFDeriv 𝕜 0 f) s

case succ
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : IsOpen s
n : ℕ
IH : EqOn (iteratedFDerivWithin 𝕜 n f s) (iteratedFDeriv 𝕜 n f) s
⊢ EqOn (iteratedFDerivWithin 𝕜 (n + 1) f s) (iteratedFDeriv 𝕜 (n + 1) f) s
tactic: induction' n with n IH
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.even_odd₃
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

Proof steps:
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSymNat a b = -r
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = -jacobiSym (↑a / 2) b
tactic: simp only [jacobiSymNat, ← hr, ← hc, Int.ofNat_ediv, Nat.cast_ofNat]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ jacobiSym (↑a) b = -jacobiSym (↑a / 2) b
state_after: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1
tactic: rw [← jacobiSym.even_odd (mod_cast ha), if_pos (by simp [hb])]
state_before: a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ b % 2 = 1
state_after: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8
tactic: rw [← Nat.mod_mod_of_dvd, hb]
state_before: case h
a b c : ℕ
r : ℤ
ha : a % 2 = 0
hb : b % 8 = 3
hc : a / 2 = c
hr : jacobiSymNat c b = r
⊢ 2 ∣ 8
state_after: no goals
tactic: norm_num
Theorem: Complex.exp_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cexp (-x) = (cexp x)⁻¹
state_after: x y : ℂ
⊢ cexp (x + -x) = cexp x * (cexp x)⁻¹
tactic: rw [← mul_right_inj' (exp_ne_zero x), ← exp_add]
state_before: x y : ℂ
⊢ cexp (x + -x) = cexp x * (cexp x)⁻¹
state_after: no goals
tactic: simp [mul_inv_cancel (exp_ne_zero x)]
Theorem: Quotient.induction_on_pi
File: Mathlib/Data/Quot.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p f
state_after: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p fun i => ⟦(f i).out⟧
tactic: rw [← (funext fun i ↦ Quotient.out_eq (f i) : (fun i ↦ ⟦(f i).out⟧) = f)]
state_before: α✝ : Sort u_1
β : Sort u_2
ι : Type u_3
α : ι → Sort u_4
s : (i : ι) → Setoid (α i)
p : ((i : ι) → Quotient (s i)) → Prop
f : (i : ι) → Quotient (s i)
h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧
⊢ p fun i => ⟦(f i).out⟧
state_after: no goals
tactic: apply h
Theorem: Ordinal.lt_nadd_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
⊢ a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'
state_after: a b c : Ordinal.{u}
⊢ a < max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'
tactic: rw [nadd_def]
state_before: a b c : Ordinal.{u}
⊢ a < max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'
state_after: no goals
tactic: simp [lt_blsub_iff]
Theorem: ENNReal.rpow_intCast_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
n : ℤ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z
state_after: no goals
tactic: rw [rpow_mul, rpow_intCast]
Theorem: Polynomial.splits_mul
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf : Splits i f
hg : Splits i g
this : DecidableEq L := Classical.decEq L
h : ¬map i (f * g) = 0
p : L[X]
hp : Irreducible p
hpf : p ∣ map i (f * g)
⊢ p ∣ map i f * map i g
state_after: case h.e'_4
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf : Splits i f
hg : Splits i g
this : DecidableEq L := Classical.decEq L
h : ¬map i (f * g) = 0
p : L[X]
hp : Irreducible p
hpf : p ∣ map i (f * g)
⊢ map i f * map i g = map i (f * g)
tactic: convert hpf
state_before: case h.e'_4
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf : Splits i f
hg : Splits i g
this : DecidableEq L := Classical.decEq L
h : ¬map i (f * g) = 0
p : L[X]
hp : Irreducible p
hpf : p ∣ map i (f * g)
⊢ map i f * map i g = map i (f * g)
state_after: no goals
tactic: rw [Polynomial.map_mul]
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf✝ : Splits i f
hg : Splits i g
this : DecidableEq L := Classical.decEq L
h : ¬map i (f * g) = 0
p : L[X]
hp : Irreducible p
hpf : p ∣ map i (f * g)
hf : map i f = 0
⊢ False
state_after: no goals
tactic: simp [hf] at h
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f g : K[X]
hf : Splits i f
hg✝ : Splits i g
this : DecidableEq L := Classical.decEq L
h : ¬map i (f * g) = 0
p : L[X]
hp : Irreducible p
hpf : p ∣ map i (f * g)
hg : map i g = 0
⊢ False
state_after: no goals
tactic: simp [hg] at h
Theorem: Quiver.cast_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Cast.lean

Proof steps:
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ Path.cast ⋯ ⋯ p = p'
state_after: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ HEq p p'
tactic: rw [Path.cast_eq_iff_heq]
state_before: U : Type u_1
inst✝ : Quiver U
u v v' w : U
p : Path u v
p' : Path u v'
e : v ⟶ w
e' : v' ⟶ w
h : p.cons e = p'.cons e'
⊢ HEq p p'
state_after: no goals
tactic: exact heq_of_cons_eq_cons h
Theorem: Ideal.range_finsuppTotal
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
⊢ LinearMap.range (finsuppTotal ι M I v) = I • Submodule.span R (Set.range v)
state_after: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ x✝ ∈ LinearMap.range (finsuppTotal ι M I v) ↔ x✝ ∈ I • Submodule.span R (Set.range v)
tactic: ext
state_before: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ x✝ ∈ LinearMap.range (finsuppTotal ι M I v) ↔ x✝ ∈ I • Submodule.span R (Set.range v)
state_after: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ x✝ ∈ LinearMap.range (finsuppTotal ι M I v) ↔ ∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • v i) = x✝
tactic: rw [Submodule.mem_ideal_smul_span_iff_exists_sum]
state_before: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ x✝ ∈ LinearMap.range (finsuppTotal ι M I v) ↔ ∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • v i) = x✝
state_after: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ (∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • v i) = x✝) → x✝ ∈ LinearMap.range (finsuppTotal ι M I v)
tactic: refine ⟨fun ⟨f, h⟩ => ⟨Finsupp.mapRange.linearMap I.subtype f, fun i => (f i).2, h⟩, ?_⟩
state_before: case h
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
x✝ : M
⊢ (∃ a, ∃ (_ : ∀ (i : ι), a i ∈ I), (a.sum fun i c => c • v i) = x✝) → x✝ ∈ LinearMap.range (finsuppTotal ι M I v)
state_after: case h.intro.intro
ι : Type u_1
M : Type u_2
inst✝² : AddCommGroup M
R : Type u_3
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
a : ι →₀ R
ha : ∀ (i : ι), a i ∈ I
⊢ (a.sum fun i c => c • v i) ∈ LinearMap.range (finsuppTotal ι M I v)
tactic: rintro ⟨a, ha, rfl⟩
Theorem: lineDifferentiableWithinAt_univ
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
⊢ LineDifferentiableWithinAt 𝕜 f univ x v ↔ LineDifferentiableAt 𝕜 f x v
state_after: no goals
tactic: simp only [LineDifferentiableWithinAt, LineDifferentiableAt, preimage_univ,
    differentiableWithinAt_univ]
Theorem: MeasureTheory.piPremeasure_pi_eval
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ piPremeasure m (univ.pi fun i => eval i '' s) = piPremeasure m s
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ ∏ i : ι, (m i) ((fun a => a i) '' s) = piPremeasure m s
tactic: simp only [eval, piPremeasure_pi']
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ ∏ i : ι, (m i) ((fun a => a i) '' s) = piPremeasure m s
state_after: no goals
tactic: rfl