ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EReal.liminf_add_top_of_ne_bot
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
⊢ liminf (u + v) f = ⊤
state_after: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
⊢ ∀ (z : ℝ), ↑z < ⊤ → ↑z ≤ liminf (u + v) f
tactic: apply top_le_iff.1 ((ge_iff_le_forall_real_lt (liminf (u + v) f) ⊤).1 _)
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
⊢ ∀ (z : ℝ), ↑z < ⊤ → ↑z ≤ liminf (u + v) f
state_after: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x : ℝ
⊢ ↑x < ⊤ → ↑x ≤ liminf (u + v) f
tactic: intro x
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x : ℝ
⊢ ↑x < ⊤ → ↑x ≤ liminf (u + v) f
state_after: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
⊢ ↑x < ⊤ → ↑x ≤ liminf (u + v) f
tactic: rcases exists_between_coe_real (Ne.bot_lt h') with ⟨y, ⟨_, hy⟩⟩
state_before: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
⊢ ↑x < ⊤ → ↑x ≤ liminf (u + v) f
state_after: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
a✝ : ↑x < ⊤
⊢ ↑x ≤ liminf (u + v) f
tactic: intro _
state_before: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
a✝ : ↑x < ⊤
⊢ ↑x ≤ liminf (u + v) f
state_after: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
a✝ : ↑x < ⊤
⊢ ↑(x - y) + ↑y ≤ liminf (u + v) f
tactic: rw [← sub_add_cancel x y, coe_add (x - y) y]
state_before: case intro.intro
α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
f : Filter α
u v : α → EReal
a b : EReal
h : liminf u f = ⊤
h' : liminf v f ≠ ⊥
x y : ℝ
left✝ : ⊥ < ↑y
hy : ↑y < liminf v f
a✝ : ↑x < ⊤
⊢ ↑(x - y) + ↑y ≤ liminf (u + v) f
state_after: no goals
tactic: exact coe_sub x y ▸ @liminf_add_gt_of_gt α f u v (x - y) y
    (h ▸ coe_sub x y ▸ coe_lt_top (x-y)) hy |>.le
Theorem: Finsupp.zipWith_neLocus_eq_right
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
⊢ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂
state_after: case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
a✝ : α
⊢ a✝ ∈ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) ↔ a✝ ∈ f₁.neLocus f₂
tactic: ext
state_before: case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
a✝ : α
⊢ a✝ ∈ (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) ↔ a✝ ∈ f₁.neLocus f₂
state_after: no goals
tactic: simpa only [mem_neLocus] using (hF _).ne_iff
Theorem: EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius
File: Mathlib/Geometry/Euclidean/Angle/Sphere.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)
s : Sphere P
p₁ p₂ : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
h : p₁ ≠ p₂
⊢ dist p₁ p₂ / (∡ p₂ p₁ s.center).cos = 2 * s.radius
state_after: no goals
tactic: rw [← dist_div_cos_oangle_center_div_two_eq_radius hp₁ hp₂ h, mul_div_cancel₀ _ (two_ne_zero' ℝ)]
Theorem: CategoryTheory.Dial.tensorHom_f
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj (X₁.tensorObj Y₁).rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tensorObj Y₂).tgt))).obj (X₂.tensorObj Y₂).rel
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₁.rel) ⊓
      (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₁.rel) ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₂.rel) ⊓
      (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₂.rel)
tactic: simp only [tensorObj, Subobject.inf_pullback]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₁.rel) ⊓
      (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₁.rel) ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₂.rel) ⊓
      (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₂.rel)
state_after: case h₁
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback (π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F)) ≫ prod.map π₁ π₁)).obj X₁.rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)) ≫ prod.map π₁ π₁)).obj X₂.rel

case h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback (π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F)) ≫ prod.map π₂ π₂)).obj Y₁.rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)) ≫ prod.map π₂ π₂)).obj Y₂.rel
tactic: apply inf_le_inf <;> rw [← Subobject.pullback_comp, ← Subobject.pullback_comp]
Theorem: Polynomial.ker_evalRingHom
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
⊢ RingHom.ker (evalRingHom x) = Ideal.span {X - C x}
state_after: case h
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
y : R[X]
⊢ y ∈ RingHom.ker (evalRingHom x) ↔ y ∈ Ideal.span {X - C x}
tactic: ext y
state_before: case h
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
y : R[X]
⊢ y ∈ RingHom.ker (evalRingHom x) ↔ y ∈ Ideal.span {X - C x}
state_after: no goals
tactic: simp [Ideal.mem_span_singleton, dvd_iff_isRoot, RingHom.mem_ker]
Theorem: MvPolynomial.aeval_algebraMap_apply
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
σ : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
⊢ (aeval (⇑(algebraMap A B) ∘ x)) p = (algebraMap A B) ((aeval x) p)
state_after: R : Type u_1
A : Type u_2
B : Type u_3
σ : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R B) (⇑(algebraMap A B) ∘ x)) p = (eval₂Hom (algebraMap R B) fun i => (algebraMap A B) (x i)) p
tactic: rw [aeval_def, aeval_def, ← coe_eval₂Hom, ← coe_eval₂Hom, map_eval₂Hom, ←
    IsScalarTower.algebraMap_eq]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
σ : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
⊢ (eval₂Hom (algebraMap R B) (⇑(algebraMap A B) ∘ x)) p = (eval₂Hom (algebraMap R B) fun i => (algebraMap A B) (x i)) p
state_after: no goals
tactic: simp only [Function.comp]
Theorem: ContinuousLinearEquiv.comp_right_differentiable_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
⊢ Differentiable 𝕜 (f ∘ ⇑iso) ↔ Differentiable 𝕜 f
state_after: no goals
tactic: simp only [← differentiableOn_univ, ← iso.comp_right_differentiableOn_iff, preimage_univ]
Theorem: add_pow_expChar_pow
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
q : ℕ
hR : ExpChar R q
n : ℕ
x y : R
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: case zero
R : Type u
inst✝¹ : CommSemiring R
n : ℕ
x y : R
inst✝ : CharZero R
⊢ (x + y) ^ 1 ^ n = x ^ 1 ^ n + y ^ 1 ^ n

case prime
R : Type u
inst✝ : CommSemiring R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : CommSemiring R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: case prime
R : Type u
inst✝ : CommSemiring R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : CommSemiring R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q ^ n = x ^ q ^ n + y ^ q ^ n
state_after: no goals
tactic: exact add_pow_char_pow R x y
Theorem: Finsupp.filter_eq_self_iff
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
p : α → Prop
inst✝ : DecidablePred p
f : α →₀ M
⊢ filter p f = f ↔ ∀ (x : α), f x ≠ 0 → p x
state_after: no goals
tactic: simp only [DFunLike.ext_iff, filter_eq_indicator, Set.indicator_apply_eq_self, Set.mem_setOf_eq,
    not_imp_comm]
Theorem: Quaternion.norm_coe
File: Mathlib/Analysis/Quaternion.lean

Proof steps:
state_before: a : ℝ
⊢ ‖↑a‖ = ‖a‖
state_after: no goals
tactic: rw [norm_eq_sqrt_real_inner, inner_self, normSq_coe, Real.sqrt_sq_eq_abs, Real.norm_eq_abs]
Theorem: mem_nhds_discrete
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : DiscreteTopology α
β : Type u_2
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ x ∈ s
state_after: no goals
tactic: rw [nhds_discrete, mem_pure]
Theorem: CategoryTheory.eval_typesGlue
File: Mathlib/CategoryTheory/Sites/Types.lean

Proof steps:
state_before: S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj (op PUnit.{u + 1})
⊢ eval S α (typesGlue S hs α f) = f
state_after: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj (op PUnit.{u + 1})
x : α
⊢ eval S α (typesGlue S hs α f) x = f x
tactic: funext x
state_before: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj (op PUnit.{u + 1})
x : α
⊢ eval S α (typesGlue S hs α f) x = f x
state_after: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj (op PUnit.{u + 1})
x : α
⊢ S.map (↾fun x => PUnit.unit).op (f ((↾fun x_1 => x) (Classical.choose ⋯))) = f x
tactic: apply (IsSheafFor.valid_glue _ _ _ <| ⟨PUnit.unit, fun _ => Subsingleton.elim _ _⟩).trans
state_before: case h
S : Type uᵒᵖ ⥤ Type u
hs : IsSheaf typesGrothendieckTopology S
α : Type u
f : α → S.obj (op PUnit.{u + 1})
x : α
⊢ S.map (↾fun x => PUnit.unit).op (f ((↾fun x_1 => x) (Classical.choose ⋯))) = f x
state_after: no goals
tactic: convert FunctorToTypes.map_id_apply S _
Theorem: Prod.mk_covBy_mk_iff_left
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂
state_after: no goals
tactic: simp_rw [covBy_iff_wcovBy_and_lt, mk_wcovBy_mk_iff_left, mk_lt_mk_iff_left]
Theorem: Real.pow_rpow_inv_natCast
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x
state_after: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x
tactic: have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (x ^ n) ^ (↑n)⁻¹ = x
state_after: no goals
tactic: rw [← rpow_natCast, ← rpow_mul hx, mul_inv_cancel hn0, rpow_one]
Theorem: Complex.equivRealProdLm_symm_apply_re
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: r : ℝ
c : ℂ
⊢ { toFun := __src✝.toFun, map_add' := ⋯ }.toFun (r • c) =
    (RingHom.id ℝ) r • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun c
state_after: no goals
tactic: simp [equivRealProdAddHom, Prod.smul_def, smul_eq_mul]
Theorem: topologicalAddGroup_is_uniform_of_compactSpace
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : CompactSpace G
⊢ UniformContinuous fun p => p.1 / p.2
state_after: case h
G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : CompactSpace G
⊢ Continuous fun p => p.1 / p.2
tactic: apply CompactSpace.uniformContinuous_of_continuous
state_before: case h
G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : CompactSpace G
⊢ Continuous fun p => p.1 / p.2
state_after: no goals
tactic: exact continuous_div'
Theorem: CategoryTheory.Bicategory.whiskerRight_comp_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h = (α_ f g h).hom ≫ η ▷ (g ≫ h) ≫ (α_ f' g h).inv
state_after: no goals
tactic: simp
Theorem: BoxIntegral.Prepartition.mem_splitCenter
File: Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
⊢ J ∈ splitCenter I ↔ ∃ s, I.splitCenterBox s = J
state_after: no goals
tactic: simp [splitCenter]
Theorem: Polynomial.coeff_C_ne_zero
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
h : n ≠ 0
⊢ (C a).coeff n = 0
state_after: no goals
tactic: rw [coeff_C, if_neg h]
Theorem: Set.mapsTo_iff_exists_map_subtype
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)
x : α
hx : x ∈ s
g : ↑s → ↑t
hg : ∀ (x : ↑s), f ↑x = ↑(g x)
⊢ f x ∈ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)
x : α
hx : x ∈ s
g : ↑s → ↑t
hg : ∀ (x : ↑s), f ↑x = ↑(g x)
⊢ ↑(g ⟨x, hx⟩) ∈ t
tactic: erw [hg ⟨x, hx⟩]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
x✝ : ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)
x : α
hx : x ∈ s
g : ↑s → ↑t
hg : ∀ (x : ↑s), f ↑x = ↑(g x)
⊢ ↑(g ⟨x, hx⟩) ∈ t
state_after: no goals
tactic: apply Subtype.coe_prop
Theorem: Set.indicator_le_indicator_nonneg
File: Mathlib/Algebra/Order/Group/Indicator.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : Zero M
inst✝ : LinearOrder M
s : Set α
f : α → M
⊢ s.indicator f ≤ {a | 0 ≤ f a}.indicator f
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : Zero M
inst✝ : LinearOrder M
s : Set α
f : α → M
a : α
⊢ s.indicator f a ≤ {a | 0 ≤ f a}.indicator f a
tactic: intro a
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝¹ : Zero M
inst✝ : LinearOrder M
s : Set α
f : α → M
a : α
⊢ s.indicator f a ≤ {a | 0 ≤ f a}.indicator f a
state_after: no goals
tactic: classical
  simp_rw [indicator_apply]
  split_ifs
  exacts [le_rfl, (not_le.1 ‹_›).le, ‹_›, le_rfl]
Theorem: PartENat.add_one_le_iff_lt
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : PartENat
hx : x ≠ ⊤
⊢ x + 1 ≤ y ↔ x < y
state_after: x y : PartENat
hx : x ≠ ⊤
h : x + 1 ≤ y
⊢ x < y
tactic: refine ⟨fun h => ?_, add_one_le_of_lt⟩
state_before: x y : PartENat
hx : x ≠ ⊤
h : x + 1 ≤ y
⊢ x < y
state_after: case intro
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h : ↑m + 1 ≤ y
⊢ ↑m < y
tactic: rcases ne_top_iff.mp hx with ⟨m, rfl⟩
state_before: case intro
y : PartENat
m : ℕ
hx : ↑m ≠ ⊤
h : ↑m + 1 ≤ y
⊢ ↑m < y
state_after: case intro.a
m : ℕ
hx : ↑m ≠ ⊤
h : ↑m + 1 ≤ ⊤
⊢ ↑m < ⊤

case intro.a
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ ↑m < ↑n
tactic: induction' y using PartENat.casesOn with n
state_before: case intro.a
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ ↑m < ↑n
state_after: case intro.a
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ m < n
tactic: norm_cast
state_before: case intro.a
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ m < n
state_after: case intro.a.h
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ m.succ ≤ n
tactic: apply Nat.lt_of_succ_le
state_before: case intro.a.h
m : ℕ
hx : ↑m ≠ ⊤
n : ℕ
h : ↑m + 1 ≤ ↑n
⊢ m.succ ≤ n
state_after: no goals
tactic: norm_cast at h
Theorem: BoxIntegral.Box.mk'_eq_bot
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ mk' l u = ⊥ ↔ ∃ i, u i ≤ l i
state_after: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) = ⊥ ↔ ∃ i, u i ≤ l i
tactic: rw [mk']
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ (if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) = ⊥ ↔ ∃ i, u i ≤ l i
state_after: no goals
tactic: split_ifs with h <;> simpa using h
Theorem: finprod_mem_range'
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g✝ : α → M
a b : α
s t : Set α
g : β → α
hg : InjOn g (mulSupport (f ∘ g))
⊢ ∏ᶠ (i : α) (_ : i ∈ range g), f i = ∏ᶠ (j : β), f (g j)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g✝ : α → M
a b : α
s t : Set α
g : β → α
hg : InjOn g (mulSupport (f ∘ g))
⊢ InjOn g (univ ∩ mulSupport (f ∘ g))
tactic: rw [← image_univ, finprod_mem_image', finprod_mem_univ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g✝ : α → M
a b : α
s t : Set α
g : β → α
hg : InjOn g (mulSupport (f ∘ g))
⊢ InjOn g (univ ∩ mulSupport (f ∘ g))
state_after: no goals
tactic: rwa [univ_inter]
Theorem: Nat.pow_mul_mem_smoothNumbers
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
⊢ p ^ e * n ∈ p.succ.smoothNumbers
state_after: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
⊢ p ^ e * n ∈ p.succ.smoothNumbers
tactic: have : NoZeroDivisors ℕ := inferInstance
state_before: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
⊢ p ^ e * n ∈ p.succ.smoothNumbers
state_after: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
⊢ p ^ e * n ∈ p.succ.smoothNumbers
tactic: have hp' := pow_ne_zero e hp
state_before: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
⊢ p ^ e * n ∈ p.succ.smoothNumbers
state_after: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
q : ℕ
hq : q ∈ (p ^ e * n).primeFactorsList
⊢ q < p.succ
tactic: refine ⟨mul_ne_zero hp' hn.1, fun q hq ↦ ?_⟩
state_before: p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
q : ℕ
hq : q ∈ (p ^ e * n).primeFactorsList
⊢ q < p.succ
state_after: case inl
p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
q : ℕ
hq : q ∈ (p ^ e * n).primeFactorsList
H : q ∈ (p ^ e).primeFactorsList
⊢ q < p.succ

case inr
p n : ℕ
hp : p ≠ 0
e : ℕ
hn : n ∈ p.smoothNumbers
this : NoZeroDivisors ℕ
hp' : p ^ e ≠ 0
q : ℕ
hq : q ∈ (p ^ e * n).primeFactorsList
H : q ∈ n.primeFactorsList
⊢ q < p.succ
tactic: rcases (mem_primeFactorsList_mul hp' hn.1).mp hq with H | H
Theorem: Finset.Ico_insert_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ insert b (Ico a b) = Icc a b
state_after: no goals
tactic: rw [← coe_inj, coe_insert, coe_Icc, coe_Ico, Set.insert_eq, Set.union_comm, Set.Ico_union_right h]
Theorem: IsLocalization.ideal_eq_iInf_comap_map_away
File: Mathlib/RingTheory/Localization/Ideal.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S✝ : Type u_2
inst✝² : CommRing S✝
inst✝¹ : Algebra R S✝
inst✝ : IsLocalization M S✝
S : Finset R
hS : Ideal.span ↑S = ⊤
I : Ideal R
⊢ I = ⨅ f ∈ S, Ideal.comap (algebraMap R (Localization.Away f)) (Ideal.map (algebraMap R (Localization.Away f)) I)
state_after: case a
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S✝ : Type u_2
inst✝² : CommRing S✝
inst✝¹ : Algebra R S✝
inst✝ : IsLocalization M S✝
S : Finset R
hS : Ideal.span ↑S = ⊤
I : Ideal R
⊢ I ≤ ⨅ f ∈ S, Ideal.comap (algebraMap R (Localization.Away f)) (Ideal.map (algebraMap R (Localization.Away f)) I)

case a
R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S✝ : Type u_2
inst✝² : CommRing S✝
inst✝¹ : Algebra R S✝
inst✝ : IsLocalization M S✝
S : Finset R
hS : Ideal.span ↑S = ⊤
I : Ideal R
⊢ ⨅ f ∈ S, Ideal.comap (algebraMap R (Localization.Away f)) (Ideal.map (algebraMap R (Localization.Away f)) I) ≤ I
tactic: apply le_antisymm