ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finsupp.coe_update
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑(f.update a b) = Function.update (⇑f) a b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑{ support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ } =
    fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1
tactic: delta update Function.update
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ ⇑{ support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ } =
    fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ { support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ }
      x✝ =
    if h : x✝ = a then ⋯ ▸ b else f x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ { support := if b = 0 then f.support.erase a else insert a f.support,
        toFun := fun a_1 => if h : a_1 = a then ⋯ ▸ b else f a_1, mem_support_toFun := ⋯ }
      x✝ =
    if h : x✝ = a then ⋯ ▸ b else f x✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ (if h : x✝ = a then ⋯ ▸ b else f x✝) = if h : x✝ = a then ⋯ ▸ b else f x✝
tactic: dsimp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
x✝ : α
⊢ (if h : x✝ = a then ⋯ ▸ b else f x✝) = if h : x✝ = a then ⋯ ▸ b else f x✝
state_after: no goals
tactic: split_ifs <;> simp
Theorem: CategoryTheory.Over.CreatesConnected.raised_cone_lowers_to_original
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Connected.lean

Proof steps:
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
⊢ (forget B).mapCone (raiseCone c) = c
state_after: no goals
tactic: aesop_cat
Theorem: SetTheory.PGame.isOption_neg_neg
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ (-x).IsOption (-y) ↔ x.IsOption y
state_after: no goals
tactic: rw [isOption_neg, neg_neg]
Theorem: TopologicalSpace.IsTopologicalBasis.sum
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
t✝ : TopologicalSpace α
β : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set (Set α)
hs : IsTopologicalBasis s
t : Set (Set β)
ht : IsTopologicalBasis t
⊢ IsTopologicalBasis ((fun u => Sum.inl '' u) '' s ∪ (fun u => Sum.inr '' u) '' t)
state_after: case h_open
α : Type u
t✝ : TopologicalSpace α
β : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set (Set α)
hs : IsTopologicalBasis s
t : Set (Set β)
ht : IsTopologicalBasis t
⊢ ∀ u ∈ (fun u => Sum.inl '' u) '' s ∪ (fun u => Sum.inr '' u) '' t, IsOpen u

case h_nhds
α : Type u
t✝ : TopologicalSpace α
β : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s : Set (Set α)
hs : IsTopologicalBasis s
t : Set (Set β)
ht : IsTopologicalBasis t
⊢ ∀ (a : α ⊕ β) (u : Set (α ⊕ β)),
    a ∈ u → IsOpen u → ∃ v ∈ (fun u => Sum.inl '' u) '' s ∪ (fun u => Sum.inr '' u) '' t, a ∈ v ∧ v ⊆ u
tactic: apply isTopologicalBasis_of_isOpen_of_nhds
Theorem: CochainComplex.HomComplex.Cochain.ext₀
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z₁ z₂ : Cochain F G 0
h : ∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯
⊢ z₁ = z₂
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z₁ z₂ : Cochain F G 0
h : ∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯
p q : ℤ
hpq : p + 0 = q
⊢ z₁.v p q hpq = z₂.v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z₁ z₂ : Cochain F G 0
h : ∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯
p q : ℤ
hpq : p + 0 = q
⊢ z₁.v p q hpq = z₂.v p q hpq
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z₁ z₂ : Cochain F G 0
h : ∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯
q : ℤ
hpq : q + 0 = q
⊢ z₁.v q q hpq = z₂.v q q hpq
tactic: obtain rfl : q = p := by rw [← hpq, add_zero]
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
z₁ z₂ : Cochain F G 0
h : ∀ (p : ℤ), z₁.v p p ⋯ = z₂.v p p ⋯
q : ℤ
hpq : q + 0 = q
⊢ z₁.v q q hpq = z₂.v q q hpq
state_after: no goals
tactic: exact h q
Theorem: Real.arctan_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: ⊢ arctan 0 = 0
state_after: no goals
tactic: simp [arctan_eq_arcsin]
Theorem: IsCyclotomicExtension.Rat.nrRealPlaces_eq_zero
File: Mathlib/NumberTheory/Cyclotomic/Embeddings.lean

Proof steps:
state_before: n : ℕ+
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
inst✝ : IsCyclotomicExtension {n} ℚ K
hn : 2 < n
⊢ NrRealPlaces K = 0
state_after: n : ℕ+
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
inst✝ : IsCyclotomicExtension {n} ℚ K
hn : 2 < n
this : NumberField K
⊢ NrRealPlaces K = 0
tactic: have := IsCyclotomicExtension.numberField {n} ℚ K
state_before: n : ℕ+
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
inst✝ : IsCyclotomicExtension {n} ℚ K
hn : 2 < n
this : NumberField K
⊢ NrRealPlaces K = 0
state_after: no goals
tactic: apply (IsCyclotomicExtension.zeta_spec n ℚ K).nrRealPlaces_eq_zero_of_two_lt hn
Theorem: PowerSeries.derivative_invOf
File: Mathlib/RingTheory/PowerSeries/Derivative.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
f : R⟦X⟧
inst✝ : Invertible f
⊢ (d⁄dX R) ⅟f = -⅟f ^ 2 * (d⁄dX R) f
state_after: no goals
tactic: rw [Derivation.leibniz_invOf, smul_eq_mul]
Theorem: Set.singleton_op
File: Mathlib/Data/Set/Opposite.lean

Proof steps:
state_before: α : Type u_1
x : α
⊢ {x}.op = {op x}
state_after: case h
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {x}.op ↔ x✝ ∈ {op x}
tactic: ext
state_before: case h
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {x}.op ↔ x✝ ∈ {op x}
state_after: case h.mp
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {x}.op → x✝ ∈ {op x}

case h.mpr
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {op x} → x✝ ∈ {x}.op
tactic: constructor
Theorem: Real.nnabs_of_nonneg
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: x : ℝ
h : 0 ≤ x
⊢ nnabs x = x.toNNReal
state_after: case a
x : ℝ
h : 0 ≤ x
⊢ ↑(nnabs x) = ↑x.toNNReal
tactic: ext
state_before: case a
x : ℝ
h : 0 ≤ x
⊢ ↑(nnabs x) = ↑x.toNNReal
state_after: no goals
tactic: rw [coe_toNNReal x h, coe_nnabs, abs_of_nonneg h]
Theorem: Polynomial.aeval_algebraMap_apply
File: Mathlib/RingTheory/Polynomial/Tower.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Semiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : A
p : R[X]
⊢ (aeval ((algebraMap A B) x)) p = (algebraMap A B) ((aeval x) p)
state_after: no goals
tactic: rw [aeval_def, aeval_def, hom_eval₂, ← IsScalarTower.algebraMap_eq]
Theorem: AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_hom
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X Y Z : LocallyRingedSpace
f✝ : X ⟶ Y
g✝ : Y ⟶ Z
f g : X ⟶ Y
hfg : f = g
x : ↑X.toTopCat
⊢ Hom.stalkMap f x = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap g x
state_after: X✝ X Y Z : LocallyRingedSpace
f✝ : X ⟶ Y
g : Y ⟶ Z
f : X ⟶ Y
x : ↑X.toTopCat
⊢ Hom.stalkMap f x = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x
tactic: subst hfg
state_before: X✝ X Y Z : LocallyRingedSpace
f✝ : X ⟶ Y
g : Y ⟶ Z
f : X ⟶ Y
x : ↑X.toTopCat
⊢ Hom.stalkMap f x = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x
state_after: no goals
tactic: simp
Theorem: Real.tendsto_harmonic_sub_log
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: ⊢ Tendsto (fun n => ↑(harmonic n) - log ↑n) atTop (𝓝 eulerMascheroniConstant)
state_after: ⊢ eulerMascheroniSeq' =ᶠ[atTop] fun n => ↑(harmonic n) - log ↑n
tactic: apply tendsto_eulerMascheroniSeq'.congr'
state_before: ⊢ eulerMascheroniSeq' =ᶠ[atTop] fun n => ↑(harmonic n) - log ↑n
state_after: case h
n : ℕ
hn : n ≠ 0
⊢ eulerMascheroniSeq' n = ↑(harmonic n) - log ↑n
tactic: filter_upwards [eventually_ne_atTop 0] with n hn
state_before: case h
n : ℕ
hn : n ≠ 0
⊢ eulerMascheroniSeq' n = ↑(harmonic n) - log ↑n
state_after: no goals
tactic: simp_rw [eulerMascheroniSeq', hn, if_false]
Theorem: MeasureTheory.lintegral_withDensity_eq_lintegral_mul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
h_mf : Measurable f
⊢ ∀ {g : α → ℝ≥0∞}, Measurable g → ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ
state_after: case h_ind
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
h_mf : Measurable f
⊢ ∀ (c : ℝ≥0∞) ⦃s : Set α⦄,
    MeasurableSet s →
      ∫⁻ (a : α), s.indicator (fun x => c) a ∂μ.withDensity f = ∫⁻ (a : α), (f * s.indicator fun x => c) a ∂μ

case h_add
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
h_mf : Measurable f
⊢ ∀ ⦃f_1 g : α → ℝ≥0∞⦄,
    Disjoint (Function.support f_1) (Function.support g) →
      Measurable f_1 →
        Measurable g →
          ∫⁻ (a : α), f_1 a ∂μ.withDensity f = ∫⁻ (a : α), (f * f_1) a ∂μ →
            ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ →
              ∫⁻ (a : α), (f_1 + g) a ∂μ.withDensity f = ∫⁻ (a : α), (f * (f_1 + g)) a ∂μ

case h_iSup
α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
h_mf : Measurable f
⊢ ∀ ⦃f_1 : ℕ → α → ℝ≥0∞⦄,
    (∀ (n : ℕ), Measurable (f_1 n)) →
      Monotone f_1 →
        (∀ (n : ℕ), ∫⁻ (a : α), f_1 n a ∂μ.withDensity f = ∫⁻ (a : α), (f * f_1 n) a ∂μ) →
          ∫⁻ (a : α), (fun x => ⨆ n, f_1 n x) a ∂μ.withDensity f = ∫⁻ (a : α), (f * fun x => ⨆ n, f_1 n x) a ∂μ
tactic: apply Measurable.ennreal_induction
Theorem: Ordinal.add_le_right_iff_mul_omega_le
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a * ω ≤ b
state_after: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a + b = b
tactic: rw [← add_eq_right_iff_mul_omega_le]
state_before: a b : Ordinal.{u_1}
⊢ a + b ≤ b ↔ a + b = b
state_after: no goals
tactic: exact (add_isNormal a).le_iff_eq
Theorem: Cubic.natDegree_of_b_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b ≠ 0
⊢ P.toPoly.natDegree = 2
state_after: no goals
tactic: rw [of_a_eq_zero ha, natDegree_quadratic hb]
Theorem: isEmpty_psigma
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
α : Sort u_5
E : α → Sort u_4
⊢ IsEmpty (PSigma E) ↔ ∀ (a : α), IsEmpty (E a)
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_psigma, not_exists]
Theorem: ModularGroup.T_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

Proof steps:
state_before: g : SL(2, ℤ)
⊢ ↑(T * g) 1 = ↑g 1
state_after: no goals
tactic: simpa using T_pow_mul_apply_one 1 g
Theorem: PartialHomeomorph.eventually_nhdsWithin
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
x : X
p : Y → Prop
s : Set X
hx : x ∈ e.source
⊢ (∀ᶠ (y : Y) in 𝓝[↑e.symm ⁻¹' s] ↑e x, p y) ↔ ∀ᶠ (x : X) in 𝓝[s] x, p (↑e x)
state_after: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
x : X
p : Y → Prop
s : Set X
hx : x ∈ e.source
⊢ (∀ᶠ (y : Y) in 𝓝[↑e.symm ⁻¹' s] ↑e x, p y) ↔ ∀ᶠ (b : Y) in map (↑e) (𝓝[s] x), p b
tactic: refine Iff.trans ?_ eventually_map
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
x : X
p : Y → Prop
s : Set X
hx : x ∈ e.source
⊢ (∀ᶠ (y : Y) in 𝓝[↑e.symm ⁻¹' s] ↑e x, p y) ↔ ∀ᶠ (b : Y) in map (↑e) (𝓝[s] x), p b
state_after: no goals
tactic: rw [e.map_nhdsWithin_eq hx, e.image_source_inter_eq', e.nhdsWithin_target_inter (e.mapsTo hx)]
Theorem: CategoryTheory.ShortComplex.HomologyData.leftRightHomologyComparison'_eq
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
h : S.HomologyData
⊢ leftRightHomologyComparison' h.left h.right = h.iso.hom
state_after: no goals
tactic: simp only [← cancel_epi h.left.π, ← cancel_mono h.right.ι, assoc,
    π_leftRightHomologyComparison'_ι, comm]
Theorem: isAtomistic_dual_iff_isCoatomistic
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsAtomistic αᵒᵈ
b : α
⊢ ∃ s, b = sInf s ∧ ∀ a ∈ s, IsCoatom a
state_after: no goals
tactic: apply h.eq_sSup_atoms
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsCoatomistic α
b : αᵒᵈ
⊢ ∃ s, b = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: no goals
tactic: apply h.eq_sInf_coatoms
Theorem: IsAdjoinRootMonic.basis_repr
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
i : Fin f.natDegree
⊢ (h.basis.repr x) i = (h.modByMonicHom x).coeff ↑i
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
i : Fin f.natDegree
⊢ (Finsupp.comapDomain Fin.val (h.modByMonicHom x).toFinsupp ⋯) i = (h.modByMonicHom x).coeff ↑i
tactic: change (h.modByMonicHom x).toFinsupp.comapDomain _ Fin.val_injective.injOn i = _
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
i : Fin f.natDegree
⊢ (Finsupp.comapDomain Fin.val (h.modByMonicHom x).toFinsupp ⋯) i = (h.modByMonicHom x).coeff ↑i
state_after: no goals
tactic: rw [Finsupp.comapDomain_apply, Polynomial.toFinsupp_apply]
Theorem: eq_of_inv_mul_eq_one
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 : α
h : a⁻¹ * b = 1
⊢ a = b
state_after: no goals
tactic: simpa using eq_inv_of_mul_eq_one_left h
Theorem: Matrix.op_smul_one_eq_diagonal
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonAssocSemiring α
inst✝ : DecidableEq m
a : α
⊢ MulOpposite.op a • 1 = diagonal fun x => a
state_after: no goals
tactic: simp_rw [← diagonal_one, ← diagonal_smul, Pi.smul_def, op_smul_eq_mul, one_mul]
Theorem: AlgebraicTopology.AlternatingCofaceMapComplex.d_eq_unop_d
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.74494, u_2} A
inst✝ : Abelian A
X Y : CosimplicialObject C
n : ℕ
⊢ objD X n = (AlternatingFaceMapComplex.objD ((cosimplicialSimplicialEquiv C).functor.obj (op X)) n).unop
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.74494, u_2} A
inst✝ : Abelian A
X Y : CosimplicialObject C
n : ℕ
⊢ ∑ i : Fin (n + 2), (-1) ^ ↑i • X.δ i =
    ∑ x : Fin (n + 2), (-1) ^ ↑x • (((cosimplicialSimplicialEquiv C).functor.obj (op X)).δ x).unop
tactic: simp only [objD, AlternatingFaceMapComplex.objD, unop_sum, unop_zsmul]
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.74494, u_2} A
inst✝ : Abelian A
X Y : CosimplicialObject C
n : ℕ
⊢ ∑ i : Fin (n + 2), (-1) ^ ↑i • X.δ i =
    ∑ x : Fin (n + 2), (-1) ^ ↑x • (((cosimplicialSimplicialEquiv C).functor.obj (op X)).δ x).unop
state_after: no goals
tactic: rfl
Theorem: Cardinal.denumerable_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β α : Type u
h : #α = ℵ₀
⊢ Nonempty (Denumerable α)
state_after: case intro
α✝ β α : Type u
h : #α = ℵ₀
f : α ≃ ULift.{u, 0} ℕ
⊢ Nonempty (Denumerable α)
tactic: cases' Quotient.exact h with f
state_before: case intro
α✝ β α : Type u
h : #α = ℵ₀
f : α ≃ ULift.{u, 0} ℕ
⊢ Nonempty (Denumerable α)
state_after: no goals
tactic: exact ⟨Denumerable.mk' <| f.trans Equiv.ulift⟩
Theorem: Finset.prod_dvd_of_coprime
File: Mathlib/RingTheory/Coprime/Lemmas.lean

Proof steps:
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
⊢ (↑t).Pairwise (IsCoprime on s) → (∀ i ∈ t, s i ∣ z) → ∏ x ∈ t, s x ∣ z
state_after: no goals
tactic: classical
  exact Finset.induction_on t (fun _ _ ↦ one_dvd z)
    (by
      intro a r har ih Hs Hs1
      rw [Finset.prod_insert har]
      have aux1 : a ∈ (↑(insert a r) : Set I) := Finset.mem_insert_self a r
      refine
        (IsCoprime.prod_right fun i hir ↦
              Hs aux1 (Finset.mem_insert_of_mem hir) <| by
                rintro rfl
                exact har hir).mul_dvd
          (Hs1 a aux1) (ih (Hs.mono ?_) fun i hi ↦ Hs1 i <| Finset.mem_insert_of_mem hi)
      simp only [Finset.coe_insert, Set.subset_insert])
Theorem: MeasureTheory.Measure.QuasiMeasurePreserving.comp
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝¹ : α → β
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
g : β → γ
f : α → β
hg : QuasiMeasurePreserving g μb μc
hf : QuasiMeasurePreserving f μa μb
⊢ map (g ∘ f) μa ≪ μc
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝¹ : α → β
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
g : β → γ
f : α → β
hg : QuasiMeasurePreserving g μb μc
hf : QuasiMeasurePreserving f μa μb
⊢ map g (map f μa) ≪ μc
tactic: rw [← map_map hg.1 hf.1]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝¹ : α → β
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
g : β → γ
f : α → β
hg : QuasiMeasurePreserving g μb μc
hf : QuasiMeasurePreserving f μa μb
⊢ map g (map f μa) ≪ μc
state_after: no goals
tactic: exact (hf.2.map hg.1).trans hg.2
Theorem: WittVector.bind₁_verschiebungPoly_wittPolynomial
File: Mathlib/RingTheory/WittVector/Verschiebung.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (bind₁ verschiebungPoly) (wittPolynomial p ℤ n) = if n = 0 then 0 else ↑p * wittPolynomial p ℤ (n - 1)
state_after: case h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ ∀ (x : ℕ → ℤ),
    (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) =
      (MvPolynomial.eval x) (if n = 0 then 0 else ↑p * wittPolynomial p ℤ (n - 1))
tactic: apply MvPolynomial.funext
state_before: case h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ ∀ (x : ℕ → ℤ),
    (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) =
      (MvPolynomial.eval x) (if n = 0 then 0 else ↑p * wittPolynomial p ℤ (n - 1))
state_after: case h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : ℕ → ℤ
⊢ (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) =
    (MvPolynomial.eval x) (if n = 0 then 0 else ↑p * wittPolynomial p ℤ (n - 1))
tactic: intro x
state_before: case h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : ℕ → ℤ
⊢ (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) =
    (MvPolynomial.eval x) (if n = 0 then 0 else ↑p * wittPolynomial p ℤ (n - 1))
state_after: case pos
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : ℕ → ℤ
hn : n = 0
⊢ (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) = (MvPolynomial.eval x) 0

case neg
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
x : ℕ → ℤ
hn : ¬n = 0
⊢ (MvPolynomial.eval x) ((bind₁ verschiebungPoly) (wittPolynomial p ℤ n)) =
    (MvPolynomial.eval x) (↑p * wittPolynomial p ℤ (n - 1))
tactic: split_ifs with hn
Theorem: CategoryTheory.ShortComplex.abToCycles_apply_coe
File: Mathlib/Algebra/Homology/ShortComplex/Ab.lean

Proof steps:
state_before: S : ShortComplex Ab
⊢ ∀ (a b : ↑S.X₁), (fun x => ⟨S.f x, ⋯⟩) (a + b) = (fun x => ⟨S.f x, ⋯⟩) a + (fun x => ⟨S.f x, ⋯⟩) b
state_after: no goals
tactic: aesop
Theorem: Matrix.nonsing_inv_mul_cancel_right
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B✝ : Matrix n n α
B : Matrix m n α
h : IsUnit A.det
⊢ B * A⁻¹ * A = B
state_after: no goals
tactic: simp [Matrix.mul_assoc, nonsing_inv_mul A h]
Theorem: EReal.div_self
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a : EReal
h₁ : a ≠ ⊥
h₂ : a ≠ ⊤
h₃ : a ≠ 0
⊢ a / a = 1
state_after: a : EReal
h₁ : a ≠ ⊥
h₂ : a ≠ ⊤
h₃ : ↑a.toReal ≠ 0
⊢ ↑a.toReal / ↑a.toReal = 1
tactic: rw [← coe_toReal h₂ h₁] at h₃ ⊢
state_before: a : EReal
h₁ : a ≠ ⊥
h₂ : a ≠ ⊤
h₃ : ↑a.toReal ≠ 0
⊢ ↑a.toReal / ↑a.toReal = 1
state_after: no goals
tactic: rw [← coe_div, _root_.div_self (coe_ne_zero.1 h₃), coe_one]