1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsNilpotent.isUnit_add_left_of_commute
File: Mathlib/RingTheory/Nilpotent/Basic.lean

tactic: rw [← Units.isUnit_mul_units _ hu.unit⁻¹, add_mul, IsUnit.mul_val_inv]
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r u
⊢ IsUnit (u + r)
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r u
⊢ IsUnit (1 + r * ↑hu.unit⁻¹)

tactic: replace h_comm : Commute r (↑hu.unit⁻¹) := Commute.units_inv_right h_comm
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r u
⊢ IsUnit (1 + r * ↑hu.unit⁻¹)
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r ↑hu.unit⁻¹
⊢ IsUnit (1 + r * ↑hu.unit⁻¹)

tactic: refine IsNilpotent.isUnit_one_add ?_
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r ↑hu.unit⁻¹
⊢ IsUnit (1 + r * ↑hu.unit⁻¹)
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r ↑hu.unit⁻¹
⊢ IsNilpotent (r * ↑hu.unit⁻¹)

tactic: exact (hu.unit⁻¹.isUnit.isNilpotent_mul_unit_of_commute_iff h_comm).mpr hnil
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r u : R
hnil : IsNilpotent r
hu : IsUnit u
h_comm : Commute r ↑hu.unit⁻¹
⊢ IsNilpotent (r * ↑hu.unit⁻¹)
state_after: no goals
Theorem: Filter.OrderIso.apply_blimsup
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq, map_sInf, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ e (blimsup u f p) = blimsup (⇑e ∘ u) f p
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ sInf (⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a}) = sInf {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ sInf (⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a}) = sInf {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}
state_after: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}

tactic: ext c
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}
state_after: case e_a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
c : γ
⊢ c ∈ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ c ∈ {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}

tactic: obtain ⟨a, rfl⟩ := e.surjective c
state_before: case e_a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
c : γ
⊢ c ∈ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ c ∈ {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}
state_after: case e_a.h.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
a : α
⊢ e a ∈ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ e a ∈ {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}

tactic: simp
state_before: case e_a.h.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
a : α
⊢ e a ∈ ⇑e '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ e a ∈ {a | ∀ᶠ (x : β) in f, p x → e (u x) ≤ a}
state_after: no goals
Theorem: Relation.cutExpand_double
File: Mathlib/Logic/Hydra.lean

tactic: simp only [insert_eq_cons, mem_cons, mem_singleton, forall_eq_or_imp, forall_eq]
state_before: α : Type u_1
r : α → α → Prop
a a₁ a₂ : α
h₁ : r a₁ a
h₂ : r a₂ a
⊢ ∀ x' ∈ {a₁, a₂}, r x' a
state_after: α : Type u_1
r : α → α → Prop
a a₁ a₂ : α
h₁ : r a₁ a
h₂ : r a₂ a
⊢ r a₁ a ∧ r a₂ a

tactic: tauto
state_before: α : Type u_1
r : α → α → Prop
a a₁ a₂ : α
h₁ : r a₁ a
h₂ : r a₂ a
⊢ r a₁ a ∧ r a₂ a
state_after: no goals
Theorem: MeasureTheory.Measure.lintegral_condKernel
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: conv_rhs => rw [← compProd_fst_condKernel ρ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω), f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel

tactic: rw [lintegral_compProd hf]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω), f x ∂ρ.fst ⊗ₘ ρ.condKernel
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.OpenCover.gluedCoverT'_snd_snd
File: Mathlib/AlgebraicGeometry/Gluing.lean

tactic: delta gluedCoverT'
state_before: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ 𝒰.gluedCoverT' x y z ≫ pullback.snd ≫ pullback.snd = pullback.fst ≫ pullback.fst
state_after: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (𝒰.map x) (𝒰.map z) pullback.fst).hom ≫
        (pullback.map (pullback.fst ≫ 𝒰.map x) (𝒰.map z) (pullback.fst ≫ 𝒰.map y) (𝒰.map z)
              (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom (𝟙 (𝒰.obj z)) (𝟙 X) ⋯ ⋯ ≫
            (pullbackRightPullbackFstIso (𝒰.map y) (𝒰.map z) pullback.fst).inv) ≫
          (pullbackSymmetry pullback.fst pullback.fst).hom) ≫
      pullback.snd ≫ pullback.snd =
    pullback.fst ≫ pullback.fst

tactic: simp
state_before: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ ((pullbackRightPullbackFstIso (𝒰.map x) (𝒰.map z) pullback.fst).hom ≫
        (pullback.map (pullback.fst ≫ 𝒰.map x) (𝒰.map z) (pullback.fst ≫ 𝒰.map y) (𝒰.map z)
              (pullbackSymmetry (𝒰.map x) (𝒰.map y)).hom (𝟙 (𝒰.obj z)) (𝟙 X) ⋯ ⋯ ≫
            (pullbackRightPullbackFstIso (𝒰.map y) (𝒰.map z) pullback.fst).inv) ≫
          (pullbackSymmetry pullback.fst pullback.fst).hom) ≫
      pullback.snd ≫ pullback.snd =
    pullback.fst ≫ pullback.fst
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: simp only [coeFn_univ, Ne, one_ne_zero, not_false_iff]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
ν : ProbabilityMeasure Ω
⊢ ν univ ≠ 0
state_after: no goals
Theorem: ModularCyclotomicCharacter.toFun_unique
File: Mathlib/NumberTheory/Cyclotomic/CyclotomicCharacter.lean

tactic: apply IsCyclic.ext rfl (fun ζ ↦ ?_)
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
hc : ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ c.val)
⊢ c = χ₀ n g
state_after: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
hc : ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ c.val)
ζ : ↥(rootsOfUnity n L)
⊢ ζ ^ c.val = ζ ^ (χ₀ n g).val

tactic: specialize hc ζ
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
hc : ∀ (t : ↥(rootsOfUnity n L)), g ↑↑t = ↑(↑t ^ c.val)
ζ : ↥(rootsOfUnity n L)
⊢ ζ ^ c.val = ζ ^ (χ₀ n g).val
state_after: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
ζ : ↥(rootsOfUnity n L)
hc : g ↑↑ζ = ↑(↑ζ ^ c.val)
⊢ ζ ^ c.val = ζ ^ (χ₀ n g).val

tactic: suffices ((ζ ^ c.val : Lˣ) : L) = (ζ ^ (χ₀ n g).val : Lˣ) by exact_mod_cast this
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
ζ : ↥(rootsOfUnity n L)
hc : g ↑↑ζ = ↑(↑ζ ^ c.val)
⊢ ζ ^ c.val = ζ ^ (χ₀ n g).val
state_after: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
ζ : ↥(rootsOfUnity n L)
hc : g ↑↑ζ = ↑(↑ζ ^ c.val)
⊢ ↑(↑ζ ^ c.val) = ↑(↑ζ ^ (χ₀ n g).val)

tactic: rw [← toFun_spec g ζ, hc]
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
ζ : ↥(rootsOfUnity n L)
hc : g ↑↑ζ = ↑(↑ζ ^ c.val)
⊢ ↑(↑ζ ^ c.val) = ↑(↑ζ ^ (χ₀ n g).val)
state_after: no goals

tactic: exact_mod_cast this
state_before: L : Type u
inst✝¹ : CommRing L
inst✝ : IsDomain L
n : ℕ+
g : L ≃+* L
c : ZMod (Fintype.card ↥(rootsOfUnity n L))
ζ : ↥(rootsOfUnity n L)
hc : g ↑↑ζ = ↑(↑ζ ^ c.val)
this : ↑(↑ζ ^ c.val) = ↑(↑ζ ^ (χ₀ n g).val)
⊢ ζ ^ c.val = ζ ^ (χ₀ n g).val
state_after: no goals
Theorem: Subalgebra.topologicalClosure_star_comm
File: Mathlib/Topology/Algebra/StarSubalgebra.lean

tactic: suffices ∀ t : Subalgebra R A, (star t).topologicalClosure ≤ star t.topologicalClosure from
  le_antisymm (this s) (by simpa only [star_star] using Subalgebra.star_mono (this (star s)))
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ (star s).topologicalClosure = star s.topologicalClosure
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ ∀ (t : Subalgebra R A), (star t).topologicalClosure ≤ star t.topologicalClosure

tactic: exact fun t => (star t).topologicalClosure_minimal (Subalgebra.star_mono subset_closure)
  (isClosed_closure.preimage continuous_star)
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ ∀ (t : Subalgebra R A), (star t).topologicalClosure ≤ star t.topologicalClosure
state_after: no goals

tactic: simpa only [star_star] using Subalgebra.star_mono (this (star s))
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
this : ∀ (t : Subalgebra R A), (star t).topologicalClosure ≤ star t.topologicalClosure
⊢ star s.topologicalClosure ≤ (star s).topologicalClosure
state_after: no goals
Theorem: ContinuousMap.inseparable_coe
File: Mathlib/Topology/CompactOpen.lean

tactic: simp only [inseparable_iff_specializes_and, specializes_coe]
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace T
K : Set X
U : Set Y
f g : C(X, Y)
⊢ Inseparable ⇑f ⇑g ↔ Inseparable f g
state_after: no goals
Theorem: Real.differentiableOn_negMulLog
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

tactic: simpa only [negMulLog_eq_neg] using differentiableOn_mul_log.neg
state_before: ⊢ DifferentiableOn ℝ negMulLog {0}ᶜ
state_after: no goals
Theorem: List.countP_true
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

tactic: rw [countP_eq_length]
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP (fun x => true) l = l.length
state_after: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → true = true

tactic: simp
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → true = true
state_after: no goals
Theorem: QuadraticForm.polar_smul_left
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: obtain ⟨B, h⟩ := Q.exists_companion
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a : R
x y : M
⊢ polar (⇑Q) (a • x) y = a * polar (⇑Q) x y
state_after: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a : R
x y : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ polar (⇑Q) (a • x) y = a * polar (⇑Q) x y

tactic: simp_rw [polar, h, Q.map_smul, LinearMap.map_smul₂, sub_sub, add_sub_cancel_left, smul_eq_mul]
state_before: case intro
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a : R
x y : M
B : BilinForm R M
h : ∀ (x y : M), Q (x + y) = Q x + Q y + (B x) y
⊢ polar (⇑Q) (a • x) y = a * polar (⇑Q) x y
state_after: no goals
Theorem: Set.ncard_diff_singleton_add_one
File: Mathlib/Data/Set/Card.lean

tactic: to_encard_tac
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard + 1 = s.ncard
state_after: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ ↑(s \ {a}).ncard + 1 = ↑s.ncard

tactic: rw [hs.cast_ncard_eq, (hs.diff _).cast_ncard_eq,
encard_diff_singleton_add_one h]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ ↑(s \ {a}).ncard + 1 = ↑s.ncard
state_after: no goals
Theorem: ContinuousMap.dist_lt_iff
File: Mathlib/Topology/ContinuousFunction/Compact.lean

tactic: rw [← dist_mkOfCompact, dist_lt_iff_of_compact C0]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
C0 : 0 < C
⊢ dist f g < C ↔ ∀ (x : α), dist (f x) (g x) < C
state_after: α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
C0 : 0 < C
⊢ (∀ (x : α), dist ((mkOfCompact f) x) ((mkOfCompact g) x) < C) ↔ ∀ (x : α), dist (f x) (g x) < C

tactic: simp only [mkOfCompact_apply]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
C0 : 0 < C
⊢ (∀ (x : α), dist ((mkOfCompact f) x) ((mkOfCompact g) x) < C) ↔ ∀ (x : α), dist (f x) (g x) < C
state_after: no goals
Theorem: IsometryEquiv.toDilationEquiv_ratio
File: Mathlib/Topology/MetricSpace/DilationEquiv.lean

tactic: rw [← ratio_toDilation, IsometryEquiv.toDilationEquiv_toDilation, Isometry.toDilation_ratio]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : PseudoEMetricSpace X
inst✝¹ : PseudoEMetricSpace Y
inst✝ : PseudoEMetricSpace Z
e : X ≃ᵢ Y
⊢ ratio e.toDilationEquiv = 1
state_after: no goals
Theorem: Cardinal.cantorFunction_succ
File: Mathlib/Data/Real/Cardinality.lean

tactic: rw [cantorFunction, tsum_eq_zero_add (summable_cantor_function f h1 h2)]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ cantorFunction c f = (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)
state_after: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ cantorFunctionAux c f 0 + ∑' (b : ℕ), cantorFunctionAux c f (b + 1) =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)

tactic: rw [cantorFunctionAux_succ, tsum_mul_left, cantorFunctionAux, _root_.pow_zero]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ cantorFunctionAux c f 0 + ∑' (b : ℕ), cantorFunctionAux c f (b + 1) =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)
state_after: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ (bif f 0 then 1 else 0) + c * ∑' (x : ℕ), cantorFunctionAux c (fun n => f (n + 1)) x =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)

tactic: rfl
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ (bif f 0 then 1 else 0) + c * ∑' (x : ℕ), cantorFunctionAux c (fun n => f (n + 1)) x =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)
state_after: no goals
Theorem: List.lookupAll_nodup
File: Mathlib/Data/List/Sigma.lean

tactic: (rw [lookupAll_eq_dlookup a h]; apply Option.toList_nodup)
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).Nodup
state_after: no goals

tactic: rw [lookupAll_eq_dlookup a h]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).Nodup
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (dlookup a l).toList.Nodup

tactic: apply Option.toList_nodup
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (dlookup a l).toList.Nodup
state_after: no goals
Theorem: Ultrafilter.le_nhds_lim
File: Mathlib/Topology/Compactness/Compact.lean

tactic: rcases isCompact_univ.ultrafilter_le_nhds F (by simp) with ⟨x, -, h⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
F : Ultrafilter X
⊢ ↑F ≤ 𝓝 F.lim
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
F : Ultrafilter X
x : X
h : ↑F ≤ 𝓝 x
⊢ ↑F ≤ 𝓝 F.lim

tactic: exact le_nhds_lim ⟨x, h⟩
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
F : Ultrafilter X
x : X
h : ↑F ≤ 𝓝 x
⊢ ↑F ≤ 𝓝 F.lim
state_after: no goals

tactic: simp
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
F : Ultrafilter X
⊢ ↑F ≤ 𝓟 univ
state_after: no goals
Theorem: IsOpen.union
File: Mathlib/Topology/Basic.lean

tactic: rw [union_eq_iUnion]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (s₁ ∪ s₂)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (⋃ b, bif b then s₁ else s₂)

tactic: exact isOpen_iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (⋃ b, bif b then s₁ else s₂)
state_after: no goals
Theorem: CategoryTheory.isCoseparator_prod_of_isCoseparator_right
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryProduct G H
hH : IsCoseparator H
⊢ {H} ⊆ {G, H}
state_after: no goals
Theorem: Homotopy.comp_nullHomotopicMap
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: ext n
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → D.X i ⟶ E.X j
⊢ f ≫ nullHomotopicMap hom = nullHomotopicMap fun i j => f.f i ≫ hom i j
state_after: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → D.X i ⟶ E.X j
n : ι
⊢ (f ≫ nullHomotopicMap hom).f n = (nullHomotopicMap fun i j => f.f i ≫ hom i j).f n

tactic: dsimp [nullHomotopicMap, fromNext, toPrev, AddMonoidHom.mk'_apply]
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → D.X i ⟶ E.X j
n : ι
⊢ (f ≫ nullHomotopicMap hom).f n = (nullHomotopicMap fun i j => f.f i ≫ hom i j).f n
state_after: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → D.X i ⟶ E.X j
n : ι
⊢ f.f n ≫ (D.dFrom n ≫ hom (c.next n) n + hom n (c.prev n) ≫ E.dTo n) =
    C.dFrom n ≫ f.f (c.next n) ≫ hom (c.next n) n + (f.f n ≫ hom n (c.prev n)) ≫ E.dTo n

tactic: simp only [Preadditive.comp_add, assoc, f.comm_assoc]
state_before: case h
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
f : C ⟶ D
hom : (i j : ι) → D.X i ⟶ E.X j
n : ι
⊢ f.f n ≫ (D.dFrom n ≫ hom (c.next n) n + hom n (c.prev n) ≫ E.dTo n) =
    C.dFrom n ≫ f.f (c.next n) ≫ hom (c.next n) n + (f.f n ≫ hom n (c.prev n)) ≫ E.dTo n
state_after: no goals
Theorem: List.next_cons_cons_eq'
File: Mathlib/Data/List/Cycle.lean

tactic: rw [next, nextOr, if_pos hx]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hx : x = y
⊢ (y :: z :: l).next x h = z
state_after: no goals
Theorem: MeasureTheory.Measure.InnerRegularWRT.measure_eq_iSup
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: refine
  le_antisymm (le_of_forall_lt fun r hr => ?_) (iSup₂_le fun K hK => iSup_le fun _ => μ.mono hK)
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
⊢ μ U = ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
r : ℝ≥0∞
hr : r < μ U
⊢ r < ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K

tactic: simpa only [lt_iSup_iff, exists_prop] using H hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
hU : q U
r : ℝ≥0∞
hr : r < μ U
⊢ r < ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
state_after: no goals