ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.prod_span
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
⊢ ∏ i ∈ s, span R (M i) = span R (∏ i ∈ s, M i)
state_after: ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∏ i ∈ s, span R (M i) = span R (∏ i ∈ s, M i)
tactic: letI := Classical.decEq ι
state_before: ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∏ i ∈ s, span R (M i) = span R (∏ i ∈ s, M i)
state_after: case refine_1
ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∏ i ∈ ∅, span R (M i) = span R (∏ i ∈ ∅, M i)

case refine_2
ι✝ : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M✝ N : Submodule R A
m n : A
ι : Type u_1
s : Finset ι
M : ι → Set A
this : DecidableEq ι := Classical.decEq ι
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    a ∉ s →
      ∏ i ∈ s, span R (M i) = span R (∏ i ∈ s, M i) → ∏ i ∈ insert a s, span R (M i) = span R (∏ i ∈ insert a s, M i)
tactic: refine Finset.induction_on s ?_ ?_
Theorem: Submodule.closure_induction'
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
p : (x : M) → x ∈ span R s → Prop
zero : p 0 ⋯
add : ∀ (x : M) (hx : x ∈ span R s) (y : M) (hy : y ∈ span R s), p x hx → p y hy → p (x + y) ⋯
smul_mem : ∀ (r : R) (x : M) (h : x ∈ s), p (r • x) ⋯
x : M
hx : x ∈ span R s
⊢ p x hx
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
p : (x : M) → x ∈ span R s → Prop
zero : p 0 ⋯
add : ∀ (x : M) (hx : x ∈ span R s) (y : M) (hy : y ∈ span R s), p x hx → p y hy → p (x + y) ⋯
smul_mem : ∀ (r : R) (x : M) (h : x ∈ s), p (r • x) ⋯
x : M
hx : x ∈ span R s
⊢ ∃ (x_1 : x ∈ span R s), p x x_1
tactic: refine Exists.elim ?_ fun (hx : x ∈ span R s) (hc : p x hx) ↦ hc
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
p : (x : M) → x ∈ span R s → Prop
zero : p 0 ⋯
add : ∀ (x : M) (hx : x ∈ span R s) (y : M) (hy : y ∈ span R s), p x hx → p y hy → p (x + y) ⋯
smul_mem : ∀ (r : R) (x : M) (h : x ∈ s), p (r • x) ⋯
x : M
hx : x ∈ span R s
⊢ ∃ (x_1 : x ∈ span R s), p x x_1
state_after: no goals
tactic: refine closure_induction hx ⟨zero_mem _, zero⟩
    (fun x y hx hy ↦ Exists.elim hx fun hx' hx ↦
      Exists.elim hy fun hy' hy ↦ ⟨add_mem hx' hy', add _ _ _ _ hx hy⟩)
    fun r x hx ↦ ⟨Submodule.smul_mem _ _ (subset_span hx), smul_mem r x hx⟩
Theorem: CategoryTheory.Kleisli.Adjunction.toKleisli_map
File: Mathlib/CategoryTheory/Monad/Kleisli.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map f ≫
      { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    (f ≫ T.η.app Y) ≫ T.map (g ≫ T.η.app Z) ≫ T.μ.app Z
tactic: change _ = (f ≫ (Monad.η T).app Y) ≫ T.map (g ≫ (Monad.η T).app Z) ≫ T.μ.app Z
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => f ≫ T.η.app Y }.map (f ≫ g) =
    (f ≫ T.η.app Y) ≫ T.map (g ≫ T.η.app Z) ≫ T.μ.app Z
state_after: no goals
tactic: simp [← T.η.naturality g]
Theorem: AddAction.orbit_addSubmonoid_subset
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: M : Type u
inst✝² : Monoid M
α : Type v
inst✝¹ : MulAction M α
β : Type u_1
inst✝ : MulAction M β
S : Submonoid M
a : α
⊢ orbit (↥S) a ⊆ orbit M a
state_after: case intro
M : Type u
inst✝² : Monoid M
α : Type v
inst✝¹ : MulAction M α
β : Type u_1
inst✝ : MulAction M β
S : Submonoid M
a : α
g : ↥S
⊢ (fun m => m • a) g ∈ orbit M a
tactic: rintro b ⟨g, rfl⟩
state_before: case intro
M : Type u
inst✝² : Monoid M
α : Type v
inst✝¹ : MulAction M α
β : Type u_1
inst✝ : MulAction M β
S : Submonoid M
a : α
g : ↥S
⊢ (fun m => m • a) g ∈ orbit M a
state_after: no goals
tactic: exact mem_orbit _ _
Theorem: spectrum.SpectralRadius.of_subsingleton
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : Subsingleton A
a : A
⊢ spectralRadius 𝕜 a = 0
state_after: no goals
tactic: simp [spectralRadius]
Theorem: ChainComplex.mkHom_f_succ_succ
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
P Q : ChainComplex V ℕ
zero : P.X 0 ⟶ Q.X 0
one : P.X 1 ⟶ Q.X 1
one_zero_comm : one ≫ Q.d 1 0 = P.d 1 0 ≫ zero
succ :
  (n : ℕ) →
    (p : (f : P.X n ⟶ Q.X n) ×' (f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×' f' ≫ Q.d (n + 1) n = P.d (n + 1) n ≫ f) →
      (f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×' f'' ≫ Q.d (n + 2) (n + 1) = P.d (n + 2) (n + 1) ≫ p.snd.fst
n : ℕ
⊢ (P.mkHom Q zero one one_zero_comm succ).f (n + 2) =
    (succ n ⟨(P.mkHom Q zero one one_zero_comm succ).f n, ⟨(P.mkHom Q zero one one_zero_comm succ).f (n + 1), ⋯⟩⟩).fst
state_after: no goals
tactic: dsimp [mkHom, mkHomAux]
Theorem: LaurentSeries.valuation_single_zpow
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
s : ℤ
⊢ Valued.v ((single s) 1) = ↑(Multiplicative.ofAdd (-s))
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
s : ℤ
this : Valued.v 1 = 1
⊢ Valued.v ((single s) 1) = ↑(Multiplicative.ofAdd (-s))
tactic: have : Valued.v (1 : LaurentSeries K) = (1 : ℤₘ₀) := Valued.v.map_one
state_before: R : Type u_1
K : Type u_2
inst✝ : Field K
s : ℤ
this : Valued.v 1 = 1
⊢ Valued.v ((single s) 1) = ↑(Multiplicative.ofAdd (-s))
state_after: R : Type u_1
K : Type u_2
inst✝ : Field K
s : ℤ
this : Valued.v ((single s) 1) = (Valued.v ((single (-s)) 1))⁻¹
⊢ Valued.v ((single s) 1) = ↑(Multiplicative.ofAdd (-s))

R : Type u_1
K : Type u_2
inst✝ : Field K
s : ℤ
this : Valued.v ((single s) 1) * Valued.v ((single (-s)) 1) = 1
⊢ Valued.v ((single (-s)) 1) ≠ 0
tactic: rw [← single_zero_one, ← add_right_neg s, ← mul_one 1, ← single_mul_single, map_mul,
    mul_eq_one_iff_eq_inv₀] at this
Theorem: Left.inv_le_one_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ 1 ↔ 1 ≤ a
state_after: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a
tactic: rw [← mul_le_mul_iff_left a]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a
state_after: no goals
tactic: simp
Theorem: HurwitzKernelBounds.F_nat_zero_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
⊢ ‖F_nat 0 a t‖ ≤ rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))
state_after: a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
⊢ HasSum (g_nat 0 a t) (rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)))
tactic: refine tsum_of_norm_bounded ?_ (f_le_g_nat 0 ha ht)
state_before: a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
⊢ HasSum (g_nat 0 a t) (rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)))
state_after: case h.e'_5
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
⊢ g_nat 0 a t = fun i => rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ i
tactic: convert (hasSum_geometric_of_lt_one (exp_pos _).le <| exp_lt_aux ht).mul_left _ using 1
state_before: case h.e'_5
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
⊢ g_nat 0 a t = fun i => rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ i
state_after: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ g_nat 0 a t n = rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ n
tactic: ext1 n
state_before: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ g_nat 0 a t n = rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ n
state_after: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ 0 * rexp (-π * (↑n + a ^ 2) * t) = rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ n
tactic: simp only [g_nat]
state_before: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ 0 * rexp (-π * (↑n + a ^ 2) * t) = rexp (-π * a ^ 2 * t) * rexp (-π * t) ^ n
state_after: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ 0 * rexp (-π * (↑n + a ^ 2) * t) = rexp (-π * a ^ 2 * t + ↑n * (-π * t))
tactic: rw [← Real.exp_nat_mul, ← Real.exp_add]
state_before: case h.e'_5.h
a : ℝ
ha : 0 ≤ a
t : ℝ
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ 0 * rexp (-π * (↑n + a ^ 2) * t) = rexp (-π * a ^ 2 * t + ↑n * (-π * t))
state_after: no goals
tactic: ring_nf
Theorem: RingCon.ringConGen_of_ringCon
File: Mathlib/RingTheory/Congruence/Basic.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c : RingCon R
⊢ ringConGen ⇑c ≤ c
state_after: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c : RingCon R
⊢ sInf {s | ∀ (x y : R), c x y → s x y} ≤ c
tactic: rw [ringConGen_eq]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
c : RingCon R
⊢ sInf {s | ∀ (x y : R), c x y → s x y} ≤ c
state_after: no goals
tactic: exact sInf_le fun _ _ => id
Theorem: Metric.continuousOn_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : PseudoMetricSpace β
f : α → β
s : Set α
⊢ ContinuousOn f s ↔ ∀ b ∈ s, ∀ ε > 0, ∃ δ > 0, ∀ a ∈ s, dist a b < δ → dist (f a) (f b) < ε
state_after: no goals
tactic: simp [ContinuousOn, continuousWithinAt_iff]
Theorem: injective_nsmul_iff_not_isOfFinAddOrder
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
x y a : G
m n : ℕ
⊢ (Injective fun n => x ^ n) ↔ ¬IsOfFinOrder x
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : ¬IsOfFinOrder x
n m : ℕ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
tactic: refine ⟨fun h => not_isOfFinOrder_of_injective_pow h, fun h n m hnm => ?_⟩
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : ¬IsOfFinOrder x
n m : ℕ
hnm : (fun n => x ^ n) n = (fun n => x ^ n) m
⊢ n = m
state_after: no goals
tactic: rwa [pow_eq_pow_iff_modEq, orderOf_eq_zero_iff.mpr h, modEq_zero_iff] at hnm
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: MeasureTheory.OuterMeasure.restrict_iInf_restrict
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
s : Set α
m : ι → OuterMeasure α
⊢ (restrict s) (⨅ i, (restrict s) (m i)) = (restrict (range Subtype.val)) (⨅ i, (restrict s) (m i))
state_after: no goals
tactic: rw [Subtype.range_coe]
Theorem: Fin.comp_snoc
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin n → α
y : α
⊢ g ∘ snoc q y = snoc (g ∘ q) (g y)
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin n → α
y : α
j : Fin (n + 1)
⊢ (g ∘ snoc q y) j = snoc (g ∘ q) (g y) j
tactic: ext j
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin n → α
y : α
j : Fin (n + 1)
⊢ (g ∘ snoc q y) j = snoc (g ∘ q) (g y) j
state_after: case pos
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin n → α
y : α
j : Fin (n + 1)
h : ↑j < n
⊢ (g ∘ snoc q y) j = snoc (g ∘ q) (g y) j

case neg
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ (last n)
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.castSucc
i : Fin n
y✝ : α✝ i.castSucc
z : α✝ (last n)
α : Type u_1
β : Type u_2
g : α → β
q : Fin n → α
y : α
j : Fin (n + 1)
h : ¬↑j < n
⊢ (g ∘ snoc q y) j = snoc (g ∘ q) (g y) j
tactic: by_cases h : j.val < n
Theorem: Int.abs_le_one_iff
File: Mathlib/Algebra/Order/Group/Int.lean

Proof steps:
state_before: a : ℤ
⊢ |a| ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1
state_after: no goals
tactic: rw [le_iff_lt_or_eq, abs_lt_one_iff, abs_eq Int.one_nonneg]
Theorem: WeierstrassCurve.Projective.polynomialZ_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
⊢ W.polynomialZ =
    X 1 ^ 2 + C W.a₁ * X 0 * X 1 + C (2 * W.a₃) * X 1 * X 2 -
      (C W.a₂ * X 0 ^ 2 + C (2 * W.a₄) * X 0 * X 2 + C (3 * W.a₆) * X 2 ^ 2)
state_after: R : Type u
inst✝ : CommRing R
W : Projective R
⊢ (pderiv 2)
      (X 1 ^ 2 * X 2 + C W.a₁ * X 0 * X 1 * X 2 + C W.a₃ * X 1 * X 2 ^ 2 -
        (X 0 ^ 3 + C W.a₂ * X 0 ^ 2 * X 2 + C W.a₄ * X 0 * X 2 ^ 2 + C W.a₆ * X 2 ^ 3)) =
    X 1 ^ 2 + C W.a₁ * X 0 * X 1 + C (2 * W.a₃) * X 1 * X 2 -
      (C W.a₂ * X 0 ^ 2 + C (2 * W.a₄) * X 0 * X 2 + C (3 * W.a₆) * X 2 ^ 2)
tactic: rw [polynomialZ, polynomial]
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
⊢ (pderiv 2)
      (X 1 ^ 2 * X 2 + C W.a₁ * X 0 * X 1 * X 2 + C W.a₃ * X 1 * X 2 ^ 2 -
        (X 0 ^ 3 + C W.a₂ * X 0 ^ 2 * X 2 + C W.a₄ * X 0 * X 2 ^ 2 + C W.a₆ * X 2 ^ 3)) =
    X 1 ^ 2 + C W.a₁ * X 0 * X 1 + C (2 * W.a₃) * X 1 * X 2 -
      (C W.a₂ * X 0 ^ 2 + C (2 * W.a₄) * X 0 * X 2 + C (3 * W.a₆) * X 2 ^ 2)
state_after: R : Type u
inst✝ : CommRing R
W : Projective R
⊢ ↑2 * X 1 ^ (2 - 1) * 0 * X 2 + X 1 ^ 2 * 1 +
          (((0 * X 0 + C W.a₁ * 0) * X 1 + C W.a₁ * X 0 * 0) * X 2 + C W.a₁ * X 0 * X 1 * 1) +
        ((0 * X 1 + C W.a₃ * 0) * X 2 ^ 2 + C W.a₃ * X 1 * (↑2 * X 2 ^ (2 - 1) * 1)) -
      (↑3 * X 0 ^ (3 - 1) * 0 + ((0 * X 0 ^ 2 + C W.a₂ * (↑2 * X 0 ^ (2 - 1) * 0)) * X 2 + C W.a₂ * X 0 ^ 2 * 1) +
          ((0 * X 0 + C W.a₄ * 0) * X 2 ^ 2 + C W.a₄ * X 0 * (↑2 * X 2 ^ (2 - 1) * 1)) +
        (0 * X 2 ^ 3 + C W.a₆ * (↑3 * X 2 ^ (3 - 1) * 1))) =
    X 1 ^ 2 + C W.a₁ * X 0 * X 1 + 2 * C W.a₃ * X 1 * X 2 -
      (C W.a₂ * X 0 ^ 2 + 2 * C W.a₄ * X 0 * X 2 + 3 * C W.a₆ * X 2 ^ 2)
tactic: pderiv_simp
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
⊢ ↑2 * X 1 ^ (2 - 1) * 0 * X 2 + X 1 ^ 2 * 1 +
          (((0 * X 0 + C W.a₁ * 0) * X 1 + C W.a₁ * X 0 * 0) * X 2 + C W.a₁ * X 0 * X 1 * 1) +
        ((0 * X 1 + C W.a₃ * 0) * X 2 ^ 2 + C W.a₃ * X 1 * (↑2 * X 2 ^ (2 - 1) * 1)) -
      (↑3 * X 0 ^ (3 - 1) * 0 + ((0 * X 0 ^ 2 + C W.a₂ * (↑2 * X 0 ^ (2 - 1) * 0)) * X 2 + C W.a₂ * X 0 ^ 2 * 1) +
          ((0 * X 0 + C W.a₄ * 0) * X 2 ^ 2 + C W.a₄ * X 0 * (↑2 * X 2 ^ (2 - 1) * 1)) +
        (0 * X 2 ^ 3 + C W.a₆ * (↑3 * X 2 ^ (3 - 1) * 1))) =
    X 1 ^ 2 + C W.a₁ * X 0 * X 1 + 2 * C W.a₃ * X 1 * X 2 -
      (C W.a₂ * X 0 ^ 2 + 2 * C W.a₄ * X 0 * X 2 + 3 * C W.a₆ * X 2 ^ 2)
state_after: no goals
tactic: ring1
Theorem: Fermat42.ne_zero
File: Mathlib/NumberTheory/FLT/Four.lean

Proof steps:
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ≠ 0
state_after: a b c : ℤ
h : Fermat42 a b c
⊢ c ^ 2 ≠ 0
tactic: apply ne_zero_pow two_ne_zero _
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ^ 2 ≠ 0
state_after: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < c ^ 2
tactic: apply ne_of_gt
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < c ^ 2
state_after: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < (a ^ 2) ^ 2 + (b ^ 2) ^ 2
tactic: rw [← h.2.2, (by ring : a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2)]
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < (a ^ 2) ^ 2 + (b ^ 2) ^ 2
state_after: no goals
tactic: exact
    add_pos (sq_pos_of_ne_zero (pow_ne_zero 2 h.1)) (sq_pos_of_ne_zero (pow_ne_zero 2 h.2.1))
Theorem: Filter.iInf_neBot_of_directed
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 : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), (f i).NeBot
⊢ (iInf f).NeBot
state_after: case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), (f i).NeBot
h✝ : IsEmpty ι
⊢ (iInf f).NeBot

case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
hn : Nonempty α
hd : Directed (fun x x_1 => x ≥ x_1) f
hb : ∀ (i : ι), (f i).NeBot
h✝ : Nonempty ι
⊢ (iInf f).NeBot
tactic: cases isEmpty_or_nonempty ι
Theorem: NonUnitalAlgHom.to_mulHom_injective
File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

Proof steps:
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
⊢ f = g
state_after: case h
R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
a : A
⊢ f a = g a
tactic: ext a
state_before: case h
R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
h : ↑f = ↑g
a : A
⊢ f a = g a
state_after: no goals
tactic: exact DFunLike.congr_fun h a
Theorem: MeasurableEmbedding.integrableOn_iff_comap
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ⊆ range e
⊢ IntegrableOn f s μ ↔ IntegrableOn (f ∘ e) (e ⁻¹' s) (Measure.comap e μ)
state_after: no goals
tactic: simp_rw [← he.integrableOn_map_iff, he.map_comap, IntegrableOn,
    Measure.restrict_restrict_of_subset hs]
Theorem: Bool.or_inr
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: a b : Bool
H : b = true
⊢ (a || b) = true
state_after: no goals
tactic: cases a <;> simp [H]
Theorem: Multiset.stronglyMeasurable_sum'
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 ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : Multiset (α → M)
hl : ∀ f ∈ l, StronglyMeasurable f
⊢ StronglyMeasurable l.prod
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))
tactic: rcases l with ⟨l⟩
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))
state_after: no goals
tactic: simpa using l.stronglyMeasurable_prod' (by simpa using hl)
Theorem: List.forall₂_comp_perm_eq_perm_comp_forall₂
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
⊢ Forall₂ r ∘r Perm = Perm ∘r Forall₂ r
state_after: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Forall₂ r ∘r Perm) l₁ l₃ = (Perm ∘r Forall₂ r) l₁ l₃
tactic: funext l₁ l₃
state_before: case h.h
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Forall₂ r ∘r Perm) l₁ l₃ = (Perm ∘r Forall₂ r) l₁ l₃
state_after: case h.h.a
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Forall₂ r ∘r Perm) l₁ l₃ ↔ (Perm ∘r Forall₂ r) l₁ l₃
tactic: apply propext
state_before: case h.h.a
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Forall₂ r ∘r Perm) l₁ l₃ ↔ (Perm ∘r Forall₂ r) l₁ l₃
state_after: case h.h.a.mp
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Forall₂ r ∘r Perm) l₁ l₃ → (Perm ∘r Forall₂ r) l₁ l₃

case h.h.a.mpr
α : Type u_1
β : Type u_2
l l₁✝ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
l₁ : List α
l₃ : List β
⊢ (Perm ∘r Forall₂ r) l₁ l₃ → (Forall₂ r ∘r Perm) l₁ l₃
tactic: constructor