ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.NatIso.naturality_2'
File: Mathlib/CategoryTheory/NatIso.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y : C
α : F ⟶ G
f : X ⟶ Y
x✝ : IsIso (α.app Y)
⊢ α.app X ≫ G.map f ≫ inv (α.app Y) = F.map f
state_after: no goals
tactic: rw [← Category.assoc, ← naturality, Category.assoc, IsIso.hom_inv_id, Category.comp_id]
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec_base_apply_eq_comap
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑(Proj.restrict ⋯).toTopCat
⊢ (toSpec 𝒜 f).val.base x = (PrimeSpectrum.comap (mapId 𝒜 ⋯)) (closedPoint (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal))
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑(Proj.restrict ⋯).toTopCat
⊢ (PrimeSpectrum.comap (awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).presheaf.Γgerm x))
      (closedPoint ↑((Proj.restrict ⋯).presheaf.stalk x)) =
    (PrimeSpectrum.comap (mapId 𝒜 ⋯)) (closedPoint (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal))
tactic: show PrimeSpectrum.comap (awayToΓ 𝒜 f ≫ (Proj| pbo f).presheaf.Γgerm x)
        (LocalRing.closedPoint ((Proj| pbo f).presheaf.stalk x)) = _
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑(Proj.restrict ⋯).toTopCat
⊢ (PrimeSpectrum.comap (awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).presheaf.Γgerm x))
      (closedPoint ↑((Proj.restrict ⋯).presheaf.stalk x)) =
    (PrimeSpectrum.comap (mapId 𝒜 ⋯)) (closedPoint (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal))
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑(Proj.restrict ⋯).toTopCat
⊢ ((PrimeSpectrum.comap (mapId 𝒜 ⋯)).comp
        (PrimeSpectrum.comap ((Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv ≫ (Proj.restrictStalkIso ⋯ x).inv)))
      (closedPoint ↑((Proj.restrict ⋯).presheaf.stalk x)) =
    (PrimeSpectrum.comap (mapId 𝒜 ⋯)) (closedPoint (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal))
tactic: rw [awayToΓ_ΓToStalk, CommRingCat.comp_eq_ring_hom_comp, PrimeSpectrum.comap_comp]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑(Proj.restrict ⋯).toTopCat
⊢ ((PrimeSpectrum.comap (mapId 𝒜 ⋯)).comp
        (PrimeSpectrum.comap ((Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv ≫ (Proj.restrictStalkIso ⋯ x).inv)))
      (closedPoint ↑((Proj.restrict ⋯).presheaf.stalk x)) =
    (PrimeSpectrum.comap (mapId 𝒜 ⋯)) (closedPoint (AtPrime 𝒜 (↑x).asHomogeneousIdeal.toIdeal))
state_after: no goals
tactic: exact congr(PrimeSpectrum.comap _ $(@LocalRing.comap_closedPoint
    (HomogeneousLocalization.AtPrime 𝒜 x.1.asHomogeneousIdeal.toIdeal) _ _
    ((Proj| pbo f).presheaf.stalk x) _ _ _ (isLocalRingHom_of_isIso _)))
Theorem: LinearMap.BilinForm.nondegenerate_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : AddCommMonoid M
inst✝¹⁷ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁶ : CommRing R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_11
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_12
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : BilinForm A M₃
b : Basis ι A M₃
⊢ B.Nondegenerate ↔ ((BilinForm.toMatrix b) B).det ≠ 0
state_after: no goals
tactic: rw [← Matrix.nondegenerate_iff_det_ne_zero, nondegenerate_toMatrix_iff]
Theorem: Vector.tendsto_cons
File: Mathlib/Topology/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : Vector α n
⊢ Tendsto (fun p => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : Vector α n
⊢ Tendsto (fun x => ↑(x.1 ::ᵥ x.2)) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: ↑l))
tactic: rw [tendsto_subtype_rng, Vector.cons_val]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : Vector α n
⊢ Tendsto (fun x => ↑(x.1 ::ᵥ x.2)) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: ↑l))
state_after: no goals
tactic: exact tendsto_fst.cons (Tendsto.comp continuousAt_subtype_val tendsto_snd)
Theorem: MeasureTheory.AEStronglyMeasurable.comp_snd_map_prod_id
File: Mathlib/Probability/Kernel/Condexp.lean

Proof steps:
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)
tactic: rw [← aestronglyMeasurable_comp_snd_map_prod_mk_iff (measurable_id'' hm)] at hf
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (id ω, id ω)) μ)
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
tactic: simp_rw [id] at hf ⊢
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
μ : Measure Ω
f : Ω → F
inst✝ : TopologicalSpace F
hm : m ≤ mΩ
hf : AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
⊢ AEStronglyMeasurable (fun x => f x.2) (Measure.map (fun ω => (ω, ω)) μ)
state_after: no goals
tactic: exact hf
Theorem: NNReal.finset_sup_div
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r✝ r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
f : α → ℝ≥0
s : Finset α
r : ℝ≥0
⊢ s.sup f / r = s.sup fun a => f a / r
state_after: no goals
tactic: simp only [div_eq_inv_mul, mul_finset_sup]
Theorem: CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_inv_comp_rightHomologyι
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ h.rightHomologyIso.inv ≫ S.rightHomologyι = h.ι ≫ h.opcyclesIso.inv
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ rightHomologyMap' (𝟙 S) h S.rightHomologyData ≫ S.rightHomologyData.ι = h.ι ≫ opcyclesMap' (𝟙 S) h S.rightHomologyData
tactic: dsimp only [rightHomologyι, rightHomologyIso, opcyclesIso, rightHomologyMapIso',
    opcyclesMapIso', Iso.refl]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ rightHomologyMap' (𝟙 S) h S.rightHomologyData ≫ S.rightHomologyData.ι = h.ι ≫ opcyclesMap' (𝟙 S) h S.rightHomologyData
state_after: no goals
tactic: rw [rightHomologyι_naturality']
Theorem: MeasureTheory.L1.SimpleFunc.norm_setToL1S_le
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ‖T s‖ ≤ C * (μ s).toReal
f : ↥(simpleFunc E 1 μ)
⊢ ‖setToL1S T f‖ ≤ C * ‖f‖
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ‖T s‖ ≤ C * (μ s).toReal
f : ↥(simpleFunc E 1 μ)
⊢ ‖SimpleFunc.setToSimpleFunc T (toSimpleFunc f)‖ ≤
    C * ∑ x ∈ (toSimpleFunc f).range, (μ (↑(toSimpleFunc f) ⁻¹' {x})).toReal * ‖x‖
tactic: rw [setToL1S, norm_eq_sum_mul f]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
C : ℝ
hT_norm : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ‖T s‖ ≤ C * (μ s).toReal
f : ↥(simpleFunc E 1 μ)
⊢ ‖SimpleFunc.setToSimpleFunc T (toSimpleFunc f)‖ ≤
    C * ∑ x ∈ (toSimpleFunc f).range, (μ (↑(toSimpleFunc f) ⁻¹' {x})).toReal * ‖x‖
state_after: no goals
tactic: exact
    SimpleFunc.norm_setToSimpleFunc_le_sum_mul_norm_of_integrable T hT_norm _
      (SimpleFunc.integrable f)
Theorem: Complex.sin_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℂ
⊢ sin (↑π / 2 - x) = cos x
state_after: no goals
tactic: simp [sub_eq_add_neg, sin_add]
Theorem: ENNReal.add_iInf
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a + iInf f = ⨅ b, a + f b
state_after: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ⨅ i, f i + a = ⨅ b, a + f b
tactic: rw [add_comm, iInf_add]
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ⨅ i, f i + a = ⨅ b, a + f b
state_after: no goals
tactic: simp [add_comm]
Theorem: nhds_mul
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ 𝓝 (x * y) = map (fun x_1 => x * x_1) (map (fun x => x * y) (𝓝 1 * 𝓝 1))
state_after: no goals
tactic: simp
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map (fun x_1 => x * x_1) (map (fun x => x * y) (𝓝 1 * 𝓝 1)) = map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1)
state_after: no goals
tactic: rw [← map₂_mul, map_map₂, map_map₂]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1) = map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1)
state_after: no goals
tactic: simp only [mul_assoc]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1) = 𝓝 x * 𝓝 y
state_after: no goals
tactic: rw [← map_mul_left_nhds_one x, ← map_mul_right_nhds_one y, ← map₂_mul, map₂_map_left,
        map₂_map_right]
Theorem: Real.Gamma_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ ∀ {n : ℕ}, -↑n < s → Gamma s ≠ 0
state_after: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
n : ℕ
⊢ -↑n < s → Gamma s ≠ 0
tactic: intro n
state_before: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
n : ℕ
⊢ -↑n < s → Gamma s ≠ 0
state_after: case zero
s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ -↑0 < s → Gamma s ≠ 0

case succ
n✝ : ℕ
n_ih : ∀ {s : ℝ}, (∀ (m : ℕ), s ≠ -↑m) → -↑n✝ < s → Gamma s ≠ 0
s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ -↑(n✝ + 1) < s → Gamma s ≠ 0
tactic: induction' n with _ n_ih generalizing s
Theorem: AlgebraicGeometry.quasiSeparated_over_affine_iff
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

Proof steps:
state_before: X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsAffine Y
⊢ QuasiSeparated f ↔ QuasiSeparatedSpace ↑↑X.toPresheafedSpace
state_after: no goals
tactic: rw [HasAffineProperty.iff_of_isAffine (P := @QuasiSeparated)]
Theorem: Fin.castOrderIso_refl
File: Mathlib/Order/Fin/Basic.lean

Proof steps:
state_before: m n : ℕ
p : Fin (n + 1)
i j : Fin n
h : optParam (n = n) ⋯
⊢ castOrderIso h = OrderIso.refl (Fin n)
state_after: case h.h.h
m n : ℕ
p : Fin (n + 1)
i j : Fin n
h : optParam (n = n) ⋯
x✝ : Fin n
⊢ ↑((castOrderIso h) x✝) = ↑((OrderIso.refl (Fin n)) x✝)
tactic: ext
state_before: case h.h.h
m n : ℕ
p : Fin (n + 1)
i j : Fin n
h : optParam (n = n) ⋯
x✝ : Fin n
⊢ ↑((castOrderIso h) x✝) = ↑((OrderIso.refl (Fin n)) x✝)
state_after: no goals
tactic: simp
Theorem: List.mapIdxMAux'_eq_mapIdxMGo
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
f : ℕ → α → m PUnit.{u + 1}
as : List α
arr : Array PUnit.{u + 1}
⊢ mapIdxMAux' f arr.size as = SeqRight.seqRight (mapIdxM.go f as arr) fun x => pure PUnit.unit
state_after: α✝ : Type u
β : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
f : ℕ → α → m PUnit.{u + 1}
as : List α
⊢ ∀ (arr : Array PUnit.{u + 1}),
    mapIdxMAux' f arr.size as = SeqRight.seqRight (mapIdxM.go f as arr) fun x => pure PUnit.unit
tactic: revert arr
state_before: α✝ : Type u
β : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
f : ℕ → α → m PUnit.{u + 1}
as : List α
⊢ ∀ (arr : Array PUnit.{u + 1}),
    mapIdxMAux' f arr.size as = SeqRight.seqRight (mapIdxM.go f as arr) fun x => pure PUnit.unit
state_after: case nil
α✝ : Type u
β : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
f : ℕ → α → m PUnit.{u + 1}
arr : Array PUnit.{u + 1}
⊢ mapIdxMAux' f arr.size [] = SeqRight.seqRight (mapIdxM.go f [] arr) fun x => pure PUnit.unit

case cons
α✝ : Type u
β : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
f : ℕ → α → m PUnit.{u + 1}
head : α
tail : List α
ih :
  ∀ (arr : Array PUnit.{u + 1}),
    mapIdxMAux' f arr.size tail = SeqRight.seqRight (mapIdxM.go f tail arr) fun x => pure PUnit.unit
arr : Array PUnit.{u + 1}
⊢ mapIdxMAux' f arr.size (head :: tail) = SeqRight.seqRight (mapIdxM.go f (head :: tail) arr) fun x => pure PUnit.unit
tactic: induction' as with head tail ih <;> intro arr
Theorem: Nat.floorRoot_def
File: Mathlib/Data/Nat/Factorization/Root.lean

Proof steps:
state_before: a b n : ℕ
⊢ n.floorRoot a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod fun x x_1 => x ^ x_1
state_after: a b n : ℕ
⊢ (if n = 0 ∨ a = 0 then 0 else a.factorization.prod fun p k => p ^ (k / n)) =
    if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod fun x x_1 => x ^ x_1
tactic: unfold floorRoot
state_before: a b n : ℕ
⊢ (if n = 0 ∨ a = 0 then 0 else a.factorization.prod fun p k => p ^ (k / n)) =
    if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod fun x x_1 => x ^ x_1
state_after: no goals
tactic: split_ifs with h <;> simp [Finsupp.floorDiv_def, prod_mapRange_index pow_zero]
Theorem: VitaliFamily.frequently_filterAt_iff
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
P : Set α → Prop
⊢ (∃ᶠ (a : Set α) in v.filterAt x, P a) ↔ ∀ ε > 0, ∃ a ∈ v.setsAt x, a ⊆ closedBall x ε ∧ P a
state_after: no goals
tactic: simp only [(v.filterAt_basis_closedBall x).frequently_iff, ← and_assoc, subset_def, mem_setOf]
Theorem: List.subperm_ext_iff
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ l₁ <+~ l₂ ↔ ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
state_after: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
⊢ l₁ <+~ l₂
tactic: refine ⟨fun h x _ => h.count_le x, fun h => ?_⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
⊢ l₁ <+~ l₂
state_after: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
this : l₁ <+~ l₂.diff l₁ ++ l₁
⊢ l₁ <+~ l₂
tactic: have : l₁ <+~ l₂.diff l₁ ++ l₁ := (subperm_append_right l₁).mpr nil_subperm
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
this : l₁ <+~ l₂.diff l₁ ++ l₁
⊢ l₁ <+~ l₂
state_after: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
this : l₁ <+~ l₂.diff l₁ ++ l₁
⊢ l₂.diff l₁ ++ l₁ ~ l₂
tactic: refine this.trans (Perm.subperm ?_)
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
this : l₁ <+~ l₂.diff l₁ ++ l₁
⊢ l₂.diff l₁ ++ l₁ ~ l₂
state_after: no goals
tactic: exact perm_append_comm.trans (subperm_append_diff_self_of_count_le h)
Theorem: split_by_characteristic_localRing
File: Mathlib/Algebra/CharP/MixedCharZero.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
⊢ P
state_after: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
⊢ ∀ (p : ℕ), p ≠ 0 → CharP R p → P
tactic: refine split_by_characteristic R ?_ h_equal h_mixed
state_before: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
⊢ ∀ (p : ℕ), p ≠ 0 → CharP R p → P
state_after: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_pos : p ≠ 0
p_char : CharP R p
⊢ P
tactic: intro p p_pos p_char
state_before: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_pos : p ≠ 0
p_char : CharP R p
⊢ P
state_after: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_pos : p ≠ 0
p_char : CharP R p
p_ppow : IsPrimePow p
⊢ P
tactic: have p_ppow : IsPrimePow (p : ℕ) := or_iff_not_imp_left.mp (charP_zero_or_prime_power R p) p_pos
state_before: R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : LocalRing R
h_pos : ∀ (p : ℕ), IsPrimePow p → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_pos : p ≠ 0
p_char : CharP R p
p_ppow : IsPrimePow p
⊢ P
state_after: no goals
tactic: exact h_pos p p_ppow p_char
Theorem: WeierstrassCurve.Affine.evalEval_polynomial_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ evalEval 0 0 W.polynomial = -W.a₆
state_after: no goals
tactic: simp only [evalEval_polynomial, zero_add, zero_sub, mul_zero, zero_pow <| Nat.succ_ne_zero _]
Theorem: Wbtw.trans_right_ne
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w x z
h₂ : Wbtw R x y z
h : w ≠ x
⊢ w ≠ y
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x z : P
h₁ : Wbtw R w x z
h : w ≠ x
h₂ : Wbtw R x w z
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x z : P
h₁ : Wbtw R w x z
h : w ≠ x
h₂ : Wbtw R x w z
⊢ False
state_after: no goals
tactic: exact h (h₁.swap_left_iff.1 h₂)
Theorem: LinearAlgebra.FreeProduct.identify_one
File: Mathlib/LinearAlgebra/FreeProduct/Basic.lean

Proof steps:
state_before: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (ι' R A) ((lof R I A i) 1) = 1
state_after: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (ι' R A) ((lof R I A i) 1) = (mkAlgHom R A) 1
tactic: suffices ι' R A (DirectSum.lof R I A i 1) = mkAlgHom R A 1 by simpa
state_before: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (ι' R A) ((lof R I A i) 1) = (mkAlgHom R A) 1
state_after: no goals
tactic: exact RingQuot.mkAlgHom_rel R <| rel_id R A (i := i)