ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LieSubmodule.isNilpotent_iff_exists_lcs_eq_bot
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k : ℕ
N✝ : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N : LieSubmodule R L M
⊢ IsNilpotent R L ↥↑N ↔ ∃ k, LieSubmodule.lcs k N = ⊥
state_after: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k : ℕ
N✝ : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N : LieSubmodule R L M
⊢ (∃ k, lowerCentralSeries R L (↥↑N) k = ⊥) ↔ ∃ k, LieSubmodule.lcs k N = ⊥
tactic: rw [isNilpotent_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k : ℕ
N✝ : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N : LieSubmodule R L M
⊢ (∃ k, lowerCentralSeries R L (↥↑N) k = ⊥) ↔ ∃ k, LieSubmodule.lcs k N = ⊥
state_after: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N✝ : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N : LieSubmodule R L M
k : ℕ
⊢ lowerCentralSeries R L (↥↑N) k = ⊥ ↔ LieSubmodule.lcs k N = ⊥
tactic: refine exists_congr fun k => ?_
state_before: R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N✝ : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N : LieSubmodule R L M
k : ℕ
⊢ lowerCentralSeries R L (↥↑N) k = ⊥ ↔ LieSubmodule.lcs k N = ⊥
state_after: no goals
tactic: rw [N.lowerCentralSeries_eq_lcs_comap k, LieSubmodule.comap_incl_eq_bot,
    inf_eq_right.mpr (N.lcs_le_self k)]
Theorem: Real.cos_two_mul'
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(cos (2 * x)) = ↑(cos x ^ 2 - sin x ^ 2)
state_after: no goals
tactic: simp [cos_two_mul']
Theorem: ENNReal.tendsto_toNNReal
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
ha : a ≠ ⊤
⊢ Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto ENNReal.toNNReal (𝓝 ↑a) (𝓝 (↑a).toNNReal)
tactic: lift a to ℝ≥0 using ha
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto ENNReal.toNNReal (𝓝 ↑a) (𝓝 (↑a).toNNReal)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto (ENNReal.toNNReal ∘ ofNNReal) (𝓝 a) (𝓝 (↑a).toNNReal)
tactic: rw [nhds_coe, tendsto_map'_iff]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto (ENNReal.toNNReal ∘ ofNNReal) (𝓝 a) (𝓝 (↑a).toNNReal)
state_after: no goals
tactic: exact tendsto_id
Theorem: nullMeasurableSet_region_between_cc
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ✝ : Measure α
f✝ g✝ : α → ℝ
s✝ : Set α
μ : Measure α
f g : α → ℝ
f_mble : AEMeasurable f μ
g_mble : AEMeasurable g μ
s : Set α
s_mble : NullMeasurableSet s μ
⊢ NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Icc (f p.1) (g p.1)} (μ.prod volume)
state_after: case refine_1
α : Type u_1
inst✝ : MeasurableSpace α
μ✝ : Measure α
f✝ g✝ : α → ℝ
s✝ : Set α
μ : Measure α
f g : α → ℝ
f_mble : AEMeasurable f μ
g_mble : AEMeasurable g μ
s : Set α
s_mble : NullMeasurableSet s μ
⊢ NullMeasurableSet (fun p => f p.1 ≤ p.2) (μ.prod volume)

case refine_2
α : Type u_1
inst✝ : MeasurableSpace α
μ✝ : Measure α
f✝ g✝ : α → ℝ
s✝ : Set α
μ : Measure α
f g : α → ℝ
f_mble : AEMeasurable f μ
g_mble : AEMeasurable g μ
s : Set α
s_mble : NullMeasurableSet s μ
⊢ NullMeasurableSet (fun p => p.2 ≤ g p.1) (μ.prod volume)
tactic: refine NullMeasurableSet.inter
          (s_mble.preimage quasiMeasurePreserving_fst) (NullMeasurableSet.inter ?_ ?_)
Theorem: Nat.add_eq_three_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0
state_after: no goals
tactic: omega
Theorem: spectrum.exists_mem_of_not_isUnit_aeval_prod
File: Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬IsUnit ((aeval a) (Multiset.map (fun x => X - C x) p.roots).prod)
⊢ ∃ k ∈ σ a, eval k p = 0
state_after: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬IsUnit (List.map (⇑(aeval a)) (Multiset.map (fun x => X - C x) p.roots).toList).prod
⊢ ∃ k ∈ σ a, eval k p = 0
tactic: rw [← Multiset.prod_toList, map_list_prod] at h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬IsUnit (List.map (⇑(aeval a)) (Multiset.map (fun x => X - C x) p.roots).toList).prod
⊢ ∃ k ∈ σ a, eval k p = 0
state_after: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬∀ m ∈ List.map (⇑(aeval a)) (Multiset.map (fun x => X - C x) p.roots).toList, IsUnit m
⊢ ∃ k ∈ σ a, eval k p = 0
tactic: replace h := mt List.prod_isUnit h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ¬∀ m ∈ List.map (⇑(aeval a)) (Multiset.map (fun x => X - C x) p.roots).toList, IsUnit m
⊢ ∃ k ∈ σ a, eval k p = 0
state_after: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ∃ a_1 ∈ p.roots, ¬IsUnit (a - ↑ₐ a_1)
⊢ ∃ k ∈ σ a, eval k p = 0
tactic: simp only [not_forall, exists_prop, aeval_C, Multiset.mem_toList, List.mem_map, aeval_X,
    exists_exists_and_eq_and, Multiset.mem_map, map_sub] at h
state_before: R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
h : ∃ a_1 ∈ p.roots, ¬IsUnit (a - ↑ₐ a_1)
⊢ ∃ k ∈ σ a, eval k p = 0
state_after: case intro.intro
R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
r : R
r_mem : r ∈ p.roots
r_nu : ¬IsUnit (a - ↑ₐ r)
⊢ ∃ k ∈ σ a, eval k p = 0
tactic: rcases h with ⟨r, r_mem, r_nu⟩
state_before: case intro.intro
R : Type u
A : Type v
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : IsDomain R
p : R[X]
a : A
r : R
r_mem : r ∈ p.roots
r_nu : ¬IsUnit (a - ↑ₐ r)
⊢ ∃ k ∈ σ a, eval k p = 0
state_after: no goals
tactic: exact ⟨r, by rwa [mem_iff, ← IsUnit.sub_iff], (mem_roots'.1 r_mem).2⟩
Theorem: NonUnitalSubalgebra.star_adjoin_comm
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹³ : CommSemiring R
inst✝¹² : StarRing R
inst✝¹¹ : NonUnitalSemiring A
inst✝¹⁰ : StarRing A
inst✝⁹ : Module R A
inst✝⁸ : IsScalarTower R A A
inst✝⁷ : SMulCommClass R A A
inst✝⁶ : StarModule R A
inst✝⁵ : NonUnitalSemiring B
inst✝⁴ : StarRing B
inst✝³ : Module R B
inst✝² : IsScalarTower R B B
inst✝¹ : SMulCommClass R B B
inst✝ : StarModule R B
s : Set A
this : ∀ (t : Set A), NonUnitalAlgebra.adjoin R (star t) ≤ star (NonUnitalAlgebra.adjoin R t)
⊢ star (NonUnitalAlgebra.adjoin R s) ≤ NonUnitalAlgebra.adjoin R (star s)
state_after: no goals
tactic: simpa only [star_star] using NonUnitalSubalgebra.star_mono (this (star s))
Theorem: Cardinal.two_le_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{?u.232884}
⊢ 2 ≤ #α ↔ ∃ x y, x ≠ y
state_after: no goals
tactic: rw [← Nat.cast_two, nat_succ, succ_le_iff, Nat.cast_one, one_lt_iff_nontrivial, nontrivial_iff]
Theorem: List.getElem_splitWrtCompositionAux
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
l : List α
ns : List ℕ
i : ℕ
hi : i < (l.splitWrtCompositionAux ns).length
⊢ (l.splitWrtCompositionAux ns)[i] = drop (take i ns).sum (take (take (i + 1) ns).sum l)
state_after: case nil
n : ℕ
α : Type u_1
l : List α
i : ℕ
hi : i < (l.splitWrtCompositionAux []).length
⊢ (l.splitWrtCompositionAux [])[i] = drop (take i []).sum (take (take (i + 1) []).sum l)

case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH :
  ∀ (l : List α) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length),
    (l.splitWrtCompositionAux ns)[i] = drop (take i ns).sum (take (take (i + 1) ns).sum l)
l : List α
i : ℕ
hi : i < (l.splitWrtCompositionAux (n :: ns)).length
⊢ (l.splitWrtCompositionAux (n :: ns))[i] = drop (take i (n :: ns)).sum (take (take (i + 1) (n :: ns)).sum l)
tactic: induction' ns with n ns IH generalizing l i
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH :
  ∀ (l : List α) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length),
    (l.splitWrtCompositionAux ns)[i] = drop (take i ns).sum (take (take (i + 1) ns).sum l)
l : List α
i : ℕ
hi : i < (l.splitWrtCompositionAux (n :: ns)).length
⊢ (l.splitWrtCompositionAux (n :: ns))[i] = drop (take i (n :: ns)).sum (take (take (i + 1) (n :: ns)).sum l)
state_after: case cons.zero
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH :
  ∀ (l : List α) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length),
    (l.splitWrtCompositionAux ns)[i] = drop (take i ns).sum (take (take (i + 1) ns).sum l)
l : List α
hi : 0 < (l.splitWrtCompositionAux (n :: ns)).length
⊢ (l.splitWrtCompositionAux (n :: ns))[0] = drop (take 0 (n :: ns)).sum (take (take (0 + 1) (n :: ns)).sum l)

case cons.succ
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH :
  ∀ (l : List α) {i : ℕ} (hi : i < (l.splitWrtCompositionAux ns).length),
    (l.splitWrtCompositionAux ns)[i] = drop (take i ns).sum (take (take (i + 1) ns).sum l)
l : List α
i : ℕ
hi : i + 1 < (l.splitWrtCompositionAux (n :: ns)).length
⊢ (l.splitWrtCompositionAux (n :: ns))[i + 1] =
    drop (take (i + 1) (n :: ns)).sum (take (take (i + 1 + 1) (n :: ns)).sum l)
tactic: cases' i with i
Theorem: CategoryTheory.Limits.desc_op_comp_opCoproductIsoProduct'_hom
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
⊢ (hc.desc c').op ≫ (opCoproductIsoProduct' hc hf).hom = hf.lift c'.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c.ι.app { as := j } ≫ (hc.desc c').op.unop).op =
    (c.ι.app { as := j } ≫ (hf.lift c'.op ≫ (opCoproductIsoProduct' hc hf).inv).unop).op
tactic: refine (Iso.eq_comp_inv _).mp (Quiver.Hom.unop_inj (hc.hom_ext (fun ⟨j⟩ ↦ Quiver.Hom.op_inj ?_)))
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c.ι.app { as := j } ≫ (hc.desc c').op.unop).op =
    (c.ι.app { as := j } ≫ (hf.lift c'.op ≫ (opCoproductIsoProduct' hc hf).inv).unop).op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c'.ι.app { as := j }).op =
    hf.lift (Fan.mk (op c'.pt) fun a => (c'.inj a).op) ≫ (opCoproductIsoProduct' hc hf).inv ≫ (c.ι.app { as := j }).op
tactic: simp only [unop_op, Discrete.functor_obj, const_obj_obj, Quiver.Hom.unop_op, IsColimit.fac,
    Cofan.op, unop_comp, op_comp, op_unop, Quiver.Hom.op_unop, Category.assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c'.ι.app { as := j }).op =
    hf.lift (Fan.mk (op c'.pt) fun a => (c'.inj a).op) ≫ (opCoproductIsoProduct' hc hf).inv ≫ (c.ι.app { as := j }).op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c'.ι.app { as := j }).op = (Fan.mk (op c'.pt) fun a => (c'.inj a).op).π.app { as := j }
tactic: erw [opCoproductIsoProduct'_inv_comp_inj, IsLimit.fac]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
c : Cofan Z
f : Fan fun x => op (Z x)
hc : IsColimit c
hf : IsLimit f
c' : Cofan Z
x✝ : Discrete α
j : α
⊢ (c'.ι.app { as := j }).op = (Fan.mk (op c'.pt) fun a => (c'.inj a).op).π.app { as := j }
state_after: no goals
tactic: rfl
Theorem: Set.Icc_diff_both
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
⊢ Icc a b \ {a, b} = Ioo a b
state_after: no goals
tactic: rw [insert_eq, ← diff_diff, Icc_diff_left, Ioc_diff_right]
Theorem: CategoryTheory.Limits.biproduct.fromSubtype_eq_lift
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
⊢ ∀ (j : J), fromSubtype f p ≫ π f j = (lift fun j => if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0) ≫ π f j
state_after: no goals
tactic: simp
Theorem: prod_nhdsSet_le_of_disjoint_cocompact
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
K : Set X
hKf : K ∈ f
hK : IsCompact K
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)
tactic: obtain ⟨K, hKf, hK⟩ := (disjoint_cocompact_right f).mp hf
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
K : Set X
hKf : K ∈ f
hK : IsCompact K
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)
state_after: no goals
tactic: calc
    f ×ˢ 𝓝ˢ t
    _ ≤ (𝓟 K) ×ˢ 𝓝ˢ t      := Filter.prod_mono_left _ (Filter.le_principal_iff.mpr hKf)
    _ ≤ 𝓝ˢ K ×ˢ 𝓝ˢ t       := Filter.prod_mono_left _ principal_le_nhdsSet
    _ = 𝓝ˢ (K ×ˢ t)         := (hK.nhdsSet_prod_eq ht).symm
    _ ≤ 𝓝ˢ (Set.univ ×ˢ t)  := nhdsSet_mono (prod_mono_left le_top)
Theorem: CategoryTheory.PreservesImage.factorThruImage_comp_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean

Proof steps:
state_before: A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f)
state_after: no goals
tactic: simp
Theorem: Part.some_sub_some
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Div α
a b : α
⊢ some a / some b = some (a / b)
state_after: no goals
tactic: simp [div_def]
Theorem: AlgebraicTopology.DoldKan.Q_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ Q q ≫ Q q = Q q
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (Q q ≫ Q q).f n = (Q q).f n
tactic: ext n
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (Q q ≫ Q q).f n = (Q q).f n
state_after: no goals
tactic: exact Q_f_idem q n
Theorem: LinearPMap.graph_map_fst_eq_domain
File: Mathlib/LinearAlgebra/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ Submodule.map (LinearMap.fst R E F) f.graph = f.domain
state_after: case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ Submodule.map (LinearMap.fst R E F) f.graph ↔ x ∈ f.domain
tactic: ext x
state_before: case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ x ∈ Submodule.map (LinearMap.fst R E F) f.graph ↔ x ∈ f.domain
state_after: case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ (∃ x_1, ∃ (h : x ∈ f.domain), ↑f ⟨x, ⋯⟩ = x_1) ↔ x ∈ f.domain
tactic: simp only [Submodule.mem_map, mem_graph_iff, Subtype.exists, exists_and_left, exists_eq_left,
    LinearMap.fst_apply, Prod.exists, exists_and_right, exists_eq_right]
state_before: case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
⊢ (∃ x_1, ∃ (h : x ∈ f.domain), ↑f ⟨x, ⋯⟩ = x_1) ↔ x ∈ f.domain
state_after: case h.mp
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
h : ∃ x_1, ∃ (h : x ∈ f.domain), ↑f ⟨x, ⋯⟩ = x_1
⊢ x ∈ f.domain

case h.mpr
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x : E
h : x ∈ f.domain
⊢ ∃ x_1, ∃ (h : x ∈ f.domain), ↑f ⟨x, ⋯⟩ = x_1
tactic: constructor <;> intro h
Theorem: rootsOfUnity.integer_power_of_ringEquiv'
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

Proof steps:
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
⊢ ∃ m, ∀ t ∈ rootsOfUnity n L, g ↑t = ↑(t ^ m)
state_after: no goals
tactic: simpa using rootsOfUnity.integer_power_of_ringEquiv n g
Theorem: Submodule.fg_restrictScalars
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R✝ : Type u_1
M✝ : Type u_2
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P : Type u_3
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
S : Type u_5
M : Type u_6
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : Algebra R S
inst✝³ : AddCommGroup M
inst✝² : Module S M
inst✝¹ : Module R M
inst✝ : IsScalarTower R S M
N : Submodule S M
hfin : N.FG
h : Surjective ⇑(algebraMap R S)
⊢ (restrictScalars R N).FG
state_after: case intro
R✝ : Type u_1
M✝ : Type u_2
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P : Type u_3
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
S : Type u_5
M : Type u_6
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : Algebra R S
inst✝³ : AddCommGroup M
inst✝² : Module S M
inst✝¹ : Module R M
inst✝ : IsScalarTower R S M
h : Surjective ⇑(algebraMap R S)
X : Finset M
⊢ (restrictScalars R (span S ↑X)).FG
tactic: obtain ⟨X, rfl⟩ := hfin
state_before: case intro
R✝ : Type u_1
M✝ : Type u_2
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P : Type u_3
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
S : Type u_5
M : Type u_6
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : Algebra R S
inst✝³ : AddCommGroup M
inst✝² : Module S M
inst✝¹ : Module R M
inst✝ : IsScalarTower R S M
h : Surjective ⇑(algebraMap R S)
X : Finset M
⊢ (restrictScalars R (span S ↑X)).FG
state_after: case h
R✝ : Type u_1
M✝ : Type u_2
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P : Type u_3
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
S : Type u_5
M : Type u_6
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : Algebra R S
inst✝³ : AddCommGroup M
inst✝² : Module S M
inst✝¹ : Module R M
inst✝ : IsScalarTower R S M
h : Surjective ⇑(algebraMap R S)
X : Finset M
⊢ span R ↑X = restrictScalars R (span S ↑X)
tactic: use X
state_before: case h
R✝ : Type u_1
M✝ : Type u_2
inst✝¹¹ : Semiring R✝
inst✝¹⁰ : AddCommMonoid M✝
inst✝⁹ : Module R✝ M✝
P : Type u_3
inst✝⁸ : AddCommMonoid P
inst✝⁷ : Module R✝ P
f : M✝ →ₗ[R✝] P
R : Type u_4
S : Type u_5
M : Type u_6
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : Algebra R S
inst✝³ : AddCommGroup M
inst✝² : Module S M
inst✝¹ : Module R M
inst✝ : IsScalarTower R S M
h : Surjective ⇑(algebraMap R S)
X : Finset M
⊢ span R ↑X = restrictScalars R (span S ↑X)
state_after: no goals
tactic: exact (Submodule.restrictScalars_span R S h (X : Set M)).symm
Theorem: LiouvilleWith.nat_sub_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑n - x) ↔ LiouvilleWith p x
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: EMetric.infEdist_le_hausdorffEdist_of_mem
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : x ∈ s
⊢ infEdist x t ≤ hausdorffEdist s t
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : x ∈ s
⊢ infEdist x t ≤ (⨆ x ∈ s, infEdist x t) ⊔ ⨆ y ∈ t, infEdist y s
tactic: rw [hausdorffEdist_def]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : x ∈ s
⊢ infEdist x t ≤ (⨆ x ∈ s, infEdist x t) ⊔ ⨆ y ∈ t, infEdist y s
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : x ∈ s
⊢ infEdist x t ≤ ⨆ x ∈ s, infEdist x t
tactic: refine le_trans ?_ le_sup_left
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
h : x ∈ s
⊢ infEdist x t ≤ ⨆ x ∈ s, infEdist x t
state_after: no goals
tactic: exact le_iSup₂ (α := ℝ≥0∞) x h