ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: le_map_add_map_div'
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f x ≤ f y + f (y / x)
state_after: no goals
tactic: simpa only [add_comm, map_div_rev, div_mul_cancel] using map_mul_le_add f (x / y) y
Theorem: CategoryTheory.sheafComposeIso_inv_fac
File: Mathlib/CategoryTheory/Sites/PreservesSheafification.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝⁵ : Category.{u_4, u_1} A
inst✝⁴ : Category.{u_3, u_2} B
F : A ⥤ B
inst✝³ : HasWeakSheafify J A
inst✝² : HasWeakSheafify J B
inst✝¹ : J.HasSheafCompose F
inst✝ : J.PreservesSheafification F
P : Cᵒᵖ ⥤ A
⊢ whiskerRight (toSheafify J P) F ≫ (sheafifyComposeIso J F P).inv = toSheafify J (P ⋙ F)
state_after: no goals
tactic: rw [← sheafComposeIso_hom_fac, assoc, Iso.hom_inv_id, comp_id]
Theorem: Finset.pairwiseDisjoint_smul_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Mul α
inst✝¹ : IsLeftCancelMul α
inst✝ : DecidableEq α
s✝ t✝ : Finset α
a : α
s : Set α
t : Finset α
⊢ (s.PairwiseDisjoint fun x => x • t) ↔ Set.InjOn (fun p => p.1 * p.2) (s ×ˢ ↑t)
state_after: no goals
tactic: simp_rw [← pairwiseDisjoint_coe, coe_smul_finset, Set.pairwiseDisjoint_smul_iff]
Theorem: EuclideanGeometry.left_ne_right_of_oangle_sign_eq_neg_one
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : (∡ p₁ p₂ p₃).sign = -1
⊢ -1 ≠ 0
state_after: no goals
tactic: decide
Theorem: mem_principal_ideals_iff
File: Mathlib/RingTheory/ClassGroup.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
I : (FractionalIdeal R⁰ K)ˣ
⊢ I ∈ (toPrincipalIdeal R K).range ↔ ∃ x, spanSingleton R⁰ x = ↑I
state_after: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
I : (FractionalIdeal R⁰ K)ˣ
⊢ (∃ x, spanSingleton R⁰ ↑x = ↑I) ↔ ∃ x, spanSingleton R⁰ x = ↑I
tactic: simp only [MonoidHom.mem_range, toPrincipalIdeal_eq_iff]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
I : (FractionalIdeal R⁰ K)ˣ
⊢ (∃ x, spanSingleton R⁰ ↑x = ↑I) ↔ ∃ x, spanSingleton R⁰ x = ↑I
state_after: case mp.intro
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
I : (FractionalIdeal R⁰ K)ˣ
x : Kˣ
hx : spanSingleton R⁰ ↑x = ↑I
⊢ ∃ x, spanSingleton R⁰ x = ↑I

case mpr.intro
R : Type u_1
K : Type u_2
L : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : DecidableEq L
inst✝⁵ : Algebra R K
inst✝⁴ : IsFractionRing R K
inst✝³ : Algebra K L
inst✝² : FiniteDimensional K L
inst✝¹ : Algebra R L
inst✝ : IsScalarTower R K L
I : (FractionalIdeal R⁰ K)ˣ
x : K
hx : spanSingleton R⁰ x = ↑I
⊢ ∃ x, spanSingleton R⁰ ↑x = ↑I
tactic: constructor <;> rintro ⟨x, hx⟩
Theorem: edist_vsub_vsub_le
File: Mathlib/Analysis/Normed/Group/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ edist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ edist p₁ p₃ + edist p₂ p₄
state_after: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ ↑(nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄)) ≤ ↑(nndist p₁ p₃) + ↑(nndist p₂ p₄)
tactic: simp only [edist_nndist]
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ ↑(nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄)) ≤ ↑(nndist p₁ p₃) + ↑(nndist p₂ p₄)
state_after: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄
tactic: norm_cast
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁵ : SeminormedAddCommGroup V
inst✝⁴ : PseudoMetricSpace P
inst✝³ : NormedAddTorsor V P
inst✝² : NormedAddCommGroup W
inst✝¹ : MetricSpace Q
inst✝ : NormedAddTorsor W Q
p₁ p₂ p₃ p₄ : P
⊢ nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄
state_after: no goals
tactic: apply dist_vsub_vsub_le
Theorem: Set.iUnion_Ioo_right
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : Preorder α
a✝ b c : α
inst✝ : NoMaxOrder α
a : α
⊢ ⋃ b, Ioo a b = Ioi a
state_after: no goals
tactic: simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
Theorem: CategoryTheory.WithTerminal.mapComp_inv_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
E : Type u_2
inst✝¹ : Category.{?u.59505, u_1} D
inst✝ : Category.{?u.59509, u_2} E
F : C ⥤ D
G : D ⥤ E
⊢ ∀ {X Y : WithTerminal C} (f : X ⟶ Y),
    (map (F ⋙ G)).map f ≫
        ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            Y).hom =
      ((fun X =>
              match X with
              | of x => Iso.refl ((map (F ⋙ G)).obj (of x))
              | star => Iso.refl ((map (F ⋙ G)).obj star))
            X).hom ≫
        (map F ⋙ map G).map f
state_after: no goals
tactic: aesop_cat
Theorem: FractionalIdeal.count_inv
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
I : FractionalIdeal R⁰ K
⊢ count K v I⁻¹ = -count K v I
state_after: no goals
tactic: rw [← zpow_neg_one, count_neg_zpow K v (1 : ℤ) I, zpow_one]
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_inter
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

Proof steps:
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h₁ : m.IsCaratheodory s₁
h₂ : m.IsCaratheodory s₂
⊢ m.IsCaratheodory (s₁ ∩ s₂)
state_after: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h₁ : m.IsCaratheodory s₁
h₂ : m.IsCaratheodory s₂
⊢ m.IsCaratheodory (s₁ᶜ ∪ s₂ᶜ)
tactic: rw [← isCaratheodory_compl_iff, Set.compl_inter]
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
h₁ : m.IsCaratheodory s₁
h₂ : m.IsCaratheodory s₂
⊢ m.IsCaratheodory (s₁ᶜ ∪ s₂ᶜ)
state_after: no goals
tactic: exact isCaratheodory_union _ (isCaratheodory_compl _ h₁) (isCaratheodory_compl _ h₂)
Theorem: CategoryTheory.Limits.Cofork.ext_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s t : Cofork f g
i : s.pt ≅ t.pt
w : autoParam (s.π ≫ i.hom = t.π) _auto✝
⊢ t.π ≫ i.inv = s.π
state_after: no goals
tactic: rw [Iso.comp_inv_eq, w]
Theorem: CategoryTheory.ShortComplex.Splitting.s_r
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80688, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
⊢ s.s ≫ s.r = 0
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80688, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : Epi S.g
⊢ s.s ≫ s.r = 0
tactic: have := s.epi_g
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.80688, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
s : S.Splitting
this : Epi S.g
⊢ s.s ≫ s.r = 0
state_after: no goals
tactic: simp only [← cancel_epi S.g, comp_zero, g_s_assoc, sub_comp, id_comp,
    assoc, f_r, comp_id, sub_self]
Theorem: Language.map_kstar
File: Mathlib/Computability/Language.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
f : α → β
l : Language α
⊢ (map f) l∗ = ((map f) l)∗
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
f : α → β
l : Language α
⊢ (map f) (⨆ i, l ^ i) = ⨆ i, (map f) l ^ i
tactic: rw [kstar_eq_iSup_pow, kstar_eq_iSup_pow]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
f : α → β
l : Language α
⊢ (map f) (⨆ i, l ^ i) = ⨆ i, (map f) l ^ i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
f : α → β
l : Language α
⊢ (map f) (⨆ i, l ^ i) = ⨆ i, (map f) (l ^ i)
tactic: simp_rw [← map_pow]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
f : α → β
l : Language α
⊢ (map f) (⨆ i, l ^ i) = ⨆ i, (map f) (l ^ i)
state_after: no goals
tactic: exact image_iUnion
Theorem: UniqueFactorizationMonoid.factors_eq_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = normalizedFactors x
state_after: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = Multiset.map (⇑normalize) (factors x)
tactic: unfold normalizedFactors
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = Multiset.map (⇑normalize) (factors x)
state_after: case h.e'_3.a.h.e
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
⊢ ⇑normalize = id
tactic: convert (Multiset.map_id (factors x)).symm
state_before: case h.e'_3.a.h.e
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
⊢ ⇑normalize = id
state_after: case h.e'_3.a.h.e.h
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
p : M
⊢ normalize p = id p
tactic: ext p
state_before: case h.e'_3.a.h.e.h
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : NormalizationMonoid α
inst✝³ : UniqueFactorizationMonoid α
M : Type u_2
inst✝² : CancelCommMonoidWithZero M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
p : M
⊢ normalize p = id p
state_after: no goals
tactic: exact normalize_eq p
Theorem: Rep.ρ_self_inv_apply
File: Mathlib/RepresentationTheory/Rep.lean

Proof steps:
state_before: k G✝ : Type u
inst✝² : CommRing k
inst✝¹ : Monoid G✝
G : Type u
inst✝ : Group G
A : Rep k G
g : G
x : CoeSort.coe A
⊢ (A.ρ g * A.ρ g⁻¹) x = x
state_after: no goals
tactic: rw [← map_mul, mul_inv_self, map_one, LinearMap.one_apply]
Theorem: Homeomorph.piCongrLeft_apply
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y✝
inst✝³ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝² : TopologicalSpace X'
inst✝¹ : TopologicalSpace Y'
ι : Type u_6
ι' : Type u_7
Y : ι' → Type u_8
inst✝ : (j : ι') → TopologicalSpace (Y j)
e : ι ≃ ι'
i : ι
⊢ Continuous fun a => (Equiv.piCongrLeft Y e).toFun a (e i)
state_after: no goals
tactic: simpa only [Equiv.toFun_as_coe, Equiv.piCongrLeft_apply_apply] using continuous_apply i
Theorem: Nat.Ico_image_const_sub_eq_Ico
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
hac : a ≤ c
⊢ image (fun x => c - x) (Ico a b) = Ico (c + 1 - b) (c + 1 - a)
state_after: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ x ∈ image (fun x => c - x) (Ico a b) ↔ x ∈ Ico (c + 1 - b) (c + 1 - a)
tactic: ext x
state_before: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ x ∈ image (fun x => c - x) (Ico a b) ↔ x ∈ Ico (c + 1 - b) (c + 1 - a)
state_after: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ (∃ a_1, (a ≤ a_1 ∧ a_1 < b) ∧ c - a_1 = x) ↔ c + 1 - b ≤ x ∧ x < c + 1 - a
tactic: simp_rw [mem_image, mem_Ico]
state_before: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ (∃ a_1, (a ≤ a_1 ∧ a_1 < b) ∧ c - a_1 = x) ↔ c + 1 - b ≤ x ∧ x < c + 1 - a
state_after: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ (∃ a_1, (a ≤ a_1 ∧ a_1 < b) ∧ c - a_1 = x) → c + 1 - b ≤ x ∧ x < c + 1 - a
tactic: refine ⟨?_, fun h ↦ ⟨c - x, by omega⟩⟩
state_before: case a
a b c : ℕ
hac : a ≤ c
x : ℕ
⊢ (∃ a_1, (a ≤ a_1 ∧ a_1 < b) ∧ c - a_1 = x) → c + 1 - b ≤ x ∧ x < c + 1 - a
state_after: case a.intro.intro
a b c : ℕ
hac : a ≤ c
x : ℕ
hx : a ≤ x ∧ x < b
⊢ c + 1 - b ≤ c - x ∧ c - x < c + 1 - a
tactic: rintro ⟨x, hx, rfl⟩
state_before: case a.intro.intro
a b c : ℕ
hac : a ≤ c
x : ℕ
hx : a ≤ x ∧ x < b
⊢ c + 1 - b ≤ c - x ∧ c - x < c + 1 - a
state_after: no goals
tactic: omega
Theorem: Cardinal.mul_eq_max_of_aleph0_le_left
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
⊢ a * b = max a b
state_after: case inl
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : ℵ₀ ≤ b
⊢ a * b = max a b

case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ a * b = max a b
tactic: rcases le_or_lt ℵ₀ b with hb | hb
state_before: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ a * b = max a b
state_after: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ max a b ≤ a * b
tactic: refine (mul_le_max_of_aleph0_le_left h).antisymm ?_
state_before: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
⊢ max a b ≤ a * b
state_after: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ max a b ≤ a * b
tactic: have : b ≤ a := hb.le.trans h
state_before: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ max a b ≤ a * b
state_after: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a ≤ a * b
tactic: rw [max_eq_left this]
state_before: case inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a ≤ a * b
state_after: case h.e'_3
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a = a * 1
tactic: convert mul_le_mul_left' (one_le_iff_ne_zero.mpr h') a
state_before: case h.e'_3
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a
h' : b ≠ 0
hb : b < ℵ₀
this : b ≤ a
⊢ a = a * 1
state_after: no goals
tactic: rw [mul_one]
Theorem: Batteries.RBNode.Ordered.balance2
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (l.balance2 v r)
state_after: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (r.reverse.balance1 v l.reverse).reverse
tactic: rw [← reverse_reverse (balance2 ..), reverse_balance2]
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (r.reverse.balance1 v l.reverse).reverse
state_after: no goals
tactic: exact .reverse <| hr.reverse.balance1
    ((All.reverse.2 vr).imp cmpLT.flip) ((All.reverse.2 lv).imp cmpLT.flip) hl.reverse
Theorem: hasFTaylorSeriesUpTo_zero_iff
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ HasFTaylorSeriesUpTo 0 f p ↔ Continuous f ∧ ∀ (x : E), (p x 0).uncurry0 = f x
state_after: no goals
tactic: simp [hasFTaylorSeriesUpToOn_univ_iff.symm, continuous_iff_continuousOn_univ,
    hasFTaylorSeriesUpToOn_zero_iff]
Theorem: Set.uIcc_subset_uIcc_union_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x✝ x : α
⊢ x ∈ [[a, c]] → x ∈ [[a, b]] ∪ [[b, c]]
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x✝ x : α
⊢ a ≤ x ∧ x ≤ c ∨ c ≤ x ∧ x ≤ a → (a ≤ x ∧ x ≤ b ∨ b ≤ x ∧ x ≤ a) ∨ b ≤ x ∧ x ≤ c ∨ c ≤ x ∧ x ≤ b
tactic: simp only [mem_uIcc, mem_union]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x✝ x : α
⊢ a ≤ x ∧ x ≤ c ∨ c ≤ x ∧ x ≤ a → (a ≤ x ∧ x ≤ b ∨ b ≤ x ∧ x ≤ a) ∨ b ≤ x ∧ x ≤ c ∨ c ≤ x ∧ x ≤ b
state_after: no goals
tactic: rcases le_total x b with h2 | h2 <;> tauto
Theorem: Ideal.IsLocal.mem_jacobson_or_exists_inv
File: Mathlib/RingTheory/JacobsonIdeal.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝ : CommRing R
I : Ideal R
hi : I.IsLocal
x : R
h : I ⊔ span {x} = ⊤
p : R
hpi : p ∈ I
q : R
hq : q ∈ span {x}
hpq : p + q = 1
r : R
hr : q = x * r
⊢ r * x - 1 ∈ I
state_after: R : Type u
S : Type v
inst✝ : CommRing R
I : Ideal R
hi : I.IsLocal
x : R
h : I ⊔ span {x} = ⊤
p : R
hpi : p ∈ I
q : R
hq : q ∈ span {x}
hpq : p + q = 1
r : R
hr : q = x * r
⊢ -p ∈ I
tactic: rw [← hpq, mul_comm, ← hr, ← neg_sub, add_sub_cancel_right]
state_before: R : Type u
S : Type v
inst✝ : CommRing R
I : Ideal R
hi : I.IsLocal
x : R
h : I ⊔ span {x} = ⊤
p : R
hpi : p ∈ I
q : R
hq : q ∈ span {x}
hpq : p + q = 1
r : R
hr : q = x * r
⊢ -p ∈ I
state_after: no goals
tactic: exact I.neg_mem hpi
Theorem: Real.sqrt_mul'
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
hy : 0 ≤ y
⊢ √(x * y) = √x * √y
state_after: no goals
tactic: rw [mul_comm, sqrt_mul hy, mul_comm]
Theorem: inter_preimage_maximals_eq_of_rel_iff_rel_on_of_subset
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x✝ : α
f : α → β
r : α → α → Prop
s : β → β → Prop
y : Set β
x : Set α
hf : ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
hy : y ⊆ f '' x
⊢ x ∩ f ⁻¹' maximals s y = maximals r (x ∩ f ⁻¹' y)
state_after: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x✝ : α
f : α → β
r : α → α → Prop
s : β → β → Prop
y : Set β
x : Set α
hf : ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
hy : y ⊆ f '' x
⊢ ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a' a ↔ s (f a') (f a))
tactic: apply inter_preimage_minimals_eq_of_rel_iff_rel_on_of_subset _ hy
state_before: α : Type u_1
β : Type u_2
r✝ r₁ r₂ : α → α → Prop
s✝ t : Set α
a b x✝ : α
f : α → β
r : α → α → Prop
s : β → β → Prop
y : Set β
x : Set α
hf : ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a a' ↔ s (f a) (f a'))
hy : y ⊆ f '' x
⊢ ∀ ⦃a a' : α⦄, a ∈ x → a' ∈ x → (r a' a ↔ s (f a') (f a))
state_after: no goals
tactic: exact fun _ _ a b ↦ hf b a
Theorem: USize.toNat_lt
File: .lake/packages/batteries/Batteries/Data/UInt.lean

Proof steps:
state_before: x : USize
⊢ x.toNat < 2 ^ System.Platform.numBits
state_after: x : USize
⊢ x.toNat < size
tactic: rw [←USize.size_eq]
state_before: x : USize
⊢ x.toNat < size
state_after: no goals
tactic: exact x.val.isLt
Theorem: induced_topology_pure
File: Mathlib/Topology/StoneCech.lean

Proof steps:
state_before: α : Type u
⊢ induced pure Ultrafilter.topologicalSpace = ⊥
state_after: case h
α : Type u
⊢ ∀ (x : α), IsOpen {x}
tactic: apply eq_bot_of_singletons_open
state_before: case h
α : Type u
⊢ ∀ (x : α), IsOpen {x}
state_after: case h
α : Type u
x : α
⊢ IsOpen {x}
tactic: intro x
state_before: case h
α : Type u
x : α
⊢ IsOpen {x}
state_after: case right
α : Type u
x : α
⊢ pure ⁻¹' {u | {x} ∈ u} = {x}
tactic: use { u : Ultrafilter α | {x} ∈ u }, ultrafilter_isOpen_basic _
state_before: case right
α : Type u
x : α
⊢ pure ⁻¹' {u | {x} ∈ u} = {x}
state_after: no goals
tactic: simp
Theorem: Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto arg (𝓝[{z | 0 ≤ z.im}] z) (𝓝 π)
state_after: no goals
tactic: simpa only [arg_eq_pi_iff.2 ⟨hre, him⟩] using
    (continuousWithinAt_arg_of_re_neg_of_im_zero hre him).tendsto
Theorem: AddCommGrp.Colimits.cocone_naturality_components
File: Mathlib/Algebra/Category/Grp/Colimits.lean

Proof steps:
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ (coconeMorphism F j') ((F.map f) x) = (coconeMorphism F j) x
state_after: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ (coconeMorphism F j') ((F.map f) x) = (F.map f ≫ coconeMorphism F j') x
tactic: rw [← cocone_naturality F f]
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x : ↑(F.obj j)
⊢ (coconeMorphism F j') ((F.map f) x) = (F.map f ≫ coconeMorphism F j') x
state_after: no goals
tactic: rfl
Theorem: Traversable.foldrm.ofFreeMonoid_comp_of
File: Mathlib/Control/Fold.lean

Proof steps:
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m α
⊢ ⇑(foldrM.ofFreeMonoid f) ∘ FreeMonoid.of = foldrM.mk ∘ f
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m α
x✝ : β
⊢ (⇑(foldrM.ofFreeMonoid f) ∘ FreeMonoid.of) x✝ = (foldrM.mk ∘ f) x✝
tactic: ext