ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.Monic.eq_X_pow_char_pow_sub_C_of_natSepDegree_eq_one_of_irreducible
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
h : f.natSepDegree = 1
⊢ ∃ n y, (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = X ^ q ^ n - C y
state_after: case intro.intro
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
h : f.natSepDegree = 1
n : ℕ
y : F
hf : f = X ^ q ^ n - C y
⊢ ∃ n y, (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = X ^ q ^ n - C y
tactic: obtain ⟨n, y, hf⟩ := (hm.natSepDegree_eq_one_iff_of_irreducible q hi).1 h
state_before: case intro.intro
F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
hm : f.Monic
hi : Irreducible f
h : f.natSepDegree = 1
n : ℕ
y : F
hf : f = X ^ q ^ n - C y
⊢ ∃ n y, (n = 0 ∨ y ∉ (frobenius F q).range) ∧ f = X ^ q ^ n - C y
state_after: no goals
tactic: cases id ‹ExpChar F q› with
  | zero =>
    simp_rw [one_pow, pow_one] at hf ⊢
    exact ⟨0, y, .inl rfl, hf⟩
  | prime hq =>
    refine ⟨n, y, (em _).imp id fun hn ⟨z, hy⟩ ↦ ?_, hf⟩
    haveI := expChar_of_injective_ringHom (R := F) C_injective q
    rw [hf, ← Nat.succ_pred hn, pow_succ, pow_mul, ← hy, frobenius_def, map_pow,
      ← sub_pow_expChar] at hi
    exact not_irreducible_pow hq.ne_one hi
Theorem: WeierstrassCurve.ψ₂_sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.ψ₂ ^ 2 = C W.Ψ₂Sq + 4 * W.toAffine.polynomial
state_after: no goals
tactic: rw [C_Ψ₂Sq, sub_add_cancel]
Theorem: Mathlib.Tactic.Ring.add_congr
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' + b' = c
⊢ a + b = c
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a' a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
⊢ a' + b' = a' + b'
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a' a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
⊢ a' + b' = a' + b'
state_after: no goals
tactic: rfl
Theorem: uniformEquicontinuousOn_iff_range
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn Subtype.val S
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn (F ∘ rangeSplitting F) S
tactic: rw [← comp_rangeSplitting F]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn (F ∘ rangeSplitting F) S
state_after: no goals
tactic: exact h.comp _
Theorem: Behrend.exp_four_lt
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ rexp 4 < 64
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 < log 2

α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < ↑6
tactic: rw [show (64 : ℝ) = 2 ^ ((6 : ℕ) : ℝ) by rw [rpow_natCast]; norm_num1,
    ← lt_log_iff_exp_lt (rpow_pos_of_pos zero_lt_two _), log_rpow zero_lt_two, ← div_lt_iff']
Theorem: Function.Embedding.nonempty_of_card_le
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
inst✝ : Fintype β
h : Fintype.card α ≤ Fintype.card β
⊢ Nonempty (α ↪ β)
state_after: no goals
tactic: classical exact (truncOfCardLE h).nonempty
Theorem: MeasureTheory.lintegral_mul_const'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
⊢ ∫⁻ (a : α), f a * r ∂μ = (∫⁻ (a : α), f a ∂μ) * r
state_after: no goals
tactic: simp_rw [mul_comm, lintegral_const_mul' r f hr]
Theorem: Dilation.ratio_unique_of_nndist_ne_zero
File: Mathlib/Topology/MetricSpace/Dilation.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
F✝ : Type u_4
G : Type u_5
inst✝⁶ : PseudoEMetricSpace α✝
inst✝⁵ : PseudoEMetricSpace β✝
inst✝⁴ : FunLike F✝ α✝ β✝
α : Type u_6
β : Type u_7
F : Type u_8
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : FunLike F α β
inst✝ : DilationClass F α β
f : F
x y : α
r : ℝ≥0
hxy : nndist x y ≠ 0
hr : nndist (f x) (f y) = r * nndist x y
⊢ edist x y ≠ 0
state_after: no goals
tactic: rwa [edist_nndist, ENNReal.coe_ne_zero]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
F✝ : Type u_4
G : Type u_5
inst✝⁶ : PseudoEMetricSpace α✝
inst✝⁵ : PseudoEMetricSpace β✝
inst✝⁴ : FunLike F✝ α✝ β✝
α : Type u_6
β : Type u_7
F : Type u_8
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : FunLike F α β
inst✝ : DilationClass F α β
f : F
x y : α
r : ℝ≥0
hxy : nndist x y ≠ 0
hr : nndist (f x) (f y) = r * nndist x y
⊢ edist (f x) (f y) = ↑r * edist x y
state_after: no goals
tactic: rw [edist_nndist, edist_nndist, hr, ENNReal.coe_mul]
Theorem: CategoryTheory.Subobject.mk_le_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X : Subobject B
f : A ⟶ B
inst✝ : Mono f
g : A ⟶ underlying.obj X
w : g ≫ X.arrow = f
⊢ ((underlyingIso f).hom ≫ g) ≫ X.arrow = (mk f).arrow
state_after: no goals
tactic: simp [w]
Theorem: eventually_residual_liouville
File: Mathlib/NumberTheory/Liouville/Residual.lean

Proof steps:
state_before: ⊢ ∀ᶠ (x : ℝ) in residual ℝ, Liouville x
state_after: ⊢ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ∈ residual ℝ
tactic: rw [Filter.Eventually, setOf_liouville_eq_irrational_inter_iInter_iUnion]
state_before: ⊢ {x | Irrational x} ∩ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) ∈ residual ℝ
state_after: ⊢ ∀ᶠ (x : ℝ) in residual ℝ, x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
tactic: refine eventually_residual_irrational.and ?_
state_before: ⊢ ∀ᶠ (x : ℝ) in residual ℝ, x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)
state_after: case refine_1

⊢ IsGδ {x | (fun x => x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)) x}

case refine_2

⊢ range Rat.cast ⊆ {x | (fun x => x ∈ ⋂ n, ⋃ a, ⋃ b, ⋃ (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)) x}
tactic: refine residual_of_dense_Gδ ?_ (Rat.denseEmbedding_coe_real.dense.mono ?_)
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.tensor_comp
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ tensorHom ℬ (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom ℬ f₁ f₂ ≫ tensorHom ℬ g₁ g₂
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
g₁ : Y₁ ⟶ Z₁
g₂ : Y₂ ⟶ Z₂
⊢ ∀ (j : Discrete WalkingPair),
    tensorHom ℬ (f₁ ≫ g₁) (f₂ ≫ g₂) ≫ (ℬ Z₁ Z₂).cone.π.app j =
      (tensorHom ℬ f₁ f₂ ≫ tensorHom ℬ g₁ g₂) ≫ (ℬ Z₁ Z₂).cone.π.app j
tactic: apply IsLimit.hom_ext (ℬ _ _).isLimit
Theorem: Filter.IsBoundedUnder.bddAbove_range_of_cofinite
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
⊢ BddAbove (range f)
tactic: rcases hf with ⟨b, hb⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
⊢ BddAbove (range f)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
this : Nonempty β
⊢ BddAbove (range f)
tactic: haveI : Nonempty β := ⟨b⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
this : Nonempty β
⊢ BddAbove (range f)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
this : Nonempty β
⊢ BddAbove (f '' {x | f x ≤ b}) ∧ BddAbove (f '' {x | f x ≤ b}ᶜ)
tactic: rw [← image_univ, ← union_compl_self { x | f x ≤ b }, image_union, bddAbove_union]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : α → β
b : β
hb : ∀ᶠ (x : β) in map f cofinite, (fun x x_1 => x ≤ x_1) x b
this : Nonempty β
⊢ BddAbove (f '' {x | f x ≤ b}) ∧ BddAbove (f '' {x | f x ≤ b}ᶜ)
state_after: no goals
tactic: exact ⟨⟨b, forall_mem_image.2 fun x => id⟩, (hb.image f).bddAbove⟩
Theorem: TopCat.GlueData.image_inter
File: Mathlib/Topology/Gluing.lean

Proof steps:
state_before: D : GlueData
i j : D.J
⊢ Set.range ⇑(D.ι i) ∩ Set.range ⇑(D.ι j) = Set.range ⇑(D.f i j ≫ D.ι i)
state_after: case h
D : GlueData
i j : D.J
x : ↑D.glued
⊢ x ∈ Set.range ⇑(D.ι i) ∩ Set.range ⇑(D.ι j) ↔ x ∈ Set.range ⇑(D.f i j ≫ D.ι i)
tactic: ext x
state_before: case h
D : GlueData
i j : D.J
x : ↑D.glued
⊢ x ∈ Set.range ⇑(D.ι i) ∩ Set.range ⇑(D.ι j) ↔ x ∈ Set.range ⇑(D.f i j ≫ D.ι i)
state_after: case h.mp
D : GlueData
i j : D.J
x : ↑D.glued
⊢ x ∈ Set.range ⇑(D.ι i) ∩ Set.range ⇑(D.ι j) → x ∈ Set.range ⇑(D.f i j ≫ D.ι i)

case h.mpr
D : GlueData
i j : D.J
x : ↑D.glued
⊢ x ∈ Set.range ⇑(D.f i j ≫ D.ι i) → x ∈ Set.range ⇑(D.ι i) ∩ Set.range ⇑(D.ι j)
tactic: constructor
Theorem: CancelDenoms.sub_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Ring α
n e1 e2 t1 t2 : α
h1 : n * e1 = t1
h2 : n * e2 = t2
⊢ n * (e1 - e2) = t1 - t2
state_after: no goals
tactic: simp [left_distrib, *, sub_eq_add_neg]
Theorem: Complex.abs_exp
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: z : ℂ
⊢ abs (cexp z) = Real.exp z.re
state_after: no goals
tactic: rw [exp_eq_exp_re_mul_sin_add_cos, map_mul, abs_exp_ofReal, abs_cos_add_sin_mul_I, mul_one]
Theorem: Fintype.piFinset_image₂
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
⊢ (piFinset fun i => image₂ (f i) (s i) (t i)) = image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)
state_after: case a
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
a✝ : (a : ι) → γ a
⊢ (a✝ ∈ piFinset fun i => image₂ (f i) (s i) (t i)) ↔
    a✝ ∈ image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)
tactic: ext
state_before: case a
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ✝ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
ι : Type u_14
α : ι → Type u_15
β : ι → Type u_16
γ : ι → Type u_17
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (γ i)
f : (i : ι) → α i → β i → γ i
s : (i : ι) → Finset (α i)
t : (i : ι) → Finset (β i)
a✝ : (a : ι) → γ a
⊢ (a✝ ∈ piFinset fun i => image₂ (f i) (s i) (t i)) ↔
    a✝ ∈ image₂ (fun a b i => f i (a i) (b i)) (piFinset s) (piFinset t)
state_after: no goals
tactic: simp only [mem_piFinset, mem_image₂, Classical.skolem, forall_and, Function.funext_iff]
Theorem: HasSum.hasSum_iff_compl
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (f ∘ Subtype.val) a₁
⊢ HasProd f (a₁ * (a₂ / a₁)) ↔ HasProd f a₂
state_after: no goals
tactic: rw [mul_div_cancel]
Theorem: OrderMonoidWithZeroHom.toMonoidWithZeroHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f✝ g✝ f g : α →*₀o β
h : f.toMonoidWithZeroHom = g.toMonoidWithZeroHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
tactic: convert DFunLike.ext_iff.1 h using 0
Theorem: Multiset.antidiagonal_cons
File: Mathlib/Data/Multiset/Antidiagonal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (a ::ₘ ⟦l⟧).antidiagonal =
    map (Prod.map id (cons a)) (antidiagonal ⟦l⟧) + map (Prod.map (cons a) id) (antidiagonal ⟦l⟧)
state_after: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l ++ List.map (cons a) (powersetAux' l)).zip
      ((List.map (cons a) (powersetAux' l)).reverse ++ (powersetAux' l).reverse) ~
    List.map (fun x => Prod.map id (cons a) x) ((powersetAux' l).zip (powersetAux' l).reverse) ++
      List.map (fun x => Prod.map (cons a) id x) ((powersetAux' l).zip (powersetAux' l).reverse)
tactic: simp only [revzip, reverse_append, quot_mk_to_coe, coe_eq_coe, powersetAux'_cons, cons_coe,
      map_coe, antidiagonal_coe', coe_add]
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l ++ List.map (cons a) (powersetAux' l)).zip
      ((List.map (cons a) (powersetAux' l)).reverse ++ (powersetAux' l).reverse) ~
    List.map (fun x => Prod.map id (cons a) x) ((powersetAux' l).zip (powersetAux' l).reverse) ++
      List.map (fun x => Prod.map (cons a) id x) ((powersetAux' l).zip (powersetAux' l).reverse)
state_after: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).zip (List.map (cons a) (powersetAux' l)).reverse ++
      (List.map (cons a) (powersetAux' l)).zip (powersetAux' l).reverse =
    (List.map id (powersetAux' l)).zip (List.map (cons a) (powersetAux' l).reverse) ++
      (List.map (cons a) (powersetAux' l)).zip (List.map id (powersetAux' l).reverse)

α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).length = (List.map (cons a) (powersetAux' l)).reverse.length
tactic: rw [← zip_map, ← zip_map, zip_append, (_ : _ ++ _ = _)]
Theorem: DFinsupp.single_eq_of_sigma_eq
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i j : ι
xi : β i
xj : β j
h : ⟨i, xi⟩ = ⟨j, xj⟩
⊢ single i xi = single j xj
state_after: case refl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ single i xi = single i xi
tactic: cases h
state_before: case refl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ single i xi = single i xi
state_after: no goals
tactic: rfl
Theorem: orderOf_eq_two_iff
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
hG : Monoid.exponent G = 2
x : G
⊢ orderOf x = 2 → x ≠ 1
state_after: G : Type u
inst✝ : Monoid G
hG : Monoid.exponent G = 2
hx : orderOf 1 = 2
⊢ False
tactic: rintro hx rfl
state_before: G : Type u
inst✝ : Monoid G
hG : Monoid.exponent G = 2
hx : orderOf 1 = 2
⊢ False
state_after: no goals
tactic: norm_num at hx
Theorem: OreLocalization.mul_cancel'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.109587
inst✝ : MulAction R X
r₁ r₂ : R
s t : ↥S
⊢ r₁ * ↑s /ₒ t * (r₂ /ₒ s) = r₁ * r₂ /ₒ t
state_after: no goals
tactic: simp [oreDiv_mul_char (r₁ * s) r₂ t s r₁ 1 (by simp)]
Theorem: ball_sub_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ / {y} = ball (x / y) δ
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, inv_singleton, ball_mul_singleton]
Theorem: AlgebraicGeometry.IsOpenImmersion.map_ΓIso_inv
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U : Y.Opens
⊢ Y.presheaf.map (homOfLE ⋯).op ≫ (ΓIso f U).inv = Scheme.Hom.app f U
state_after: no goals
tactic: simp [Scheme.Hom.appLE_eq_app]
Theorem: CategoryTheory.CostructuredArrow.hom_eq_iff
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' Y'' : C
S S' : C ⥤ D
X Y : CostructuredArrow S T
f g : X ⟶ Y
h : f = g
⊢ f.left = g.left
state_after: no goals
tactic: rw [h]
Theorem: Set.image_const_sub_Ici
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a - x) '' Ici b = Iic (a - b)
state_after: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ici b = Iic (a - b)
tactic: have := image_comp (fun x => a + x) fun x => -x
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), ((fun x => a + x) ∘ fun x => -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ici b = Iic (a - b)
state_after: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ici b = Iic (a - b)
tactic: dsimp [Function.comp_def] at this
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
this : ∀ (a_1 : Set α), (fun x => a + -x) '' a_1 = (fun x => a + x) '' ((fun x => -x) '' a_1)
⊢ (fun x => a - x) '' Ici b = Iic (a - b)
state_after: no goals
tactic: simp [sub_eq_add_neg, this, add_comm]
Theorem: ArithmeticFunction.IsMultiplicative.prodPrimeFactors_one_add_of_squarefree
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
h_mult : f.IsMultiplicative
n : ℕ
hn : Squarefree n
⊢ ∏ p ∈ n.primeFactors, (1 + f p) = ∑ d ∈ n.divisors, f d
state_after: R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
h_mult : f.IsMultiplicative
n : ℕ
hn : Squarefree n
⊢ ∏ p ∈ n.primeFactors, (1 + f p) = (ArithmeticFunction.prodPrimeFactors fun p => (↑ζ + f) p) n

R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
h_mult : f.IsMultiplicative
n : ℕ
hn : Squarefree n
⊢ (ArithmeticFunction.prodPrimeFactors fun p => (↑ζ + f) p) n = ∑ d ∈ n.divisors, f d
tactic: trans (∏ᵖ p ∣ n, ((ζ : ArithmeticFunction R) + f) p)
state_before: R : Type u_1
inst✝ : CommSemiring R
f : ArithmeticFunction R
h_mult : f.IsMultiplicative
n : ℕ
hn : Squarefree n
⊢ (ArithmeticFunction.prodPrimeFactors fun p => (↑ζ + f) p) n = ∑ d ∈ n.divisors, f d
state_after: no goals
tactic: rw [isMultiplicative_zeta.natCast.prodPrimeFactors_add_of_squarefree h_mult hn,
    coe_zeta_mul_apply]