ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.haar.haarContent_self
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
⊢ (fun s => ↑((haarContent K₀).toFun s)) K₀.toCompacts = 1
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
⊢ ⟨1, ⋯⟩ = 1
tactic: simp_rw [← ENNReal.coe_one, haarContent_apply, ENNReal.coe_inj, chaar_self]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
⊢ ⟨1, ⋯⟩ = 1
state_after: no goals
tactic: rfl
Theorem: toIcoMod_neg
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (-b) = p - toIocMod hp (-a) b
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ -b - -(toIocDiv hp (-a) b • p + 1 • p) = p - (b - toIocDiv hp (-a) b • p)
tactic: simp_rw [toIcoMod, toIocMod, toIcoDiv_neg, neg_smul, add_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ -b - -(toIocDiv hp (-a) b • p + 1 • p) = p - (b - toIocDiv hp (-a) b • p)
state_after: no goals
tactic: abel
Theorem: MeasureTheory.Measure.IsEverywherePos.of_forall_exists_nhds_eq
File: Mathlib/MeasureTheory/Measure/EverywherePos.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
⊢ ν.IsEverywherePos s
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
⊢ 0 < ν n
tactic: intro x hx n hn
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
⊢ 0 < ν n
state_after: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < ν n
tactic: rcases h x hx with ⟨t, t_mem, ht⟩
state_before: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < ν n
state_after: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < ν (n ∩ t)
tactic: refine lt_of_lt_of_le ?_ (measure_mono (inter_subset_left (t := t)))
state_before: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < ν (n ∩ t)
state_after: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < μ (n ∩ t)
tactic: rw [ht (n ∩ t) inter_subset_right]
state_before: case intro.intro
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
h : ∀ x ∈ s, ∃ t ∈ 𝓝 x, ∀ u ⊆ t, ν u = μ u
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
t : Set α
t_mem : t ∈ 𝓝 x
ht : ∀ u ⊆ t, ν u = μ u
⊢ 0 < μ (n ∩ t)
state_after: no goals
tactic: exact hs x hx _ (inter_mem hn (mem_nhdsWithin_of_mem_nhds t_mem))
Theorem: monovaryOn_inv₀
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : LinearOrderedSemifield β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
hf : ∀ i ∈ s, 0 < f i
hg : ∀ i ∈ s, 0 < g i
⊢ MonovaryOn f⁻¹ g⁻¹ s ↔ MonovaryOn f g s
state_after: no goals
tactic: rw [monovaryOn_inv_left₀ hf, antivaryOn_inv_right₀ hg]
Theorem: Bool.dichotomy
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: b : Bool
⊢ b = false ∨ b = true
state_after: no goals
tactic: cases b <;> simp
Theorem: CategoryTheory.tensorRightHomEquiv_symm_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Z ⊗ Y'
⊢ (tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) = f ▷ Y ≫ (tensorRightHomEquiv X' Y Y' Z).symm g
state_after: no goals
tactic: simp [tensorRightHomEquiv]
Theorem: PFun.prodLift_fst_comp_snd_comp
File: Mathlib/Data/PFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : α →. γ
g : β →. δ
a : α × β
⊢ ∀ (b : γ × δ), b ∈ (f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) a ↔ b ∈ f.prodMap g a
state_after: no goals
tactic: simp
Theorem: Fin.tail_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
⊢ tail (cons x p) = p
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) [tail, cons]
Theorem: div_mul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = a / (b / c)
state_after: no goals
tactic: simp
Theorem: WithBot.unbot'_zero_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : a = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : ¬a = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b
tactic: by_cases ha : a = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : ¬a = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : ¬a = 0
hb : b = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : ¬a = 0
hb : ¬b = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b
tactic: by_cases hb : b = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
ha : ¬a = 0
hb : ¬b = 0
⊢ unbot' 0 (a * b) = unbot' 0 a * unbot' 0 b
state_after: case neg.bot
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithBot α
hb : ¬b = 0
ha : ¬⊥ = 0
⊢ unbot' 0 (⊥ * b) = unbot' 0 ⊥ * unbot' 0 b

case neg.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithBot α
hb : ¬b = 0
a✝ : α
ha : ¬↑a✝ = 0
⊢ unbot' 0 (↑a✝ * b) = unbot' 0 ↑a✝ * unbot' 0 b
tactic: induction a
state_before: case neg.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithBot α
hb : ¬b = 0
a✝ : α
ha : ¬↑a✝ = 0
⊢ unbot' 0 (↑a✝ * b) = unbot' 0 ↑a✝ * unbot' 0 b
state_after: case neg.coe.bot
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
a✝ : α
ha : ¬↑a✝ = 0
hb : ¬⊥ = 0
⊢ unbot' 0 (↑a✝ * ⊥) = unbot' 0 ↑a✝ * unbot' 0 ⊥

case neg.coe.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
a✝¹ : α
ha : ¬↑a✝¹ = 0
a✝ : α
hb : ¬↑a✝ = 0
⊢ unbot' 0 (↑a✝¹ * ↑a✝) = unbot' 0 ↑a✝¹ * unbot' 0 ↑a✝
tactic: induction b
state_before: case neg.coe.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
a✝¹ : α
ha : ¬↑a✝¹ = 0
a✝ : α
hb : ¬↑a✝ = 0
⊢ unbot' 0 (↑a✝¹ * ↑a✝) = unbot' 0 ↑a✝¹ * unbot' 0 ↑a✝
state_after: no goals
tactic: rw [← coe_mul, unbot'_coe, unbot'_coe, unbot'_coe]
Theorem: AlgebraicGeometry.opensRestrict_symm_apply_coe
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
⊢ (fun U_1 => U_1 ≤ Scheme.Hom.opensRange U.ι) = fun V => V ≤ U
state_after: no goals
tactic: simp
Theorem: smul_preimage_set_leₛₗ
File: Mathlib/GroupTheory/GroupAction/Pointwise.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₁ : Type u_4
M₂ : Type u_5
N : Type u_6
inst✝⁷ : Monoid R
inst✝⁶ : Monoid S
σ : R → S
inst✝⁵ : MulAction R M
inst✝⁴ : MulAction S N
inst✝³ : MulAction R M₁
inst✝² : MulAction R M₂
F : Type u_7
h : F
inst✝¹ : FunLike F M N
inst✝ : MulActionSemiHomClass F σ M N
c : R
s : Set M
t : Set N
⊢ c • ⇑h ⁻¹' t ⊆ ⇑h ⁻¹' (σ c • t)
state_after: case intro.intro
R : Type u_1
S : Type u_2
M : Type u_3
M₁ : Type u_4
M₂ : Type u_5
N : Type u_6
inst✝⁷ : Monoid R
inst✝⁶ : Monoid S
σ : R → S
inst✝⁵ : MulAction R M
inst✝⁴ : MulAction S N
inst✝³ : MulAction R M₁
inst✝² : MulAction R M₂
F : Type u_7
h : F
inst✝¹ : FunLike F M N
inst✝ : MulActionSemiHomClass F σ M N
c : R
s : Set M
t : Set N
y : M
hy : y ∈ ⇑h ⁻¹' t
⊢ (fun x => c • x) y ∈ ⇑h ⁻¹' (σ c • t)
tactic: rintro x ⟨y, hy, rfl⟩
state_before: case intro.intro
R : Type u_1
S : Type u_2
M : Type u_3
M₁ : Type u_4
M₂ : Type u_5
N : Type u_6
inst✝⁷ : Monoid R
inst✝⁶ : Monoid S
σ : R → S
inst✝⁵ : MulAction R M
inst✝⁴ : MulAction S N
inst✝³ : MulAction R M₁
inst✝² : MulAction R M₂
F : Type u_7
h : F
inst✝¹ : FunLike F M N
inst✝ : MulActionSemiHomClass F σ M N
c : R
s : Set M
t : Set N
y : M
hy : y ∈ ⇑h ⁻¹' t
⊢ (fun x => c • x) y ∈ ⇑h ⁻¹' (σ c • t)
state_after: no goals
tactic: exact ⟨h y, hy, by rw [map_smulₛₗ]⟩
Theorem: Computation.parallel_empty
File: Mathlib/Data/Seq/Parallel.lean

Proof steps:
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
⊢ False
state_after: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
⊢ False
tactic: let ⟨c, cs, _⟩ := exists_of_mem_parallel m
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
⊢ False
state_after: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ S.get? n
⊢ False
tactic: let ⟨n, nm⟩ := WSeq.exists_get?_of_mem cs
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ S.get? n
⊢ False
state_after: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ S.get? n
c' : Computation α
h' : some c' ∈ S.head
⊢ False
tactic: let ⟨c', h'⟩ := WSeq.head_some_of_get?_some nm
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
h : S.head ~> none
x✝ : (parallel S).Terminates
a : α
m : a ∈ parallel S
c : Computation α
cs : c ∈ S
right✝ : a ∈ c
n : ℕ
nm : some c ∈ S.get? n
c' : Computation α
h' : some c' ∈ S.head
⊢ False
state_after: no goals
tactic: injection h h'
Theorem: Basis.algebraMapCoeffs_repr_apply_toFun
File: Mathlib/RingTheory/AlgebraTower.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
ι : Type u_1
M : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : AddCommMonoid M
inst✝³ : Algebra R A
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
b : Basis ι R M
h : Function.Bijective ⇑(algebraMap R A)
c : R
x : M
⊢ (RingEquiv.ofBijective (algebraMap R A) h) c • x = c • x
state_after: no goals
tactic: simp
Theorem: upperClosure_singleton
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a : α
⊢ upperClosure {a} = UpperSet.Ici a
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a x✝ : α
⊢ x✝ ∈ ↑(upperClosure {a}) ↔ x✝ ∈ ↑(UpperSet.Ici a)
tactic: ext
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a x✝ : α
⊢ x✝ ∈ ↑(upperClosure {a}) ↔ x✝ ∈ ↑(UpperSet.Ici a)
state_after: no goals
tactic: simp
Theorem: ContinuousLinearEquiv.comp_right_hasFDerivAt_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
x : E
f' : E →L[𝕜] G
⊢ HasFDerivAt (f ∘ ⇑iso) f' x ↔ HasFDerivAt f (f'.comp ↑iso.symm) (iso x)
state_after: no goals
tactic: simp only [← hasFDerivWithinAt_univ, ← iso.comp_right_hasFDerivWithinAt_iff', preimage_univ]
Theorem: Nat.le_minFac'
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ m n : ℕ
h : n = 1 ∨ m ≤ n.minFac
p : ℕ
pp : 1 < p
d : p ∣ n
⊢ n = 1 → m ≤ p
state_after: n m p : ℕ
pp : 1 < p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ m ≤ p
tactic: rintro rfl
state_before: n m p : ℕ
pp : 1 < p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ m ≤ p
state_after: no goals
tactic: cases not_le_of_lt pp (le_of_dvd (by decide) d)
Theorem: ContinuousMap.subalgebra_topologicalClosure_eq_top_of_separatesPoints
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
⊢ A.topologicalClosure = ⊤
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
⊢ ↑A.topologicalClosure = ↑⊤
tactic: apply SetLike.ext'
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
⊢ ↑A.topologicalClosure = ↑⊤
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
⊢ ↑A.topologicalClosure = ↑⊤
tactic: let L := A.topologicalClosure
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
⊢ ↑A.topologicalClosure = ↑⊤
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
n : (↑L).Nonempty
⊢ ↑A.topologicalClosure = ↑⊤
tactic: have n : Set.Nonempty (L : Set C(X, ℝ)) := ⟨(1 : C(X, ℝ)), A.le_topologicalClosure A.one_mem⟩
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
n : (↑L).Nonempty
⊢ ↑A.topologicalClosure = ↑⊤
state_after: case h.e'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
n : (↑L).Nonempty
⊢ ↑A.topologicalClosure = closure ↑L
tactic: convert
    sublattice_closure_eq_top (L : Set C(X, ℝ)) n
      (fun f fm g gm => inf_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
      (fun f fm g gm => sup_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
      (Subalgebra.SeparatesPoints.strongly
        (Subalgebra.separatesPoints_monotone A.le_topologicalClosure w))
state_before: case h.e'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
L : Subalgebra ℝ C(X, ℝ) := A.topologicalClosure
n : (↑L).Nonempty
⊢ ↑A.topologicalClosure = closure ↑L
state_after: no goals
tactic: simp [L]
Theorem: Substring.Valid.get
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h : x✝.Valid
e : x✝.toString.data = m₁ ++ c :: m₂
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
state_after: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁ ++ c :: m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
e : x✝.toString.data = m₁ ++ c :: m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
state_after: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ c :: m₂
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
tactic: simp only [h.toString] at e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ c :: m₂
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
state_after: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁ ++ c :: m₂) r x✝
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
tactic: subst e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : x✝.Valid
l r : List Char
h : ValidFor l (m₁ ++ c :: m₂) r x✝
⊢ x✝.get { byteIdx := utf8Len m₁ } = c
state_after: no goals
tactic: simp [h.get]
Theorem: Polynomial.card_roots_sub_C
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p - C a).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p + C (-a)).degree = p.degree
tactic: rw [sub_eq_add_neg, ← C_neg]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p + C (-a)).degree = p.degree
state_after: no goals
tactic: exact degree_add_C hp0
Theorem: QuaternionAlgebra.coe_mul
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ ↑(x * y) = ↑x * ↑y
state_after: no goals
tactic: ext <;> simp
Theorem: AddSubgroup.normal_add
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝² : Group G
inst✝¹ : AddGroup A
s : Set G
N H : Subgroup G
inst✝ : N.Normal
⊢ ↑(N ⊔ H) = ↑N * ↑H
state_after: no goals
tactic: rw [← set_mul_normal_comm, sup_comm, mul_normal]
Theorem: dist_add_dist_eq_iff
File: Mathlib/Analysis/Convex/StrictConvexBetween.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c : P
⊢ dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c : P
this : dist (a -ᵥ a) (b -ᵥ a) + dist (b -ᵥ a) (c -ᵥ a) = dist (a -ᵥ a) (c -ᵥ a) ↔ b -ᵥ a ∈ [a -ᵥ a-[ℝ]c -ᵥ a]
⊢ dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c
tactic: have :
      dist (a -ᵥ a) (b -ᵥ a) + dist (b -ᵥ a) (c -ᵥ a) = dist (a -ᵥ a) (c -ᵥ a) ↔
        b -ᵥ a ∈ segment ℝ (a -ᵥ a) (c -ᵥ a) := by
    simp only [mem_segment_iff_sameRay, sameRay_iff_norm_add, dist_eq_norm', sub_add_sub_cancel',
      eq_comm]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c : P
this : dist (a -ᵥ a) (b -ᵥ a) + dist (b -ᵥ a) (c -ᵥ a) = dist (a -ᵥ a) (c -ᵥ a) ↔ b -ᵥ a ∈ [a -ᵥ a-[ℝ]c -ᵥ a]
⊢ dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c : P
this : dist a b + dist b c = dist a c ↔ b -ᵥ a ∈ (fun x => x -ᵥ a) '' affineSegment ℝ a c
⊢ dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c
tactic: simp_rw [dist_vsub_cancel_right, ← affineSegment_eq_segment, ← affineSegment_vsub_const_image]
    at this
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : NormedSpace ℝ V
inst✝² : StrictConvexSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c : P
this : dist a b + dist b c = dist a c ↔ b -ᵥ a ∈ (fun x => x -ᵥ a) '' affineSegment ℝ a c
⊢ dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c
state_after: no goals
tactic: rwa [(vsub_left_injective _).mem_set_image] at this
Theorem: cauchySeq_of_edist_le_of_tsum_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
hd : tsum d ≠ ⊤
⊢ CauchySeq f
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : ∑' (i : ℕ), ↑(d i) ≠ ⊤
⊢ CauchySeq f
tactic: lift d to ℕ → NNReal using fun i => ENNReal.ne_top_of_tsum_ne_top hd i
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : ∑' (i : ℕ), ↑(d i) ≠ ⊤
⊢ CauchySeq f
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable d
⊢ CauchySeq f
tactic: rw [ENNReal.tsum_coe_ne_top_iff_summable] at hd
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ (fun i => ↑(d i)) n
hd : Summable d
⊢ CauchySeq f
state_after: no goals
tactic: exact cauchySeq_of_edist_le_of_summable d hf hd
Theorem: tprod_empty
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a a₁ a₂ : α
inst✝ : IsEmpty β
⊢ ∏' (b : β), f b = 1
state_after: no goals
tactic: rw [tprod_eq_prod (s := (∅ : Finset β))] <;> simp