ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isOpen_singleton_of_finite_mem_nhds
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
⊢ IsOpen {x}
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
⊢ IsOpen {x}
tactic: have A : {x} ⊆ s := by simp only [singleton_subset_iff, mem_of_mem_nhds hs]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
⊢ IsOpen {x}
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
⊢ IsOpen {x}
tactic: have B : IsClosed (s \ {x}) := (hsf.subset diff_subset).isClosed
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
⊢ IsOpen {x}
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
⊢ IsOpen {x}
tactic: have C : (s \ {x})ᶜ ∈ 𝓝 x := B.isOpen_compl.mem_nhds fun h => h.2 rfl
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
⊢ IsOpen {x}
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
D : {x} ∈ 𝓝 x
⊢ IsOpen {x}
tactic: have D : {x} ∈ 𝓝 x := by simpa only [← diff_eq, diff_diff_cancel_left A] using inter_mem hs C
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s : Set X
hs : s ∈ 𝓝 x
hsf : s.Finite
A : {x} ⊆ s
B : IsClosed (s \ {x})
C : (s \ {x})ᶜ ∈ 𝓝 x
D : {x} ∈ 𝓝 x
⊢ IsOpen {x}
state_after: no goals
tactic: rwa [← mem_interior_iff_mem_nhds, ← singleton_subset_iff, subset_interior_iff_isOpen] at D
Theorem: Matroid.exists_basis_inter_ground_basis_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
M : Matroid α
X : Set α
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
state_after: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
tactic: obtain ⟨I, hI⟩ := M.exists_basis (X ∩ M.E)
state_before: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
state_after: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
hI' : M.Basis I (M.closure (X ∩ M.E))
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
tactic: have hI' := hI.basis_closure_right
state_before: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
hI' : M.Basis I (M.closure (X ∩ M.E))
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
state_after: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
hI' : M.Basis I (M.closure X)
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
tactic: rw [closure_inter_ground] at hI'
state_before: case intro
ι✝ : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
ι : Sort u_3
I✝ J B : Set α
f x y : α
M : Matroid α
X I : Set α
hI : M.Basis I (X ∩ M.E)
hI' : M.Basis I (M.closure X)
⊢ ∃ I, M.Basis I (X ∩ M.E) ∧ M.Basis I (M.closure X)
state_after: no goals
tactic: exact ⟨_, hI, hI'⟩
Theorem: Homeomorph.self_trans_symm
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'
h : X ≃ₜ Y
⊢ h.trans h.symm = Homeomorph.refl X
state_after: case H
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'
h : X ≃ₜ Y
x✝ : X
⊢ (h.trans h.symm) x✝ = (Homeomorph.refl X) x✝
tactic: ext
state_before: case H
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'
h : X ≃ₜ Y
x✝ : X
⊢ (h.trans h.symm) x✝ = (Homeomorph.refl X) x✝
state_after: no goals
tactic: apply symm_apply_apply
Theorem: Set.toFinset_image
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : DecidableEq β
f : α → β
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑(f '' s)
⊢ ↑(f '' s).toFinset = ↑(Finset.image f s.toFinset)
state_after: no goals
tactic: simp
Theorem: AddLECancellable.lt_of_tsub_lt_tsub_left_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁶ : AddCommSemigroup α
inst✝⁵ : PartialOrder α
inst✝⁴ : ExistsAddOfLE α
inst✝³ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : AddLECancellable b
hca : c ≤ a
h : a - b < a - c
⊢ c < b
state_after: α : Type u_1
inst✝⁶ : AddCommSemigroup α
inst✝⁵ : PartialOrder α
inst✝⁴ : ExistsAddOfLE α
inst✝³ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : AddLECancellable b
hca : c ≤ a
h : a - c + c - b < a - c
⊢ c < b
tactic: conv_lhs at h => rw [← tsub_add_cancel_of_le hca]
state_before: α : Type u_1
inst✝⁶ : AddCommSemigroup α
inst✝⁵ : PartialOrder α
inst✝⁴ : ExistsAddOfLE α
inst✝³ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : AddLECancellable b
hca : c ≤ a
h : a - c + c - b < a - c
⊢ c < b
state_after: no goals
tactic: exact lt_of_add_lt_add_left (hb.lt_add_of_tsub_lt_right h)
Theorem: Function.Injective.injective_linearMapComp_left
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : Semiring R₁
inst✝⁶ : Semiring R₂
inst✝⁵ : Semiring R₃
inst✝⁴ : AddCommMonoid M
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : AddCommMonoid M₃
module_M₁ : Module R₁ M₁
module_M₂ : Module R₂ M₂
module_M₃ : Module R₃ M₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f : M₂ →ₛₗ[σ₂₃] M₃
g : M₁ →ₛₗ[σ₁₂] M₂
f' : M₂ →ₛₗ[σ₂₃] M₃
g' : M₁ →ₛₗ[σ₁₂] M₂
hf : Injective ⇑f
g₁ g₂ : M₁ →ₛₗ[σ₁₂] M₂
h : f.comp g₁ = f.comp g₂
x : M₁
⊢ f (g₁ x) = f (g₂ x)
state_after: no goals
tactic: rw [← comp_apply, h, comp_apply]
Theorem: Set.biUnion_pair
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
a b : α
s : α → Set β
⊢ ⋃ x ∈ {a, b}, s x = s a ∪ s b
state_after: no goals
tactic: simp
Theorem: AddMonoidHom.map_addCyclic
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h : IsCyclic G
σ : G →* G
⊢ ∃ m, ∀ (g : G), σ g = g ^ m
state_after: case intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
⊢ ∃ m, ∀ (g : G), σ g = g ^ m
tactic: obtain ⟨h, hG⟩ := IsCyclic.exists_generator (α := G)
state_before: case intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
⊢ ∃ m, ∀ (g : G), σ g = g ^ m
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
⊢ ∃ m, ∀ (g : G), σ g = g ^ m
tactic: obtain ⟨m, hm⟩ := hG (σ h)
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
⊢ ∃ m, ∀ (g : G), σ g = g ^ m
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
g : G
⊢ σ g = g ^ m
tactic: refine ⟨m, fun g => ?_⟩
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
g : G
⊢ σ g = g ^ m
state_after: case intro.intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
n : ℤ
⊢ σ ((fun x => h ^ x) n) = (fun x => h ^ x) n ^ m
tactic: obtain ⟨n, rfl⟩ := hG g
state_before: case intro.intro.intro
α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
h✝ : IsCyclic G
σ : G →* G
h : G
hG : ∀ (x : G), x ∈ zpowers h
m : ℤ
hm : (fun x => h ^ x) m = σ h
n : ℤ
⊢ σ ((fun x => h ^ x) n) = (fun x => h ^ x) n ^ m
state_after: no goals
tactic: rw [MonoidHom.map_zpow, ← hm, ← zpow_mul, ← zpow_mul']
Theorem: MeasureTheory.FiniteMeasure.mass_zero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
⊢ μ.mass = 0 ↔ μ = 0
state_after: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ μ = 0
tactic: refine ⟨fun μ_mass => ?_, fun hμ => by simp only [hμ, zero_mass]⟩
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ μ = 0
state_after: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ ↑μ = ↑0
tactic: apply toMeasure_injective
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ ↑μ = ↑0
state_after: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ ↑μ univ = 0
tactic: apply Measure.measure_univ_eq_zero.mp
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : μ.mass = 0
⊢ ↑μ univ = 0
state_after: no goals
tactic: rwa [← ennreal_mass, ENNReal.coe_eq_zero]
Theorem: MeasureTheory.tendstoInMeasure_iff_norm
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : SeminormedAddCommGroup E
l : Filter ι
f : ι → α → E
g : α → E
⊢ TendstoInMeasure μ f l g ↔ ∀ (ε : ℝ), 0 < ε → Tendsto (fun i => μ {x | ε ≤ ‖f i x - g x‖}) l (𝓝 0)
state_after: no goals
tactic: simp_rw [TendstoInMeasure, dist_eq_norm]
Theorem: Finite.bddBelow_range
File: Mathlib/Data/Fintype/Order.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
⊢ BddBelow (Set.range f)
state_after: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
⊢ BddBelow (Set.range f)
tactic: obtain ⟨M, hM⟩ := Finite.exists_ge f
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
⊢ BddBelow (Set.range f)
state_after: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
a : α
ha : a ∈ Set.range f
⊢ M ≤ a
tactic: refine ⟨M, fun a ha => ?_⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
a : α
ha : a ∈ Set.range f
⊢ M ≤ a
state_after: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
b : β
⊢ M ≤ f b
tactic: obtain ⟨b, rfl⟩ := ha
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
inst✝⁵ : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝⁴ : Nonempty γ
f✝ : γ → α
inst✝³ : Finite β
inst✝² : Nonempty α
inst✝¹ : Preorder α
inst✝ : IsDirected α fun x x_1 => x ≥ x_1
f : β → α
M : α
hM : ∀ (i : β), M ≤ f i
b : β
⊢ M ≤ f b
state_after: no goals
tactic: exact hM b
Theorem: Set.image_id'
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t s : Set α
⊢ (fun x => x) '' s = s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t s : Set α
x✝ : α
⊢ x✝ ∈ (fun x => x) '' s ↔ x✝ ∈ s
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t s : Set α
x✝ : α
⊢ x✝ ∈ (fun x => x) '' s ↔ x✝ ∈ s
state_after: no goals
tactic: simp
Theorem: TopologicalSpace.IsSeparable.mono
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ s u : Set α
hs : IsSeparable s
hu : u ⊆ s
⊢ IsSeparable u
state_after: case intro.intro
α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ s u : Set α
hu : u ⊆ s
c : Set α
c_count : c.Countable
hs : s ⊆ closure c
⊢ IsSeparable u
tactic: rcases hs with ⟨c, c_count, hs⟩
state_before: case intro.intro
α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ s u : Set α
hu : u ⊆ s
c : Set α
c_count : c.Countable
hs : s ⊆ closure c
⊢ IsSeparable u
state_after: no goals
tactic: exact ⟨c, c_count, hu.trans hs⟩
Theorem: Nat.Upto.wf
File: Mathlib/Data/Nat/Upto.lean

Proof steps:
state_before: p : ℕ → Prop
x : ℕ
h : p x
⊢ Upto.GT p = InvImage (fun x x_1 => x < x_1) fun y => x - ↑y
state_after: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ Upto.GT p ⟨a, ha⟩ ⟨b, property✝⟩ ↔ InvImage (fun x x_1 => x < x_1) (fun y => x - ↑y) ⟨a, ha⟩ ⟨b, property✝⟩
tactic: ext ⟨a, ha⟩ ⟨b, _⟩
state_before: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ Upto.GT p ⟨a, ha⟩ ⟨b, property✝⟩ ↔ InvImage (fun x x_1 => x < x_1) (fun y => x - ↑y) ⟨a, ha⟩ ⟨b, property✝⟩
state_after: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ a > b ↔ x - a < x - b
tactic: dsimp [InvImage, Upto.GT]
state_before: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ a > b ↔ x - a < x - b
state_after: no goals
tactic: rw [tsub_lt_tsub_iff_left_of_le (le_of_not_lt fun h' => ha _ h' h)]
Theorem: CategoryTheory.ComposableArrows.homMk₀_app
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.61690, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 0
f : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯
i : ℕ
hi : i < 0
⊢ F.map' i (i + 1) ⋯ hi ≫
      (fun i =>
          match i with
          | ⟨0, isLt⟩ => f)
        ⟨i + 1, ⋯⟩ =
    (fun i =>
          match i with
          | ⟨0, isLt⟩ => f)
        ⟨i, ⋯⟩ ≫
      G.map' i (i + 1) ⋯ hi
state_after: no goals
tactic: simp at hi
Theorem: IsLeftRegular.pow_iff
File: Mathlib/Algebra/Regular/Pow.lean

Proof steps:
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n) ↔ IsLeftRegular a
state_after: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n) → IsLeftRegular a
tactic: refine ⟨?_, IsLeftRegular.pow n⟩
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n) → IsLeftRegular a
state_after: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n.pred * a) → IsLeftRegular a
tactic: rw [← Nat.succ_pred_eq_of_pos n0, pow_succ]
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
n0 : 0 < n
⊢ IsLeftRegular (a ^ n.pred * a) → IsLeftRegular a
state_after: no goals
tactic: exact IsLeftRegular.of_mul
Theorem: CategoryTheory.Limits.isoZeroBiprod_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ biprod.snd ≫ biprod.inr = 𝟙 (X ⊞ Y)
state_after: case h₀
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ 0 = biprod.fst
tactic: apply CategoryTheory.Limits.biprod.hom_ext <;>
      simp only [Category.assoc, biprod.inr_snd, Category.comp_id, Category.id_comp, biprod.inr_fst,
        comp_zero]
state_before: case h₀
J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
hY : IsZero X
⊢ 0 = biprod.fst
state_after: no goals
tactic: apply hY.eq_of_tgt
Theorem: MonoidAlgebra.mem_span_support
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : MulOneClass G
f : MonoidAlgebra k G
⊢ f ∈ Submodule.span k (⇑(of k G) '' ↑f.support)
state_after: no goals
tactic: erw [of, MonoidHom.coe_mk, ← supported_eq_span_single, Finsupp.mem_supported]
Theorem: CategoryTheory.Limits.MonoCoprod.mk'
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : ∀ (A B : C), ∃ c x, Mono c.inl
A B : C
c' : BinaryCofan A B
hc' : IsColimit c'
⊢ Mono c'.inl
state_after: case intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : ∀ (A B : C), ∃ c x, Mono c.inl
A B : C
c' : BinaryCofan A B
hc' : IsColimit c'
c : BinaryCofan A B
hc₁ : IsColimit c
hc₂ : Mono c.inl
⊢ Mono c'.inl
tactic: obtain ⟨c, hc₁, hc₂⟩ := h A B
state_before: case intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
h : ∀ (A B : C), ∃ c x, Mono c.inl
A B : C
c' : BinaryCofan A B
hc' : IsColimit c'
c : BinaryCofan A B
hc₁ : IsColimit c
hc₂ : Mono c.inl
⊢ Mono c'.inl
state_after: no goals
tactic: simpa only [mono_inl_iff hc' hc₁] using hc₂
Theorem: CategoryTheory.Iso.inv_hom_id_triangle_hom₃
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasShift C ℤ
T₁ T₂ T₃ A B : Triangle C
e : A ≅ B
⊢ e.inv.hom₃ ≫ e.hom.hom₃ = 𝟙 B.obj₃
state_after: no goals
tactic: rw [← comp_hom₃, e.inv_hom_id, id_hom₃]
Theorem: csSup_div
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddAbove s
ht₀ : t.Nonempty
ht₁ : BddBelow t
⊢ sSup (s / t) = sSup s / sInf t
state_after: no goals
tactic: rw [div_eq_mul_inv, csSup_mul hs₀ hs₁ ht₀.inv ht₁.inv, csSup_inv ht₀ ht₁, div_eq_mul_inv]
Theorem: EReal.sign_coe
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ
⊢ sign ↑x = sign x
state_after: no goals
tactic: simp only [sign, OrderHom.coe_mk, EReal.coe_pos, EReal.coe_neg']
Theorem: CategoryTheory.PreservesImage.hom_comp_map_image_ι
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
⊢ (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f)
state_after: no goals
tactic: rw [iso_hom, image.lift_fac]
Theorem: CategoryTheory.BinaryCofan.isVanKampen_iff
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

Proof steps:
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.265560, u_1} K
D : Type u_2
inst✝ : Category.{?u.265567, u_2} D
X Y : C
c : BinaryCofan X Y
⊢ IsVanKampenColimit c ↔
    ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ c.inl = c'.inl ≫ f →
        αY ≫ c.inr = c'.inr ≫ f →
          (Nonempty (IsColimit c') ↔ IsPullback c'.inl αX f c.inl ∧ IsPullback c'.inr αY f c.inr)
state_after: case mp
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.265560, u_1} K
D : Type u_2
inst✝ : Category.{?u.265567, u_2} D
X Y : C
c : BinaryCofan X Y
⊢ IsVanKampenColimit c →
    ∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ c.inl = c'.inl ≫ f →
        αY ≫ c.inr = c'.inr ≫ f →
          (Nonempty (IsColimit c') ↔ IsPullback c'.inl αX f c.inl ∧ IsPullback c'.inr αY f c.inr)

case mpr
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.265560, u_1} K
D : Type u_2
inst✝ : Category.{?u.265567, u_2} D
X Y : C
c : BinaryCofan X Y
⊢ (∀ {X' Y' : C} (c' : BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
      αX ≫ c.inl = c'.inl ≫ f →
        αY ≫ c.inr = c'.inr ≫ f →
          (Nonempty (IsColimit c') ↔ IsPullback c'.inl αX f c.inl ∧ IsPullback c'.inr αY f c.inr)) →
    IsVanKampenColimit c
tactic: constructor
Theorem: IsAddUnit.zero_sub_add_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit a
⊢ 1 / a * a = 1
state_after: no goals
tactic: simp [h]