ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.LocallyRingedSpace.toΓSpec_preimage_basicOpen_eq
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
⊢ X.toΓSpecFun ⁻¹' (basicOpen r).carrier = (X.toRingedSpace.basicOpen r).carrier
state_after: case h
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ x✝ ∈ (X.toRingedSpace.basicOpen r).carrier
tactic: ext
state_before: case h
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ x✝ ∈ (X.toRingedSpace.basicOpen r).carrier
state_after: case h
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ IsUnit ((X.toRingedSpace.presheaf.germ ⟨x✝, ⋯⟩) r)
tactic: erw [X.toRingedSpace.mem_top_basicOpen]
state_before: case h
X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
x✝ : ↑X.toTopCat
⊢ x✝ ∈ X.toΓSpecFun ⁻¹' (basicOpen r).carrier ↔ IsUnit ((X.toRingedSpace.presheaf.germ ⟨x✝, ⋯⟩) r)
state_after: no goals
tactic: apply not_mem_prime_iff_unit_in_stalk
Theorem: Finset.filter_const
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q : α → Prop
inst✝² : DecidablePred p✝
inst✝¹ : DecidablePred q
s✝ t : Finset α
p : Prop
inst✝ : Decidable p
s : Finset α
⊢ filter (fun _a => p) s = if p then s else ∅
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: Submonoid.LocalizationMap.mul_mk'_eq_mk'_of_mul
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
x₁ x₂ : M
y : ↥S
⊢ f.toMap x₁ * f.mk' x₂ y = f.mk' (x₁ * x₂) y
state_after: no goals
tactic: rw [← mk'_one, ← mk'_mul, one_mul]
Theorem: Set.Ico_union_Ici
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : c ≤ max a b
⊢ Ico a b ∪ Ici c = Ici (min a c)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
h : c ≤ b
⊢ Ico a b ∪ Ici c = Ici (min a c)

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
h : c ≤ a
⊢ Ico a b ∪ Ici c = Ici (min a c)
tactic: rcases le_total a b with hab | hab <;> simp [hab] at h
Theorem: MulEquiv.coe_monoidHom_comp_coe_monoidHom_symm
File: Mathlib/Algebra/Group/Equiv/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
⊢ (↑e).comp ↑e.symm = MonoidHom.id N
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
x✝ : N
⊢ ((↑e).comp ↑e.symm) x✝ = (MonoidHom.id N) x✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
x✝ : N
⊢ ((↑e).comp ↑e.symm) x✝ = (MonoidHom.id N) x✝
state_after: no goals
tactic: simp
Theorem: CategoryTheory.sheafComposeNatTrans_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_3, u_1} A
inst✝¹ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
inst✝ : J.HasSheafCompose F
P : Cᵒᵖ ⥤ A
⊢ adj₂.unit.app (P ⋙ F) ≫ (sheafToPresheaf J B).map ((sheafComposeNatTrans J F adj₁ adj₂).app P) =
    whiskerRight (adj₁.unit.app P) F
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝² : Category.{u_3, u_1} A
inst✝¹ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
inst✝ : J.HasSheafCompose F
P : Cᵒᵖ ⥤ A
⊢ adj₂.unit.app (P ⋙ F) ≫
      (sheafToPresheaf J B).map
        ((adj₂.homEquiv (((whiskeringRight Cᵒᵖ A B).obj F).obj P) ((G₁ ⋙ sheafCompose J F).obj P)).symm
          (whiskerRight (adj₁.unit.app P) F)) =
    whiskerRight (adj₁.unit.app P) F
tactic: dsimp only [sheafComposeNatTrans]
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝² : Category.{u_3, u_1} A
inst✝¹ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
inst✝ : J.HasSheafCompose F
P : Cᵒᵖ ⥤ A
⊢ adj₂.unit.app (P ⋙ F) ≫
      (sheafToPresheaf J B).map
        ((adj₂.homEquiv (((whiskeringRight Cᵒᵖ A B).obj F).obj P) ((G₁ ⋙ sheafCompose J F).obj P)).symm
          (whiskerRight (adj₁.unit.app P) F)) =
    whiskerRight (adj₁.unit.app P) F
state_after: no goals
tactic: erw [Adjunction.homEquiv_counit, Adjunction.unit_naturality_assoc,
    adj₂.right_triangle_components, comp_id]
Theorem: OrderIso.essSup_apply
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ g (essSup f μ) = essSup (fun x => g (f x)) μ
state_after: case refine_1
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f

case refine_2
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f

case refine_3
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (ae μ) fun x => g (f x)

case refine_4
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) fun x => g (f x)
tactic: refine OrderIso.limsup_apply g ?_ ?_ ?_ ?_
state_before: case refine_1
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f

case refine_2
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f

case refine_3
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) (ae μ) fun x => g (f x)

case refine_4
α : Type u_1
β : Type u_2
m✝ : MeasurableSpace α
μ✝ ν : Measure α
inst✝¹ : CompleteLattice β
m : MeasurableSpace α
γ : Type u_3
inst✝ : CompleteLattice γ
f : α → β
μ : Measure α
g : β ≃o γ
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) fun x => g (f x)
state_after: no goals
tactic: all_goals isBoundedDefault
Theorem: CompactIccSpace.mk''
File: Mathlib/Topology/Algebra/Order/Compact.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PartialOrder α
h : ∀ {a b : α}, a < b → IsCompact (Icc a b)
a✝ b✝ : α
hab : a✝ ≤ b✝
⊢ a✝ = b✝ → IsCompact (Icc a✝ b✝)
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PartialOrder α
h : ∀ {a b : α}, a < b → IsCompact (Icc a b)
a✝ : α
hab : a✝ ≤ a✝
⊢ IsCompact (Icc a✝ a✝)
tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : PartialOrder α
h : ∀ {a b : α}, a < b → IsCompact (Icc a b)
a✝ : α
hab : a✝ ≤ a✝
⊢ IsCompact (Icc a✝ a✝)
state_after: no goals
tactic: simp
Theorem: AddCommGrp.Colimits.cocone_naturality
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'
⊢ F.map f ≫ coconeMorphism F j' = coconeMorphism F j
state_after: case w
J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ (F.map f ≫ coconeMorphism F j') x✝ = (coconeMorphism F j) x✝
tactic: ext
state_before: case w
J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ (F.map f ≫ coconeMorphism F j') x✝ = (coconeMorphism F j) x✝
state_after: case w.a
J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ Setoid.r (Prequotient.of j' ((F.map f) x✝)) (Prequotient.of j x✝)
tactic: apply Quot.sound
state_before: case w.a
J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ Setoid.r (Prequotient.of j' ((F.map f) x✝)) (Prequotient.of j x✝)
state_after: no goals
tactic: apply Relation.map
Theorem: Cardinal.power_mul
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b c : Cardinal.{u_1}
⊢ a ^ (b * c) = (a ^ b) ^ c
state_after: α β : Type u
a b c : Cardinal.{u_1}
⊢ a ^ (c * b) = (a ^ b) ^ c
tactic: rw [mul_comm b c]
state_before: α β : Type u
a b c : Cardinal.{u_1}
⊢ a ^ (c * b) = (a ^ b) ^ c
state_after: no goals
tactic: exact inductionOn₃ a b c fun α β γ => mk_congr <| Equiv.curry γ β α
Theorem: sign_cases_of_C_mul_pow_nonneg
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : LinearOrder α
a b c d : α
inst✝ : PosMulStrictMono α
h : ∀ (n : ℕ), 0 ≤ a * b ^ n
⊢ a = 0 ∨ 0 < a ∧ 0 ≤ b
state_after: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : LinearOrder α
a b c d : α
inst✝ : PosMulStrictMono α
h : ∀ (n : ℕ), 0 ≤ a * b ^ n
this : 0 ≤ a
⊢ a = 0 ∨ 0 < a ∧ 0 ≤ b
tactic: have : 0 ≤ a := by simpa only [pow_zero, mul_one] using h 0
state_before: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : LinearOrder α
a b c d : α
inst✝ : PosMulStrictMono α
h : ∀ (n : ℕ), 0 ≤ a * b ^ n
this : 0 ≤ a
⊢ a = 0 ∨ 0 < a ∧ 0 ≤ b
state_after: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : LinearOrder α
a b c d : α
inst✝ : PosMulStrictMono α
h : ∀ (n : ℕ), 0 ≤ a * b ^ n
this : 0 ≤ a
ha : 0 < a
⊢ 0 ≤ a * b
tactic: refine this.eq_or_gt.imp_right fun ha ↦ ⟨ha, nonneg_of_mul_nonneg_right ?_ ha⟩
state_before: α : Type u
β : Type u_1
inst✝² : Semiring α
inst✝¹ : LinearOrder α
a b c d : α
inst✝ : PosMulStrictMono α
h : ∀ (n : ℕ), 0 ≤ a * b ^ n
this : 0 ≤ a
ha : 0 < a
⊢ 0 ≤ a * b
state_after: no goals
tactic: simpa only [pow_one] using h 1
Theorem: continuousAt_extChartAt'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x x' : M
h : x' ∈ (extChartAt I x).source
⊢ x' ∈ (chartAt H x).source
state_after: no goals
tactic: rwa [← extChartAt_source I]
Theorem: YoungDiagram.mem_cellsOfRowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: w : List ℕ
c : ℕ × ℕ
⊢ c ∈ YoungDiagram.cellsOfRowLens w ↔ ∃ (h : c.1 < w.length), c.2 < w.get ⟨c.1, h⟩
state_after: case nil
c : ℕ × ℕ
⊢ c ∈ ∅ ↔ ∃ (h : c.1 < [].length), c.2 < [].get ⟨c.1, h⟩

case cons
w_hd : ℕ
w_tl : List ℕ
w_ih : ∀ {c : ℕ × ℕ}, c ∈ YoungDiagram.cellsOfRowLens w_tl ↔ ∃ (h : c.1 < w_tl.length), c.2 < w_tl.get ⟨c.1, h⟩
c : ℕ × ℕ
⊢ c ∈
      {0} ×ˢ Finset.range w_hd ∪
        Finset.map ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Embedding.refl ℕ))
          (YoungDiagram.cellsOfRowLens w_tl) ↔
    ∃ (h : c.1 < (w_hd :: w_tl).length), c.2 < (w_hd :: w_tl).get ⟨c.1, h⟩
tactic: induction' w with w_hd w_tl w_ih generalizing c <;> rw [YoungDiagram.cellsOfRowLens]
Theorem: Complex.abs_exp_eq_iff_re_eq
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ abs (cexp x) = abs (cexp y) ↔ x.re = y.re
state_after: no goals
tactic: rw [abs_exp, abs_exp, Real.exp_eq_exp]
Theorem: Commute.left_comm
File: Mathlib/Algebra/Group/Commute/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
S : Type u_3
inst✝ : Semigroup S
a b c✝ : S
h : Commute a b
c : S
⊢ a * (b * c) = b * (a * c)
state_after: no goals
tactic: simp only [← mul_assoc, h.eq]
Theorem: Submodule.mem_finset_inf
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q : Submodule R M
ι : Type u_4
s : Finset ι
p : ι → Submodule R M
x : M
⊢ x ∈ s.inf p ↔ ∀ i ∈ s, x ∈ p i
state_after: no goals
tactic: simp only [← SetLike.mem_coe, finset_inf_coe, Set.mem_iInter]
Theorem: EuclideanGeometry.dist_center_inversion
File: Mathlib/Geometry/Euclidean/Inversion/Basic.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
a b c✝ d x✝ y z : P
r R✝ : ℝ
c x : P
R : ℝ
⊢ dist c (inversion c R x) = R ^ 2 / dist c x
state_after: no goals
tactic: rw [dist_comm c, dist_comm c, dist_inversion_center]
Theorem: Function.support_add_neg
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝ : DivisionMonoid G
f g : α → G
⊢ (fun a b => a * b⁻¹) 1 1 = 1
state_after: no goals
tactic: simp
Theorem: List.sum_take_map_length_splitWrtComposition
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
l : List α
c : Composition l.length
i : ℕ
⊢ (take i (map length (l.splitWrtComposition c))).sum = c.sizeUpTo i
state_after: case e_a.e_a
n : ℕ
α : Type u_1
l : List α
c : Composition l.length
i : ℕ
⊢ map length (l.splitWrtComposition c) = c.blocks
tactic: congr
state_before: case e_a.e_a
n : ℕ
α : Type u_1
l : List α
c : Composition l.length
i : ℕ
⊢ map length (l.splitWrtComposition c) = c.blocks
state_after: no goals
tactic: exact map_length_splitWrtComposition l c
Theorem: Ordinal.cof_bsup_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (∀ (i : Ordinal.{u}) (h : i < o), f i h < o.bsup f) → (o.bsup f).cof ≤ o.card
state_after: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (∀ (i : Ordinal.{u}) (h : i < o), f i h < o.bsup f) → (o.bsup f).cof ≤ Cardinal.lift.{u, u} o.card
tactic: rw [← o.card.lift_id]
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (∀ (i : Ordinal.{u}) (h : i < o), f i h < o.bsup f) → (o.bsup f).cof ≤ Cardinal.lift.{u, u} o.card
state_after: no goals
tactic: exact cof_bsup_le_lift
Theorem: Ioo_smul_sphere_zero
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε a b r : ℝ
ha : 0 ≤ a
hr : 0 < r
this : EqOn (fun x => ‖x‖) id (Ioo a b)
⊢ (fun x => ‖x‖) ⁻¹' Ioo (a * r) (b * r) = ball 0 (b * r) \ closedBall 0 (a * r)
state_after: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε a b r : ℝ
ha : 0 ≤ a
hr : 0 < r
this : EqOn (fun x => ‖x‖) id (Ioo a b)
x : E
⊢ x ∈ (fun x => ‖x‖) ⁻¹' Ioo (a * r) (b * r) ↔ x ∈ ball 0 (b * r) \ closedBall 0 (a * r)
tactic: ext x
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε a b r : ℝ
ha : 0 ≤ a
hr : 0 < r
this : EqOn (fun x => ‖x‖) id (Ioo a b)
x : E
⊢ x ∈ (fun x => ‖x‖) ⁻¹' Ioo (a * r) (b * r) ↔ x ∈ ball 0 (b * r) \ closedBall 0 (a * r)
state_after: no goals
tactic: simp [and_comm]
Theorem: Denumerable.prod_nat_ofNat
File: Mathlib/Logic/Denumerable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ofNat (ℕ × ℕ) = unpair
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
x✝ : ℕ
⊢ ofNat (ℕ × ℕ) x✝ = unpair x✝
tactic: funext
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
x✝ : ℕ
⊢ ofNat (ℕ × ℕ) x✝ = unpair x✝
state_after: no goals
tactic: simp
Theorem: pythagoreanTriple_comm
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
⊢ PythagoreanTriple x y z ↔ PythagoreanTriple y x z
state_after: x y z : ℤ
⊢ x * x + y * y = z * z ↔ y * y + x * x = z * z
tactic: delta PythagoreanTriple
state_before: x y z : ℤ
⊢ x * x + y * y = z * z ↔ y * y + x * x = z * z
state_after: no goals
tactic: rw [add_comm]
Theorem: Nat.prod_factorial_pos
File: Mathlib/Data/Nat/Factorial/BigOperators.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f : α → ℕ
⊢ 0 < ∏ i ∈ s, (f i)!
state_after: no goals
tactic: positivity
Theorem: FormalMultilinearSeries.constFormalMultilinearSeries_radius
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
v : F
⊢ ∀ (m : ℕ), constFormalMultilinearSeries 𝕜 E v (m + 1) = 0
state_after: no goals
tactic: simp [constFormalMultilinearSeries]
Theorem: MeasureTheory.Measure.addHaar_preimage_smul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
r : ℝ
hr : r ≠ 0
s : Set E
⊢ (map (fun x => r • x) μ) s = ENNReal.ofReal |(r ^ finrank ℝ E)⁻¹| * μ s
state_after: no goals
tactic: rw [map_addHaar_smul μ hr, coe_smul, Pi.smul_apply, smul_eq_mul]
Theorem: CategoryTheory.MonoidalCategory.tensor_inv_hom_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f.inv) ≫ (h ⊗ f.hom) = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)
state_after: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 W = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)
tactic: rw [← tensor_comp, f.inv_hom_id]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 W = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)
state_after: no goals
tactic: simp [tensorHom_id]
Theorem: Ordinal.one_lt_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: ⊢ 1 < ω
state_after: no goals
tactic: simpa only [Nat.cast_one] using nat_lt_omega 1
Theorem: Metric.tendstoLocallyUniformly_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
⊢ TendstoLocallyUniformly F f p ↔ ∀ ε > 0, ∀ (x : β), ∃ t ∈ 𝓝 x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, dist (f y) (F n y) < ε
state_after: no goals
tactic: simp only [← tendstoLocallyUniformlyOn_univ, tendstoLocallyUniformlyOn_iff, nhdsWithin_univ,
    mem_univ, forall_const, exists_prop]
Theorem: List.insertNth_comm
File: Mathlib/Data/List/InsertNth.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a✝ a b : α
j : ℕ
l : List α
⊢ 0 ≤ j → j ≤ l.length → insertNth (j + 1) b (insertNth 0 a l) = insertNth 0 a (insertNth j b l)
state_after: no goals
tactic: simp [insertNth]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a✝ a b : α
i j : ℕ
⊢ i + 1 ≤ j + 1 →
    j + 1 ≤ [].length → insertNth (j + 1 + 1) b (insertNth (i + 1) a []) = insertNth (i + 1) a (insertNth (j + 1) b [])
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a✝ a b : α
i j : ℕ
c : α
l : List α
h₀ : i + 1 ≤ j + 1
h₁ : j + 1 ≤ (c :: l).length
⊢ insertNth (j + 1 + 1) b (insertNth (i + 1) a (c :: l)) = insertNth (i + 1) a (insertNth (j + 1) b (c :: l))
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a✝ a b : α
i j : ℕ
c : α
l : List α
h₀ : i + 1 ≤ j + 1
h₁ : j + 1 ≤ (c :: l).length
⊢ insertNth (j + 1) b (insertNth i a l) = insertNth i a (insertNth j b l)
tactic: simp only [insertNth_succ_cons, cons.injEq, true_and]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a✝ a b : α
i j : ℕ
c : α
l : List α
h₀ : i + 1 ≤ j + 1
h₁ : j + 1 ≤ (c :: l).length
⊢ insertNth (j + 1) b (insertNth i a l) = insertNth i a (insertNth j b l)
state_after: no goals
tactic: exact insertNth_comm a b i j l (Nat.le_of_succ_le_succ h₀) (Nat.le_of_succ_le_succ h₁)
Theorem: singleton_mul_ball
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
⊢ {x} * ball y δ = ball (x * y) δ
state_after: no goals
tactic: simp only [preimage_mul_ball, image_mul_left, singleton_mul, div_inv_eq_mul, mul_comm y x]
Theorem: Nat.dvd_iff_dvd_ofDigits
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b ∣ ↑b' - c
n : ℕ
⊢ b ∣ n ↔ ↑b ∣ ofDigits c (b'.digits n)
state_after: n✝ b b' : ℕ
c : ℤ
h : ↑b ∣ ↑b' - c
n : ℕ
⊢ ↑b ∣ ↑n ↔ ↑b ∣ ofDigits c (b'.digits n)
tactic: rw [← Int.natCast_dvd_natCast]
state_before: n✝ b b' : ℕ
c : ℤ
h : ↑b ∣ ↑b' - c
n : ℕ
⊢ ↑b ∣ ↑n ↔ ↑b ∣ ofDigits c (b'.digits n)
state_after: no goals
tactic: exact
    dvd_iff_dvd_of_dvd_sub (zmodeq_ofDigits_digits b b' c (Int.modEq_iff_dvd.2 h).symm _).symm.dvd