ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.ΓSpec.right_triangle
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: R : CommRingCat
⊢ identityToΓSpec.app (Spec.toLocallyRingedSpace.obj (op R)) ≫
      Spec.toLocallyRingedSpace.map (SpecΓIdentity.inv.app R).op =
    𝟙 ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R)))
state_after: case w
R : CommRingCat
⊢ ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R))).toΓSpec.val.base ≫
      (Spec.locallyRingedSpaceMap (SpecΓIdentity.inv.app R).op.unop).val.base =
    (𝟙 ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R)))).val.base

case h
R : CommRingCat
⊢ ∀ (r : ↑(unop (op ((𝟭 CommRingCat).obj R)))),
    (SpecΓIdentity.inv.app R).op.unop ≫
        ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R))).presheaf.map (homOfLE ⋯).op =
      toOpen (↑(unop (op ((𝟭 CommRingCat).obj R)))) (basicOpen r) ≫
        (𝟙 ((𝟭 LocallyRingedSpace).obj (Spec.toLocallyRingedSpace.obj (op R)))).val.c.app (op (basicOpen r))
tactic: apply LocallyRingedSpace.comp_ring_hom_ext
Theorem: MeasureTheory.Measure.isAddInvariant_eq_smul_of_compactSpace
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
⊢ μ' = μ'.haarScalarFactor μ • μ
state_after: case h
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
s : Set G
_hs : MeasurableSet s
⊢ μ' s = (μ'.haarScalarFactor μ • μ) s
tactic: ext s _hs
state_before: case h
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : CompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : μ'.IsMulLeftInvariant
inst✝ : IsFiniteMeasureOnCompacts μ'
s : Set G
_hs : MeasurableSet s
⊢ μ' s = (μ'.haarScalarFactor μ • μ) s
state_after: no goals
tactic: exact measure_isMulInvariant_eq_smul_of_isCompact_closure _ _ isClosed_closure.isCompact
Theorem: Set.strictAntiOn_iff_strictAnti
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ StrictAntiOn f s ↔ StrictAnti fun a => f ↑a
state_after: no goals
tactic: simp [StrictAnti, StrictAntiOn]
Theorem: multiples.add_mem
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
x y z : M
x✝¹ : y ∈ powers x
x✝ : z ∈ powers x
n₁ : ℕ
h₁ : x ^ n₁ = y
n₂ : ℕ
h₂ : x ^ n₂ = z
⊢ x ^ (n₁ + n₂) = y * z
state_after: no goals
tactic: simp only [pow_add, *]
Theorem: Rel.comp_assoc
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
⊢ (r • s) • t = r • s • t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
⊢ (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z
tactic: unfold comp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
⊢ (fun x z => ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y z) = fun x z => ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 z
state_after: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w) ↔ ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w
tactic: ext (x w)
state_before: case a.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w) ↔ ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w
state_after: case a.h.a.mp
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w) → ∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w

case a.h.a.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : Rel α β
δ : Type u_4
r : Rel α β
s : Rel β γ
t : Rel γ δ
x : α
w : δ
⊢ (∃ y, r x y ∧ ∃ y_1, s y y_1 ∧ t y_1 w) → ∃ y, (∃ y_1, r x y_1 ∧ s y_1 y) ∧ t y w
tactic: constructor
Theorem: Polynomial.trailingCoeff_mul
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝² : Semiring R✝
f : R✝[X]
R : Type u_2
inst✝¹ : Ring R
inst✝ : NoZeroDivisors R
p q : R[X]
⊢ (p * q).trailingCoeff = p.trailingCoeff * q.trailingCoeff
state_after: no goals
tactic: rw [← reverse_leadingCoeff, reverse_mul_of_domain, leadingCoeff_mul, reverse_leadingCoeff,
    reverse_leadingCoeff]
Theorem: BoxIntegral.Prepartition.injective_boxes
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
⊢ Injective boxes
state_after: case mk.mk
ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
s₁ : Finset (Box ι)
h₁ : ∀ J ∈ s₁, J ≤ I
h₁' : (↑s₁).Pairwise (Disjoint on Box.toSet)
h₂ : ∀ J ∈ s₁, J ≤ I
h₂' : (↑s₁).Pairwise (Disjoint on Box.toSet)
⊢ { boxes := s₁, le_of_mem' := h₁, pairwiseDisjoint := h₁' } =
    { boxes := s₁, le_of_mem' := h₂, pairwiseDisjoint := h₂' }
tactic: rintro ⟨s₁, h₁, h₁'⟩ ⟨s₂, h₂, h₂'⟩ (rfl : s₁ = s₂)
state_before: case mk.mk
ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
s₁ : Finset (Box ι)
h₁ : ∀ J ∈ s₁, J ≤ I
h₁' : (↑s₁).Pairwise (Disjoint on Box.toSet)
h₂ : ∀ J ∈ s₁, J ≤ I
h₂' : (↑s₁).Pairwise (Disjoint on Box.toSet)
⊢ { boxes := s₁, le_of_mem' := h₁, pairwiseDisjoint := h₁' } =
    { boxes := s₁, le_of_mem' := h₂, pairwiseDisjoint := h₂' }
state_after: no goals
tactic: rfl
Theorem: List.rdrop_zero
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ l.rdrop 0 = l
state_after: no goals
tactic: simp [rdrop]
Theorem: circleIntegral.integral_smul_const
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → ℂ
a : E
c : ℂ
R : ℝ
⊢ (∮ (z : ℂ) in C(c, R), f z • a) = (∮ (z : ℂ) in C(c, R), f z) • a
state_after: no goals
tactic: simp only [circleIntegral, intervalIntegral.integral_smul_const, ← smul_assoc]
Theorem: Multiset.prod_eq_zero_iff
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CommMonoidWithZero α
s✝ : Multiset α
inst✝¹ : NoZeroDivisors α
inst✝ : Nontrivial α
s : Multiset α
l : List α
⊢ prod ⟦l⟧ = 0 ↔ 0 ∈ ⟦l⟧
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CommMonoidWithZero α
s✝ : Multiset α
inst✝¹ : NoZeroDivisors α
inst✝ : Nontrivial α
s : Multiset α
l : List α
⊢ l.prod = 0 ↔ 0 ∈ ↑l
tactic: rw [quot_mk_to_coe, prod_coe]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : CommMonoidWithZero α
s✝ : Multiset α
inst✝¹ : NoZeroDivisors α
inst✝ : Nontrivial α
s : Multiset α
l : List α
⊢ l.prod = 0 ↔ 0 ∈ ↑l
state_after: no goals
tactic: exact List.prod_eq_zero_iff
Theorem: AdjoinRoot.aeval_eq
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
x : R
⊢ (aeval (root f)) (C x) = (mk f) (C x)
state_after: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
x : R
⊢ (algebraMap R (AdjoinRoot f)) x = (mk f) (C x)
tactic: rw [aeval_C]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
x : R
⊢ (algebraMap R (AdjoinRoot f)) x = (mk f) (C x)
state_after: no goals
tactic: rfl
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p✝ p q : R[X]
ihp : (aeval (root f)) p = (mk f) p
ihq : (aeval (root f)) q = (mk f) q
⊢ (aeval (root f)) (p + q) = (mk f) (p + q)
state_after: no goals
tactic: rw [map_add, RingHom.map_add, ihp, ihq]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
n : ℕ
x : R
x✝ : (aeval (root f)) (C x * X ^ n) = (mk f) (C x * X ^ n)
⊢ (aeval (root f)) (C x * X ^ (n + 1)) = (mk f) (C x * X ^ (n + 1))
state_after: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
n : ℕ
x : R
x✝ : (aeval (root f)) (C x * X ^ n) = (mk f) (C x * X ^ n)
⊢ (algebraMap R (AdjoinRoot f)) x * root f ^ (n + 1) = (of f) x * root f ^ (n + 1)
tactic: rw [_root_.map_mul, aeval_C, map_pow, aeval_X, RingHom.map_mul, mk_C, RingHom.map_pow, mk_X]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f p : R[X]
n : ℕ
x : R
x✝ : (aeval (root f)) (C x * X ^ n) = (mk f) (C x * X ^ n)
⊢ (algebraMap R (AdjoinRoot f)) x * root f ^ (n + 1) = (of f) x * root f ^ (n + 1)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Pi.comapEvalIsoEval_hom_app
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)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ ((fun f => Iso.refl ((comap C h ⋙ eval (C ∘ h) j).obj f)) Y).hom =
      ((fun f => Iso.refl ((comap C h ⋙ eval (C ∘ h) j).obj f)) X).hom ≫ (eval C (h j)).map f
state_after: I : Type w₀
J✝ : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ 𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj Y) =
      𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj X) ≫ (eval C (h j)).map f
tactic: simp only [Iso.refl]
state_before: I : Type w₀
J✝ : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
J : Type w₁
K : Type w₂
h : J → I
j : J
⊢ ∀ {X Y : (i : I) → C i} (f : X ⟶ Y),
    (comap C h ⋙ eval (C ∘ h) j).map f ≫ 𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj Y) =
      𝟙 ((comap C h ⋙ eval (C ∘ h) j).obj X) ≫ (eval C (h j)).map f
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.Limits.biproduct.matrixEquiv_apply
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
⊢ components (matrix m) = m
state_after: case h.h
J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
x✝¹ : J
x✝ : K
⊢ components (matrix m) x✝¹ x✝ = m x✝¹ x✝
tactic: ext
state_before: case h.h
J : Type
inst✝⁴ : Finite J
K : Type
inst✝³ : Finite K
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
x✝¹ : J
x✝ : K
⊢ components (matrix m) x✝¹ x✝ = m x✝¹ x✝
state_after: no goals
tactic: apply biproduct.matrix_components
Theorem: bernoulli'_def
File: Mathlib/NumberTheory/Bernoulli.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ bernoulli' n = 1 - ∑ k ∈ range n, ↑(n.choose k) / (↑n - ↑k + 1) * bernoulli' k
state_after: no goals
tactic: rw [bernoulli'_def', ← Fin.sum_univ_eq_sum_range]
Theorem: IsNoetherianRing.isNilpotent_nilradical
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsNoetherianRing R
⊢ IsNilpotent (nilradical R)
state_after: case intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsNoetherianRing R
n : ℕ
hn : ⊥.radical ^ n ≤ ⊥
⊢ IsNilpotent (nilradical R)
tactic: obtain ⟨n, hn⟩ := Ideal.exists_radical_pow_le_of_fg (⊥ : Ideal R) (IsNoetherian.noetherian _)
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsNoetherianRing R
n : ℕ
hn : ⊥.radical ^ n ≤ ⊥
⊢ IsNilpotent (nilradical R)
state_after: no goals
tactic: exact ⟨n, eq_bot_iff.mpr hn⟩
Theorem: PseudoMetricSpace.replaceUniformity_eq
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
U : UniformSpace α
m : PseudoMetricSpace α
H : 𝓤 α = 𝓤 α
⊢ m.replaceUniformity H = m
state_after: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
U : UniformSpace α
m : PseudoMetricSpace α
H : 𝓤 α = 𝓤 α
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
tactic: ext
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
U : UniformSpace α
m : PseudoMetricSpace α
H : 𝓤 α = 𝓤 α
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.map_lift_piComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
⊢ G.map (Pi.lift g) ≫ piComparison G f = Pi.lift fun j => G.map (g j)
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
j : β
⊢ (G.map (Pi.lift g) ≫ piComparison G f) ≫ Pi.π (fun b => G.obj (f b)) j =
    (Pi.lift fun j => G.map (g j)) ≫ Pi.π (fun b => G.obj (f b)) j
tactic: ext j
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
j : β
⊢ (G.map (Pi.lift g) ≫ piComparison G f) ≫ Pi.π (fun b => G.obj (f b)) j =
    (Pi.lift fun j => G.map (g j)) ≫ Pi.π (fun b => G.obj (f b)) j
state_after: no goals
tactic: simp only [Discrete.functor_obj, Category.assoc, piComparison_comp_π, ← G.map_comp,
    limit.lift_π, Fan.mk_pt, Fan.mk_π_app]
Theorem: UniqueFactorizationMonoid.normalizedFactors_multiset_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
s : Multiset α
hs : 0 ∉ s
⊢ normalizedFactors s.prod = (Multiset.map normalizedFactors s).sum
state_after: case inl
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
s : Multiset α
hs : 0 ∉ s
h✝ : Subsingleton α
⊢ normalizedFactors s.prod = (Multiset.map normalizedFactors s).sum

case inr
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
s : Multiset α
hs : 0 ∉ s
h✝ : Nontrivial α
⊢ normalizedFactors s.prod = (Multiset.map normalizedFactors s).sum
tactic: cases subsingleton_or_nontrivial α
Theorem: Nat.Partition.ofComposition_parts
File: Mathlib/Combinatorics/Enumerative/Partition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
⊢ (↑c.blocks).sum = n
state_after: no goals
tactic: rw [Multiset.sum_coe, c.blocks_sum]
Theorem: Nat.cast_commute
File: Mathlib/Data/Nat/Cast/Commute.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NonAssocSemiring α
n : ℕ
x : α
⊢ Commute (↑n) x
state_after: no goals
tactic: induction n with
  | zero => rw [Nat.cast_zero]; exact Commute.zero_left x
  | succ n ihn => rw [Nat.cast_succ]; exact ihn.add_left (Commute.one_left x)
Theorem: Nat.factorization_centralBinom_of_two_mul_self_lt_three_mul
File: Mathlib/Data/Nat/Choose/Factorization.lean

Proof steps:
state_before: p n k : ℕ
n_big : 2 < n
p_le_n : p ≤ n
big : 2 * n < 3 * p
⊢ n.centralBinom.factorization p = 0
state_after: case refine_1
p n k : ℕ
n_big : 2 < n
p_le_n : p ≤ n
big : 2 * n < 3 * p
⊢ p ≠ 2

case refine_2
p n k : ℕ
n_big : 2 < n
p_le_n : p ≤ n
big : 2 * n < 3 * p
⊢ n ≤ 2 * n - n
tactic: refine factorization_choose_of_lt_three_mul ?_ p_le_n (p_le_n.trans ?_) big
Theorem: CircleDeg1Lift.iterate_pos_lt_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
n : ℕ
hn : 0 < n
⊢ (⇑f)^[n] x < x + ↑n * ↑m ↔ f x < x + ↑m
state_after: no goals
tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
    (f.commute_add_int m).iterate_pos_lt_iff_map_lt f.monotone (strictMono_id.add_const (m : ℝ)) hn
Theorem: WeakFEPair.f_modif_aux1
File: Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
⊢ EqOn (fun x => P.f_modif x - P.f x + P.f₀)
    (((Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1) (Ioi 0)
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ (fun x => P.f_modif x - P.f x + P.f₀) x =
    (((Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1) x
tactic: intro x (hx : 0 < x)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ (fun x => P.f_modif x - P.f x + P.f₀) x =
    (((Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1) x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ (Ioi 1).indicator (fun x => P.f x - P.f₀) x + (Ioo 0 1).indicator (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x -
        P.f x +
      P.f₀ =
    (Ioo 0 1).indicator (fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x + {1}.indicator (fun x => P.f₀ - P.f 1) x
tactic: simp_rw [f_modif, Pi.add_apply]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ (Ioi 1).indicator (fun x => P.f x - P.f₀) x + (Ioo 0 1).indicator (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x -
        P.f x +
      P.f₀ =
    (Ioo 0 1).indicator (fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x + {1}.indicator (fun x => P.f₀ - P.f 1) x
state_after: case inl
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
hx' : x < 1
⊢ (Ioi 1).indicator (fun x => P.f x - P.f₀) x + (Ioo 0 1).indicator (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x -
        P.f x +
      P.f₀ =
    (Ioo 0 1).indicator (fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x + {1}.indicator (fun x => P.f₀ - P.f 1) x

case inr.inl
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
hx : 0 < 1
⊢ (Ioi 1).indicator (fun x => P.f x - P.f₀) 1 + (Ioo 0 1).indicator (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) 1 -
        P.f 1 +
      P.f₀ =
    (Ioo 0 1).indicator (fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) 1 + {1}.indicator (fun x => P.f₀ - P.f 1) 1

case inr.inr
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
hx' : 1 < x
⊢ (Ioi 1).indicator (fun x => P.f x - P.f₀) x + (Ioo 0 1).indicator (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x -
        P.f x +
      P.f₀ =
    (Ioo 0 1).indicator (fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) x + {1}.indicator (fun x => P.f₀ - P.f 1) x
tactic: rcases lt_trichotomy x 1 with hx' | rfl | hx'
Theorem: Set.preimage_sub_const_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Iio b = Iio (b + a)
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: neg_zsmul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ (-0) = (a ^ 0)⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ 0 = (a ^ 0)⁻¹
tactic: change a ^ (0 : ℤ) = (a ^ (0 : ℤ))⁻¹
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ 0 = (a ^ 0)⁻¹
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = (a ^ Int.negSucc n)⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = a ^ ↑(n + 1)
tactic: rw [zpow_negSucc, inv_inv, ← zpow_natCast]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = a ^ ↑(n + 1)
state_after: no goals
tactic: rfl
Theorem: ContinuousMap.isUnit_iff_forall_isUnit
File: Mathlib/Topology/ContinuousFunction/Units.lean

Proof steps:
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
⊢ ↑(unitsLift (unitsOfForallIsUnit h)) = f
state_after: case h
X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
a✝ : X
⊢ ↑(unitsLift (unitsOfForallIsUnit h)) a✝ = f a✝
tactic: ext
state_before: case h
X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (f x)
a✝ : X
⊢ ↑(unitsLift (unitsOfForallIsUnit h)) a✝ = f a✝
state_after: no goals
tactic: rfl
Theorem: Matrix.zpow_add_one
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ A ^ (↑n + 1) = A ^ ↑n * A
state_after: no goals
tactic: simp only [← Nat.cast_succ, pow_succ, zpow_natCast]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ A ^ (-(↑n + 1) + 1) = (A ^ n)⁻¹
state_after: no goals
tactic: rw [neg_add, neg_add_cancel_right, zpow_neg h, zpow_natCast]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ (A ^ n)⁻¹ = (A * A ^ n)⁻¹ * A
state_after: no goals
tactic: rw [mul_inv_rev, Matrix.mul_assoc, nonsing_inv_mul _ h, Matrix.mul_one]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
n : ℕ
⊢ (A * A ^ n)⁻¹ * A = A ^ (-(↑n + 1)) * A
state_after: no goals
tactic: rw [zpow_neg h, ← Int.ofNat_succ, zpow_natCast, pow_succ']
Theorem: ProbabilityTheory.Kernel.Invariant.comp
File: Mathlib/Probability/Kernel/Invariance.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ η : Kernel α α
μ : Measure α
inst✝ : IsSFiniteKernel κ
hκ : κ.Invariant μ
hη : η.Invariant μ
⊢ (κ ∘ₖ η).Invariant μ
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ η : Kernel α α
μ : Measure α
inst✝ : IsSFiniteKernel κ
hκ : κ.Invariant μ
hη : η.Invariant μ
h✝ : IsEmpty α
⊢ (κ ∘ₖ η).Invariant μ

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ η : Kernel α α
μ : Measure α
inst✝ : IsSFiniteKernel κ
hκ : κ.Invariant μ
hη : η.Invariant μ
hα : Nonempty α
⊢ (κ ∘ₖ η).Invariant μ
tactic: cases' isEmpty_or_nonempty α with _ hα