ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Array.extract_append_right
File: Mathlib/Data/Array/ExtractLemmas.lean

Proof steps:
state_before: α : Type u
i✝ : Nat
a b : Array α
i j : Nat
h : a.size ≤ i
⊢ (a ++ b).extract i j = b.extract (i - a.size) (j - a.size)
state_after: case h₁
α : Type u
i✝ : Nat
a b : Array α
i j : Nat
h : a.size ≤ i
⊢ ((a ++ b).extract i j).size = (b.extract (i - a.size) (j - a.size)).size

case h₂
α : Type u
i✝ : Nat
a b : Array α
i j : Nat
h : a.size ≤ i
⊢ ∀ (i_1 : Nat) (hi₁ : i_1 < ((a ++ b).extract i j).size) (hi₂ : i_1 < (b.extract (i - a.size) (j - a.size)).size),
    ((a ++ b).extract i j)[i_1] = (b.extract (i - a.size) (j - a.size))[i_1]
tactic: apply ext
Theorem: ZMod.neg_val'
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ (-a).val = (-a).val % n
state_after: no goals
tactic: rw [Nat.mod_eq_of_lt (-a).val_lt]
state_before: m n✝ n : ℕ
inst✝ : NeZero n
a : ZMod n
⊢ (-a).val + a.val ≡ n - a.val + a.val [MOD n]
state_after: no goals
tactic: rw [Nat.ModEq, ← val_add, add_left_neg, tsub_add_cancel_of_le a.val_le, Nat.mod_self,
            val_zero]
Theorem: Polynomial.natDegree_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
⊢ (p.scaleRoots s).natDegree = p.natDegree
state_after: no goals
tactic: simp only [natDegree, degree_scaleRoots]
Theorem: MeasureTheory.IsAddFundamentalDomain.lintegral_eq_tsum_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
hν : ν ≪ μ
f : α → ℝ≥0∞
⊢ ∫⁻ (x : α), f x ∂ν = ∑' (g : G), ∫⁻ (x : α) in g • s, f x ∂ν
state_after: no goals
tactic: rw [← lintegral_sum_measure, h.sum_restrict_of_ac hν]
Theorem: Monoid.PushoutI.lift_of
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Monoid (G i)
inst✝ : Monoid H
φ : (i : ι) → H →* G i
f : (i : ι) → G i →* K
k : H →* K
hf : ∀ (i : ι), (f i).comp (φ i) = k
i : ι
g : G i
⊢ (lift f k hf) ((of i) g) = (f i) g
state_after: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Monoid (G i)
inst✝ : Monoid H
φ : (i : ι) → H →* G i
f : (i : ι) → G i →* K
k : H →* K
hf : ∀ (i : ι), (f i).comp (φ i) = k
i : ι
g : G i
⊢ ((con φ).lift (Coprod.lift (CoprodI.lift f) k) ⋯) (((con φ).mk'.comp (inl.comp CoprodI.of)) g) = (f i) g
tactic: delta PushoutI lift of
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Monoid (G i)
inst✝ : Monoid H
φ : (i : ι) → H →* G i
f : (i : ι) → G i →* K
k : H →* K
hf : ∀ (i : ι), (f i).comp (φ i) = k
i : ι
g : G i
⊢ ((con φ).lift (Coprod.lift (CoprodI.lift f) k) ⋯) (((con φ).mk'.comp (inl.comp CoprodI.of)) g) = (f i) g
state_after: no goals
tactic: simp only [MonoidHom.coe_comp, Con.coe_mk', comp_apply, Con.lift_coe,
    lift_apply_inl, CoprodI.lift_of]
Theorem: MvPolynomial.optionEquivLeft_X_some
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
x : S₁
⊢ (optionEquivLeft R S₁) (X (Option.some x)) = Polynomial.C (X x)
state_after: no goals
tactic: simp [optionEquivLeft_apply, aeval_X]
Theorem: padicValNat.div
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
dvd : p ∣ b
⊢ padicValNat p (b / p) = padicValNat p b - 1
state_after: no goals
tactic: rw [padicValNat.div_of_dvd dvd, padicValNat_self]
Theorem: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, g x ∂μ.withDensity f = ∫⁻ (x : α) in s, (f * g) x ∂μ
state_after: no goals
tactic: rw [restrict_withDensity hs, lintegral_withDensity_eq_lintegral_mul _ hf hg]
Theorem: BoxIntegral.integralSum_biUnion_partition
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
πi : (J : Box ι) → Prepartition J
hπi : ∀ J ∈ π, (πi J).IsPartition
⊢ integralSum f vol (π.biUnionPrepartition πi) = integralSum f vol π
state_after: ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
πi : (J : Box ι) → Prepartition J
hπi : ∀ J ∈ π, (πi J).IsPartition
J : Box ι
hJ : J ∈ π.boxes
⊢ ∑ J' ∈ (πi J).boxes, (vol J') (f ((π.biUnionPrepartition πi).tag J')) = (vol J) (f (π.tag J))
tactic: refine (π.sum_biUnion_boxes _ _).trans (sum_congr rfl fun J hJ => ?_)
state_before: ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
πi : (J : Box ι) → Prepartition J
hπi : ∀ J ∈ π, (πi J).IsPartition
J : Box ι
hJ : J ∈ π.boxes
⊢ ∑ J' ∈ (πi J).boxes, (vol J') (f ((π.biUnionPrepartition πi).tag J')) = (vol J) (f (π.tag J))
state_after: no goals
tactic: calc
    (∑ J' ∈ (πi J).boxes, vol J' (f (π.tag <| π.toPrepartition.biUnionIndex πi J'))) =
        ∑ J' ∈ (πi J).boxes, vol J' (f (π.tag J)) :=
      sum_congr rfl fun J' hJ' => by rw [Prepartition.biUnionIndex_of_mem _ hJ hJ']
    _ = vol J (f (π.tag J)) :=
      (vol.map ⟨⟨fun g : E →L[ℝ] F => g (f (π.tag J)), rfl⟩, fun _ _ => rfl⟩).sum_partition_boxes
        le_top (hπi J hJ)
Theorem: Finset.singleton_subset_singleton
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a b : α
⊢ {a} ⊆ {b} ↔ a = b
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.kernel_from_eq_kernel
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
i j : ι
r : c.Rel i j
⊢ kernelSubobject (C.dFrom i) = kernelSubobject (C.d i j)
state_after: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
i j : ι
r : c.Rel i j
⊢ kernelSubobject (C.d i j ≫ (C.xNextIso r).inv) = kernelSubobject (C.d i j)
tactic: rw [C.dFrom_eq r]
state_before: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
i j : ι
r : c.Rel i j
⊢ kernelSubobject (C.d i j ≫ (C.xNextIso r).inv) = kernelSubobject (C.d i j)
state_after: no goals
tactic: apply kernelSubobject_comp_mono
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.isoRestrict_hom_ofRestrict
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
⊢ (isoRestrict f).hom ≫ Y.ofRestrict ⋯ = f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ (((isoRestrict f).hom ≫ Y.ofRestrict ⋯).c ≫ whiskerRight (eqToHom ⋯) X.presheaf).app x = f.c.app x
tactic: refine PresheafedSpace.Hom.ext _ _ rfl <| NatTrans.ext _ _ <| funext fun x => ?_
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ (((isoRestrict f).hom ≫ Y.ofRestrict ⋯).c ≫ whiskerRight (eqToHom ⋯) X.presheaf).app x = f.c.app x
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ (((isoRestrict f).hom ≫ Y.ofRestrict ⋯).c ≫
          𝟙 ((Opens.map ((isoRestrict f).hom ≫ Y.ofRestrict ⋯).base).op ⋙ X.presheaf)).app
      x =
    f.c.app x
tactic: simp only [isoRestrict_hom_c_app, NatTrans.comp_app, eqToHom_refl,
    ofRestrict_c_app, Category.assoc, whiskerRight_id']
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ (((isoRestrict f).hom ≫ Y.ofRestrict ⋯).c ≫
          𝟙 ((Opens.map ((isoRestrict f).hom ≫ Y.ofRestrict ⋯).base).op ⋙ X.presheaf)).app
      x =
    f.c.app x
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ f.c.app x ≫ X.presheaf.map ((Opens.map f.base).op.map (⋯.adjunction.counit.app (unop x)).op ≫ (eqToIso ⋯).hom) =
    f.c.app x
tactic: erw [Category.comp_id, comp_c_app, f.c.naturality_assoc, ← X.presheaf.map_comp]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ f.c.app x ≫ X.presheaf.map ((Opens.map f.base).op.map (⋯.adjunction.counit.app (unop x)).op ≫ (eqToIso ⋯).hom) =
    f.c.app x
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ f.c.app x ≫ X.presheaf.map ((Opens.map f.base).op.map (⋯.adjunction.counit.app (unop x)).op ≫ (eqToIso ⋯).hom) =
    f.c.app x ≫ X.presheaf.map (𝟙 ((Opens.map f.base).op.obj x))

C : Type u
inst✝ : Category.{v, u} C
X Y : PresheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
x : (Opens ↑↑Y)ᵒᵖ
⊢ f.c.app x ≫ X.presheaf.map (𝟙 ((Opens.map f.base).op.obj x)) = f.c.app x
tactic: trans f.c.app x ≫ X.presheaf.map (𝟙 _)
Theorem: RightDerivMeasurableAux.A_mono
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
⊢ A f L r ε ⊆ A f L r δ
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x ∈ A f L r δ
tactic: rintro x ⟨r', r'r, hr'⟩
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x ∈ A f L r δ
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
y : ℝ
hy : y ∈ Icc x (x + r')
z : ℝ
hz : z ∈ Icc x (x + r')
⊢ 0 ≤ r
tactic: refine ⟨r', r'r, fun y hy z hz => (hr' y hy z hz).trans (mul_le_mul_of_nonneg_right h ?_)⟩
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
y : ℝ
hy : y ∈ Icc x (x + r')
z : ℝ
hz : z ∈ Icc x (x + r')
⊢ 0 ≤ r
state_after: no goals
tactic: linarith [hy.1, hy.2, r'r.2]
Theorem: Primrec.unpair
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
n : ℕ
⊢ ((Nat.unpair n).1, (Nat.unpair n).2) = Nat.unpair n
state_after: no goals
tactic: simp
Theorem: AffineIndependent.affineSpan_disjoint_of_disjoint
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
s1 s2 : Set ι
hd : Disjoint s1 s2
⊢ Disjoint ↑(affineSpan k (p '' s1)) ↑(affineSpan k (p '' s2))
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
s1 s2 : Set ι
hd : Disjoint s1 s2
p0 : P
hp0s1 : p0 ∈ ↑(affineSpan k (p '' s1))
hp0s2 : p0 ∈ ↑(affineSpan k (p '' s2))
⊢ False
tactic: refine Set.disjoint_left.2 fun p0 hp0s1 hp0s2 => ?_
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
s1 s2 : Set ι
hd : Disjoint s1 s2
p0 : P
hp0s1 : p0 ∈ ↑(affineSpan k (p '' s1))
hp0s2 : p0 ∈ ↑(affineSpan k (p '' s2))
⊢ False
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
s1 s2 : Set ι
hd : Disjoint s1 s2
p0 : P
hp0s1 : p0 ∈ ↑(affineSpan k (p '' s1))
hp0s2 : p0 ∈ ↑(affineSpan k (p '' s2))
i : ι
hi : i ∈ s1 ∩ s2
⊢ False
tactic: cases' ha.exists_mem_inter_of_exists_mem_inter_affineSpan hp0s1 hp0s2 with i hi
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_4
inst✝ : Nontrivial k
p : ι → P
ha : AffineIndependent k p
s1 s2 : Set ι
hd : Disjoint s1 s2
p0 : P
hp0s1 : p0 ∈ ↑(affineSpan k (p '' s1))
hp0s2 : p0 ∈ ↑(affineSpan k (p '' s2))
i : ι
hi : i ∈ s1 ∩ s2
⊢ False
state_after: no goals
tactic: exact Set.disjoint_iff.1 hd hi
Theorem: ExceptT.goto_mkLabel
File: Mathlib/Control/Monad/Cont.lean

Proof steps:
state_before: m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
x : Label (Except ε α) m β
i : α
⊢ goto (mkLabel x) i = mk (Except.ok <$> goto x (Except.ok i))
state_after: case mk
m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
i : α
apply✝ : Except ε α → m β
⊢ goto (mkLabel { apply := apply✝ }) i = mk (Except.ok <$> goto { apply := apply✝ } (Except.ok i))
tactic: cases x
state_before: case mk
m : Type u → Type v
inst✝ : Monad m
α β ε : Type u
i : α
apply✝ : Except ε α → m β
⊢ goto (mkLabel { apply := apply✝ }) i = mk (Except.ok <$> goto { apply := apply✝ } (Except.ok i))
state_after: no goals
tactic: rfl
Theorem: Matrix.PosSemidef.sqrt_mul_self
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
⊢ hA.sqrt * hA.sqrt = A
state_after: no goals
tactic: rw [← pow_two, sq_sqrt]
Theorem: WeierstrassCurve.Projective.equation_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
P : Fin 3 → R
⊢ W.Equation P ↔
    P 1 ^ 2 * P 2 + W.a₁ * P 0 * P 1 * P 2 + W.a₃ * P 1 * P 2 ^ 2 =
      P 0 ^ 3 + W.a₂ * P 0 ^ 2 * P 2 + W.a₄ * P 0 * P 2 ^ 2 + W.a₆ * P 2 ^ 3
state_after: no goals
tactic: rw [Equation, eval_polynomial, sub_eq_zero]
Theorem: le_div_iff_mul_le
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a ≤ c / b ↔ a * b ≤ c
state_after: no goals
tactic: rw [← mul_le_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
Theorem: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), s.ι.app j ≫ P.map t w.hom ≫ Q.map s w.inv = s.ι.app j ≫ 𝟙 s.pt
state_after: no goals
tactic: aesop_cat
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), t.ι.app j ≫ Q.map s w.inv ≫ P.map t w.hom = t.ι.app j ≫ 𝟙 t.pt
state_after: no goals
tactic: aesop_cat
Theorem: StrictMono.pow_const
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝⁴ : Monoid M
inst✝³ : Preorder M
inst✝² : Preorder β
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
f : β → M
n : ℕ
hf : StrictMono f
x✝ : 1 ≠ 0
⊢ StrictMono fun x => f x ^ 1
state_after: no goals
tactic: simpa
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝⁴ : Monoid M
inst✝³ : Preorder M
inst✝² : Preorder β
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
f : β → M
n✝ : ℕ
hf : StrictMono f
n : ℕ
x✝ : n.succ.succ ≠ 0
⊢ StrictMono fun x => f x ^ n.succ.succ
state_after: no goals
tactic: simpa only [pow_succ] using (hf.pow_const n.succ_ne_zero).mul' hf
Theorem: ArithmeticFunction.vonMangoldt_nonneg
File: Mathlib/NumberTheory/VonMangoldt.lean

Proof steps:
state_before: n : ℕ
⊢ 0 ≤ Λ n
state_after: n : ℕ
⊢ 0 ≤ if IsPrimePow n then Real.log ↑n.minFac else 0
tactic: rw [vonMangoldt_apply]
state_before: n : ℕ
⊢ 0 ≤ if IsPrimePow n then Real.log ↑n.minFac else 0
state_after: case pos
n : ℕ
h✝ : IsPrimePow n
⊢ 0 ≤ Real.log ↑n.minFac

case neg
n : ℕ
h✝ : ¬IsPrimePow n
⊢ 0 ≤ 0
tactic: split_ifs
state_before: case neg
n : ℕ
h✝ : ¬IsPrimePow n
⊢ 0 ≤ 0
state_after: no goals
tactic: rfl
Theorem: Uniform.tendsto_nhds_left
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Filter β
u : β → α
a : α
⊢ Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Filter β
u : β → α
a : α
⊢ Tendsto ((fun y => (y, a)) ∘ u) f (𝓤 α) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)
tactic: rw [nhds_eq_comap_uniformity', tendsto_comap_iff]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
f : Filter β
u : β → α
a : α
⊢ Tendsto ((fun y => (y, a)) ∘ u) f (𝓤 α) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α)
state_after: no goals
tactic: rfl
Theorem: EllipticCurve.map_injective
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
⊢ x✝¹ = x✝
state_after: case intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : (Units.map ↑φ) x✝¹.Δ' = (Units.map ↑φ) x✝.Δ'
⊢ x✝¹ = x✝
tactic: rcases mk.inj h with ⟨h1, h2⟩
state_before: case intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : (Units.map ↑φ) x✝¹.Δ' = (Units.map ↑φ) x✝.Δ'
⊢ x✝¹ = x✝
state_after: case intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : ↑φ ↑x✝¹.Δ' = ↑φ ↑x✝.Δ'
⊢ x✝¹ = x✝
tactic: replace h2 := (Units.mk.inj h2).left
state_before: case intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : ↑φ ↑x✝¹.Δ' = ↑φ ↑x✝.Δ'
⊢ x✝¹ = x✝
state_after: case intro.intro.intro.intro.intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : ↑φ ↑x✝¹.Δ' = ↑φ ↑x✝.Δ'
left✝³ : φ x✝¹.a₁ = φ x✝.a₁
left✝² : φ x✝¹.a₂ = φ x✝.a₂
left✝¹ : φ x✝¹.a₃ = φ x✝.a₃
left✝ : φ x✝¹.a₄ = φ x✝.a₄
right✝ : φ x✝¹.a₆ = φ x✝.a₆
⊢ x✝¹ = x✝
tactic: rcases WeierstrassCurve.mk.inj h1 with ⟨_, _, _, _, _⟩
state_before: case intro.intro.intro.intro.intro
R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
A : Type v
inst✝ : CommRing A
φ✝ φ : R →+* A
hφ : Function.Injective ⇑φ
x✝¹ x✝ : EllipticCurve R
h : (fun E => E.map φ) x✝¹ = (fun E => E.map φ) x✝
h1 : x✝¹.map φ = x✝.map φ
h2 : ↑φ ↑x✝¹.Δ' = ↑φ ↑x✝.Δ'
left✝³ : φ x✝¹.a₁ = φ x✝.a₁
left✝² : φ x✝¹.a₂ = φ x✝.a₂
left✝¹ : φ x✝¹.a₃ = φ x✝.a₃
left✝ : φ x✝¹.a₄ = φ x✝.a₄
right✝ : φ x✝¹.a₆ = φ x✝.a₆
⊢ x✝¹ = x✝
state_after: no goals
tactic: ext <;> apply_fun _ using hφ <;> assumption
Theorem: DilationEquiv.smulTorsor_ratio
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : NormedDivisionRing 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : BoundedSMul 𝕜 E
P : Type u_3
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
k : 𝕜
hk : k ≠ 0
x y : E
h : dist x y ≠ 0
⊢ dist ((smulTorsor c hk) x) ((smulTorsor c hk) y) = ↑‖k‖₊ * dist x y
state_after: no goals
tactic: simp [dist_eq_norm, ← smul_sub, norm_smul]
Theorem: Order.Icc_pred_left
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h : pred a ≤ b
⊢ Icc (pred a) b = insert (pred a) (Icc a b)
state_after: no goals
tactic: simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
Theorem: LinearIndependent.image
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι✝ : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_8
s : Set ι
f : ι → M
hs : LinearIndependent R fun (x : ↑s) => f ↑x
⊢ LinearIndependent R fun (x : ↑(f '' s)) => ↑x
state_after: no goals
tactic: convert LinearIndependent.image_of_comp s f id hs
Theorem: CategoryTheory.Cat.rightUnitor_hom_app
File: Mathlib/CategoryTheory/Category/Cat.lean

Proof steps:
state_before: B C : Cat
F : B ⟶ C
X : ↑B
⊢ (F ≫ 𝟙 C).obj X = F.obj X
state_after: no goals
tactic: simp