ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.IsNormal.sup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{max u v} → Ordinal.{max u w}
H : IsNormal f
ι : Type u
g : ι → Ordinal.{max u v}
inst✝ : Nonempty ι
a : Ordinal.{max u w}
⊢ f (Ordinal.sup g) ≤ a ↔ Ordinal.sup (f ∘ g) ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{max u v} → Ordinal.{max u w}
H : IsNormal f
ι : Type u
g : ι → Ordinal.{max u v}
inst✝ : Nonempty ι
a : Ordinal.{max u w}
⊢ f (Ordinal.sup g) ≤ a ↔ ∀ (i : ι), (f ∘ g) i ≤ a
tactic: rw [sup_le_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{max u v} → Ordinal.{max u w}
H : IsNormal f
ι : Type u
g : ι → Ordinal.{max u v}
inst✝ : Nonempty ι
a : Ordinal.{max u w}
⊢ f (Ordinal.sup g) ≤ a ↔ ∀ (i : ι), (f ∘ g) i ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{max u v} → Ordinal.{max u w}
H : IsNormal f
ι : Type u
g : ι → Ordinal.{max u v}
inst✝ : Nonempty ι
a : Ordinal.{max u w}
⊢ f (Ordinal.sup g) ≤ a ↔ ∀ (i : ι), f (g i) ≤ a
tactic: simp only [comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{max u v} → Ordinal.{max u w}
H : IsNormal f
ι : Type u
g : ι → Ordinal.{max u v}
inst✝ : Nonempty ι
a : Ordinal.{max u w}
⊢ f (Ordinal.sup g) ≤ a ↔ ∀ (i : ι), f (g i) ≤ a
state_after: no goals
tactic: rw [H.le_set' Set.univ Set.univ_nonempty g] <;>
      simp [sup_le_iff]
Theorem: FreeAlgebra.star_algebraMap
File: Mathlib/Algebra/Star/Free.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
X : Type u_2
r : R
⊢ star ((algebraMap R (FreeAlgebra R X)) r) = (algebraMap R (FreeAlgebra R X)) r
state_after: no goals
tactic: simp [star, Star.star]
Theorem: Finset.card_image₂_singleton_right
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
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hf : Injective fun a => f a b
⊢ (image₂ f s {b}).card = s.card
state_after: no goals
tactic: rw [image₂_singleton_right, card_image_of_injective _ hf]
Theorem: CategoryTheory.LocalizerMorphism.id_homMap
File: Mathlib/CategoryTheory/Localization/HomEquiv.lean

Proof steps:
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{?u.24683, u_1} C
inst✝⁸ : Category.{u_9, u_2} C₁
inst✝⁷ : Category.{?u.24691, u_3} C₂
inst✝⁶ : Category.{?u.24695, u_4} C₃
inst✝⁵ : Category.{u_8, u_5} D₁
inst✝⁴ : Category.{?u.24703, u_6} D₂
inst✝³ : Category.{?u.24707, u_7} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
Ψ : LocalizerMorphism W₂ W₃
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
L₃ : C₃ ⥤ D₃
inst✝ : L₃.IsLocalization W₃
X Y Z : C₁
f : L₁.obj X ⟶ L₁.obj Y
⊢ (id W₁).homMap L₁ L₁ f = f
state_after: no goals
tactic: simpa using (id W₁).homMap_apply L₁ L₁ (𝟭 D₁) (Iso.refl _) f
Theorem: CategoryTheory.regularTopology.isLocallySurjective_iff
File: Mathlib/CategoryTheory/Sites/Coherent/LocallySurjective.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
inst✝¹ : ConcreteCategory D
inst✝ : Preregular C
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
⊢ Presheaf.IsLocallySurjective (regularTopology C) f ↔
    ∀ (X : C) (y : (forget D).obj (G.obj (op X))),
      ∃ X' φ, ∃ (_ : EffectiveEpi φ), ∃ x, (f.app (op X')) x = (G.map (op φ)) y
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
inst✝¹ : ConcreteCategory D
inst✝ : Preregular C
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
⊢ Presheaf.IsLocallySurjective (regularTopology C) f →
    ∀ (X : C) (y : (forget D).obj (G.obj (op X))),
      ∃ X' φ, ∃ (_ : EffectiveEpi φ), ∃ x, (f.app (op X')) x = (G.map (op φ)) y

case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{u_4, u_2} D
inst✝¹ : ConcreteCategory D
inst✝ : Preregular C
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
⊢ (∀ (X : C) (y : (forget D).obj (G.obj (op X))),
      ∃ X' φ, ∃ (_ : EffectiveEpi φ), ∃ x, (f.app (op X')) x = (G.map (op φ)) y) →
    Presheaf.IsLocallySurjective (regularTopology C) f
tactic: constructor
Theorem: starConvex_compl_Iic
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
⊢ StarConvex 𝕜 y (Iic x)ᶜ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
hz : z ∈ (Iic x)ᶜ
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • y + b • z ∈ (Iic x)ᶜ
tactic: refine (starConvex_iff_forall_pos <| by simp [h.not_le]).mpr fun z hz a b ha hb hab ↦ ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
hz : z ∈ (Iic x)ᶜ
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • y + b • z ∈ (Iic x)ᶜ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
hz : ¬z ≤ x
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ ¬a • y + b • z ≤ x
tactic: rw [mem_compl_iff, mem_Iic] at hz ⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
hz : ¬z ≤ x
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ ¬a • y + b • z ≤ x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • y + b • z ≤ x
⊢ z ≤ x
tactic: contrapose! hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • y + b • z ≤ x
⊢ z ≤ x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • y + b • z ≤ x
⊢ b • z < b • x
tactic: refine (lt_of_smul_lt_smul_of_nonneg_left ?_ hb.le).le
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : OrderedRing 𝕜
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
z : E
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hz : a • y + b • z ≤ x
⊢ b • z < b • x
state_after: no goals
tactic: calc
    b • z ≤ (a + b) • x - a • y := by rwa [le_sub_iff_add_le', hab, one_smul]
    _ < b • x := by
      rw [add_smul, sub_lt_iff_lt_add']
      gcongr
Theorem: units_smul_eq_neg_iff
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
u : Rˣ
v : Module.Ray R M
⊢ u • v = -v ↔ ↑u < 0
state_after: no goals
tactic: rw [← neg_inj, neg_neg, ← Module.Ray.neg_units_smul, units_smul_eq_self_iff, Units.val_neg,
    neg_pos]
Theorem: CategoryTheory.CartesianClosed.uncurry_id_eq_ev
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
A✝ B X✝ X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A✝
A X : C
inst✝ : Exponentiable A
⊢ uncurry (𝟙 (A ⟹ X)) = (exp.ev A).app X
state_after: no goals
tactic: rw [uncurry_eq, prod.map_id_id, id_comp]
Theorem: CompositionSeries.Equivalent.snoc
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (last s₁) x₁
hsat₂ : IsMaximal (last s₂) x₂
hequiv : s₁.Equivalent s₂
hlast : Iso (last s₁, x₁) (last s₂, x₂)
e : Fin s₁.length.succ ≃ Fin s₂.length.succ :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ Iso ((snoc s₁ x₁ hsat₁).toFun i.castSucc, (snoc s₁ x₁ hsat₁).toFun i.succ)
    ((snoc s₂ x₂ hsat₂).toFun (e i).castSucc, (snoc s₂ x₂ hsat₂).toFun (e i).succ)
state_after: case refine_1
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (last s₁) x₁
hsat₂ : IsMaximal (last s₂) x₂
hequiv : s₁.Equivalent s₂
hlast : Iso (last s₁, x₁) (last s₂, x₂)
e : Fin s₁.length.succ ≃ Fin s₂.length.succ :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ Iso
    ((snoc s₁ x₁ hsat₁).toFun (Fin.last (s₁.length + (RelSeries.singleton IsMaximal x₁).length)).castSucc,
      (snoc s₁ x₁ hsat₁).toFun (Fin.last (s₁.length + (RelSeries.singleton IsMaximal x₁).length)).succ)
    ((snoc s₂ x₂ hsat₂).toFun (e (Fin.last (s₁.length + (RelSeries.singleton IsMaximal x₁).length))).castSucc,
      (snoc s₂ x₂ hsat₂).toFun (e (Fin.last (s₁.length + (RelSeries.singleton IsMaximal x₁).length))).succ)

case refine_2
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
x₁ x₂ : X
hsat₁ : IsMaximal (last s₁) x₁
hsat₂ : IsMaximal (last s₂) x₂
hequiv : s₁.Equivalent s₂
hlast : Iso (last s₁, x₁) (last s₂, x₂)
e : Fin s₁.length.succ ≃ Fin s₂.length.succ :=
  Trans.trans (Trans.trans finSuccEquivLast (Functor.mapEquiv Option (Exists.choose hequiv))) finSuccEquivLast.symm
i : Fin (snoc s₁ x₁ hsat₁).length
⊢ ∀ (i : Fin (s₁.length + (RelSeries.singleton IsMaximal x₁).length)),
    Iso ((snoc s₁ x₁ hsat₁).toFun i.castSucc.castSucc, (snoc s₁ x₁ hsat₁).toFun i.castSucc.succ)
      ((snoc s₂ x₂ hsat₂).toFun (e i.castSucc).castSucc, (snoc s₂ x₂ hsat₂).toFun (e i.castSucc).succ)
tactic: refine Fin.lastCases ?_ ?_ i
Theorem: MeasureTheory.setIntegral_nonpos_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f : X → ℝ
s : Set X
hs : MeasurableSet s
hf : ∀ᵐ (x : X) ∂μ, x ∈ s → f x ≤ 0
⊢ f ≤ᶠ[ae (μ.restrict s)] 0
state_after: no goals
tactic: rwa [EventuallyLE, ae_restrict_iff' hs]
Theorem: multiplicity.finite_nat_iff
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
⊢ Finite a b ↔ a ≠ 1 ∧ 0 < b
state_after: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
⊢ (∀ (n : ℕ), a ^ n ∣ b) ↔ a = 1 ∨ b = 0
tactic: rw [← not_iff_not, not_finite_iff_forall, not_and_or, Ne, Classical.not_not, not_lt,
    Nat.le_zero]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : ℕ
⊢ (∀ (n : ℕ), a ^ n ∣ b) ↔ a = 1 ∨ b = 0
state_after: no goals
tactic: exact
    ⟨fun h =>
      or_iff_not_imp_right.2 fun hb =>
        have ha : a ≠ 0 := fun ha => hb <| zero_dvd_iff.mp <| by rw [ha] at h; exact h 1
        Classical.by_contradiction fun ha1 : a ≠ 1 =>
          have ha_gt_one : 1 < a :=
            lt_of_not_ge fun _ =>
              match a with
              | 0 => ha rfl
              | 1 => ha1 rfl
              | b+2 => by omega
          not_lt_of_ge (le_of_dvd (Nat.pos_of_ne_zero hb) (h b)) (lt_pow_self ha_gt_one b),
      fun h => by cases h <;> simp [*]⟩
Theorem: MvPowerSeries.invOfUnit_eq'
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ φ.invOfUnit u = φ⁻¹
state_after: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ φ.invOfUnit u = φ.invOfUnit (Units.mk0 ((constantCoeff σ k) φ) ⋯)
tactic: rw [← invOfUnit_eq φ (h.symm ▸ u.ne_zero)]
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ φ.invOfUnit u = φ.invOfUnit (Units.mk0 ((constantCoeff σ k) φ) ⋯)
state_after: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ u = Units.mk0 ((constantCoeff σ k) φ) ⋯
tactic: apply congrArg (invOfUnit φ)
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ u = Units.mk0 ((constantCoeff σ k) φ) ⋯
state_after: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ ↑u = ↑(Units.mk0 ((constantCoeff σ k) φ) ⋯)
tactic: rw [Units.ext_iff]
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ : MvPowerSeries σ k
u : kˣ
h : (constantCoeff σ k) φ = ↑u
⊢ ↑u = ↑(Units.mk0 ((constantCoeff σ k) φ) ⋯)
state_after: no goals
tactic: exact h.symm
Theorem: Combinatorics.Subspace.apply_inr
File: Mathlib/Combinatorics/HalesJewett.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
l : Subspace η α ι
x : η → α
i : ι
a : α
e : η
h : l.idxFun i = Sum.inr e
⊢ ↑l x i = x e
state_after: no goals
tactic: simp [apply_def, h]
Theorem: WeierstrassCurve.Jacobian.negDblY_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3
⊢ W.negDblY P / W.dblZ P ^ 3 =
    W.toAffine.negAddY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
      (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3))
state_after: no goals
tactic: rw [negDblY, dblX, toAffine_slope_of_eq hP hQ hPz hQz hx hy, dblZ, ← (X_eq_iff hPz hQz).mp hx,
    toAffine_negAddY_of_eq hPz <| sub_ne_zero_of_ne <| Y_ne_negY_of_Y_ne' hP hQ hx hy]
Theorem: sSup_compact_le_eq
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b✝ : α
s : Set α
b : α
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b} = b
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s✝ s : Set α
hs : ∀ x ∈ s, CompleteLattice.IsCompactElement x
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ sSup s} = sSup s
tactic: rcases IsCompactlyGenerated.exists_sSup_eq b with ⟨s, hs, rfl⟩
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s✝ s : Set α
hs : ∀ x ∈ s, CompleteLattice.IsCompactElement x
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ sSup s} = sSup s
state_after: no goals
tactic: exact le_antisymm (sSup_le fun c hc => hc.2) (sSup_le_sSup fun c cs => ⟨hs c cs, le_sSup cs⟩)
Theorem: lineMap_mono_right
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b ≤ b'
hr : 0 ≤ r
⊢ (lineMap a b) r ≤ (lineMap a b') r
state_after: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b ≤ b'
hr : 0 ≤ r
⊢ (1 - r) • a + r • b ≤ (1 - r) • a + r • b'
tactic: simp only [lineMap_apply_module]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b ≤ b'
hr : 0 ≤ r
⊢ (1 - r) • a + r • b ≤ (1 - r) • a + r • b'
state_after: no goals
tactic: exact add_le_add_left (smul_le_smul_of_nonneg_left hb hr) _
Theorem: Metric.infEdist_eq_top_iff
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infEdist x s = ⊤ ↔ s = ∅
state_after: no goals
tactic: rcases s.eq_empty_or_nonempty with rfl | hs <;> simp [*, Nonempty.ne_empty, infEdist_ne_top]
Theorem: Polynomial.cyclotomic_mul_prime_dvd_eq_pow
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean

Proof steps:
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
state_after: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
tactic: letI : Algebra (ZMod p) R := ZMod.algebra _ _
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) R = cyclotomic n R ^ p
state_after: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p
tactic: suffices cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p by
    rw [← map_cyclotomic _ (algebraMap (ZMod p) R), ← map_cyclotomic _ (algebraMap (ZMod p) R),
      this, Polynomial.map_pow]
state_before: R : Type u_1
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝¹ : Ring R
inst✝ : CharP R p
hn : p ∣ n
this : Algebra (ZMod p) R := ZMod.algebra R p
⊢ cyclotomic (n * p) (ZMod p) = cyclotomic n (ZMod p) ^ p
state_after: no goals
tactic: rw [← ZMod.expand_card, ← map_cyclotomic_int n, ← map_expand,
    cyclotomic_expand_eq_cyclotomic hp.out hn, map_cyclotomic]
Theorem: Tactic.ReduceModChar.CharP.intCast_eq_mod
File: Mathlib/Tactic/ReduceModChar.lean

Proof steps:
state_before: u : Level
R : Type u_1
inst✝¹ : Ring R
p : ℕ
inst✝ : CharP R p
k : ℤ
⊢ ↑k = ↑(k % ↑p)
state_after: no goals
tactic: calc
    (k : R) = ↑(k % p + p * (k / p)) := by rw [Int.emod_add_ediv]
    _ = ↑(k % p) := by simp [CharP.cast_eq_zero R]
Theorem: String.join_eq.go
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: ss : List String
x✝ : List Char
⊢ List.foldl (fun x x_1 => x ++ x_1) { data := x✝ } [] = { data := x✝ ++ (List.map data []).join }
state_after: no goals
tactic: simp
state_before: ss✝ : List String
s : List Char
ss : List String
x✝ : List Char
⊢ { data := x✝ ++ s ++ (List.map data ss).join } = { data := x✝ ++ (List.map data ({ data := s } :: ss)).join }
state_after: no goals
tactic: simp
Theorem: IsPrimitiveRoot.zeta_sub_one_prime
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
⊢ Prime (hζ.toInteger - 1)
state_after: case pos
p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p = 2
⊢ Prime (hζ.toInteger - 1)

case neg
p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : ¬p = 2
⊢ Prime (hζ.toInteger - 1)
tactic: by_cases htwo : p = 2
Theorem: AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations_comp
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
k : N ≃* P
j : P ≃* Q
⊢ (f.ofMulEquivOfLocalizations (k.trans j)).toMap = j.toMonoidHom.comp (f.ofMulEquivOfLocalizations k).toMap
state_after: case h
M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
k : N ≃* P
j : P ≃* Q
x✝ : M
⊢ (f.ofMulEquivOfLocalizations (k.trans j)).toMap x✝ = (j.toMonoidHom.comp (f.ofMulEquivOfLocalizations k).toMap) x✝
tactic: ext
state_before: case h
M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
k : N ≃* P
j : P ≃* Q
x✝ : M
⊢ (f.ofMulEquivOfLocalizations (k.trans j)).toMap x✝ = (j.toMonoidHom.comp (f.ofMulEquivOfLocalizations k).toMap) x✝
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.AEEqFun.compQuasiMeasurePreserving_toGerm
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
f : α → β
ν : Measure β
g : β →ₘ[ν] γ
hf : Measure.QuasiMeasurePreserving f μ ν
⊢ (g.compQuasiMeasurePreserving f hf).toGerm = g.toGerm.compTendsto f ⋯
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
f : α → β
ν : Measure β
g : β →ₘ[ν] γ
hf : Measure.QuasiMeasurePreserving f μ ν
a✝ : { f // AEStronglyMeasurable f ν }
⊢ (compQuasiMeasurePreserving (Quot.mk Setoid.r a✝) f hf).toGerm = (toGerm (Quot.mk Setoid.r a✝)).compTendsto f ⋯
tactic: rcases g
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
f : α → β
ν : Measure β
g : β →ₘ[ν] γ
hf : Measure.QuasiMeasurePreserving f μ ν
a✝ : { f // AEStronglyMeasurable f ν }
⊢ (compQuasiMeasurePreserving (Quot.mk Setoid.r a✝) f hf).toGerm = (toGerm (Quot.mk Setoid.r a✝)).compTendsto f ⋯
state_after: no goals
tactic: rfl
Theorem: Monoid.exp_eq_one_iff
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
⊢ exponent G = 1 ↔ Subsingleton G
state_after: case a_eq_b
G : Type u
inst✝ : Monoid G
eq_one : exponent G = 1
a b : G
⊢ a = b

case le
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ exponent G ≤ 1

case ge
G : Type u
inst✝ : Monoid G
h : Subsingleton G
⊢ 1 ≤ exponent G
tactic: refine ⟨fun eq_one => ⟨fun a b => ?a_eq_b⟩, fun h => le_antisymm ?le ?ge⟩
Theorem: div_mul_cancel_right
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✝ : Group G
a✝ b✝ c d : G
n : ℤ
a b : G
⊢ a / (b * a) = b⁻¹
state_after: no goals
tactic: rw [← inv_div, mul_div_cancel_right]