tasksource/leandojo huggingface dataset:
Theorem: Bornology.isVonNBounded_iff_smul_tendsto_zero
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: exact hε self_mem_nhdsWithin
state_before: 𝕜 : Type ?u.186478
𝕜' : Type ?u.186481
E : Type u_3
E' : Type ?u.186487
F : Type ?u.186490
ι : Type u_1
𝕝 : Type u_2
inst✝⁷ : NormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕝
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : Module 𝕝 E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousSMul 𝕝 E
ε : ι → 𝕝
l : Filter ι
inst✝ : NeBot l
hε : Tendsto ε l (𝓝[{0}ᶜ] 0)
S : Set E
⊢ ∀ᶠ (n : ι) in l, ε n ≠ 0
Theorem: And.comm
File: src/lean/Init/Core.lean

tactic: constructor <;> intro ⟨h₁, h₂⟩ <;> exact ⟨h₂, h₁⟩
state_before: a b c d : Prop
⊢ a ∧ b ↔ b ∧ a
Theorem: sdiff_eq_bot_iff
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← le_bot_iff, sdiff_le_iff, sup_bot_eq]
state_before: ι : Type ?u.93631
α : Type u_1
β : Type ?u.93637
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ b = ⊥ ↔ a ≤ b
Theorem: integral_sin_sq_mul_cos
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have := @integral_sin_pow_mul_cos_pow_odd a b 2 0
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x ^ 2 * cos x) = (sin b ^ 3 - sin a ^ 3) / 3

tactic: norm_num at this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, sin x ^ 2 * cos x ^ (2 * 0 + 1)) = ∫ (u : ℝ) in sin a..sin b, u ^ 2 * (1 - u ^ 2) ^ 0
⊢ (∫ (x : ℝ) in a..b, sin x ^ 2 * cos x) = (sin b ^ 3 - sin a ^ 3) / 3

tactic: exact this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, sin x ^ 2 * cos x) = (sin b ^ 3 - sin a ^ 3) / 3
⊢ (∫ (x : ℝ) in a..b, sin x ^ 2 * cos x) = (sin b ^ 3 - sin a ^ 3) / 3
Theorem: MeasureTheory.Measure.snd_apply
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [snd, Measure.map_apply measurable_snd hs]
state_before: α : Type u_2
α' : Type ?u.5372563
β : Type u_1
β' : Type ?u.5372569
γ : Type ?u.5372572
E : Type ?u.5372575
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
ρ : Measure (α × β)
s : Set β
hs : MeasurableSet s
⊢ ↑↑(snd ρ) s = ↑↑ρ (Prod.snd ⁻¹' s)
Theorem: Real.sign_neg
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ sign (-r) = -sign r

tactic: rw [sign_of_neg hn, sign_of_pos (neg_pos.mpr hn), neg_neg]
state_before: case inl
r : ℝ
hn : r < 0
⊢ sign (-r) = -sign r

tactic: rw [sign_zero, neg_zero, sign_zero]
state_before: case inr.inl

⊢ sign (-0) = -sign 0

tactic: rw [sign_of_pos hp, sign_of_neg (neg_lt_zero.mpr hp)]
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ sign (-r) = -sign r
Theorem: Seminorm.ball_finset_sup_eq_iInter
File: Mathlib/Analysis/Seminorm.lean

tactic: lift r to NNReal using hr.le
state_before: R : Type ?u.1073638
R' : Type ?u.1073641
𝕜 : Type u_1
𝕜₂ : Type ?u.1073647
𝕜₃ : Type ?u.1073650
𝕝 : Type ?u.1073653
E : Type u_2
E₂ : Type ?u.1073659
E₃ : Type ?u.1073662
F : Type ?u.1073665
G : Type ?u.1073668
ι : Type u_3
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ : Seminorm 𝕜 E
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
r : ℝ
hr : 0 < r
⊢ ball (Finset.sup s p) x r = ⋂ (i : ι) (_ : i ∈ s), ball (p i) x r

tactic: simp_rw [ball, iInter_setOf, finset_sup_apply, NNReal.coe_lt_coe,
  Finset.sup_lt_iff (show ⊥ < r from hr), ← NNReal.coe_lt_coe, coe_mk]
state_before: case intro
R : Type ?u.1073638
R' : Type ?u.1073641
𝕜 : Type u_1
𝕜₂ : Type ?u.1073647
𝕜₃ : Type ?u.1073650
𝕝 : Type ?u.1073653
E : Type u_2
E₂ : Type ?u.1073659
E₃ : Type ?u.1073662
F : Type ?u.1073665
G : Type ?u.1073668
ι : Type u_3
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ : Seminorm 𝕜 E
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
r : ℝ≥0
hr : 0 < ↑r
⊢ ball (Finset.sup s p) x ↑r = ⋂ (i : ι) (_ : i ∈ s), ball (p i) x ↑r
Theorem: Filter.HasBasis.equicontinuousAt_iff_left
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [equicontinuousAt_iff_continuousAt, ContinuousAt,
  hX.tendsto_iff (UniformFun.hasBasis_nhds ι α _)]
state_before: ι : Type u_3
κ✝ : Type ?u.121547
X : Type u_2
Y : Type ?u.121553
Z : Type ?u.121556
α : Type u_4
β : Type ?u.121562
γ : Type ?u.121565
𝓕 : Type ?u.121568
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : HasBasis (𝓝 x₀) p s
⊢ EquicontinuousAt F x₀ ↔ ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x : X), x ∈ s k → ∀ (i : ι), (F i x₀, F i x) ∈ U

tactic: simp only [Function.comp_apply, mem_setOf_eq, exists_prop]
state_before: ι : Type u_3
κ✝ : Type ?u.121547
X : Type u_2
Y : Type ?u.121553
Z : Type ?u.121556
α : Type u_4
β : Type ?u.121562
γ : Type ?u.121565
𝓕 : Type ?u.121568
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : HasBasis (𝓝 x₀) p s
⊢ (∀ (ib : Set (α × α)),
      ib ∈ 𝓤 α →
        ∃ ia,
          p ia ∧
            ∀ (x : X),
              x ∈ s ia →
                (↑UniformFun.ofFun ∘ Function.swap F) x ∈
                  {g | ((↑UniformFun.ofFun ∘ Function.swap F) x₀, g) ∈ UniformFun.gen ι α ib}) ↔
    ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x : X), x ∈ s k → ∀ (i : ι), (F i x₀, F i x) ∈ U

tactic: rfl
state_before: ι : Type u_3
κ✝ : Type ?u.121547
X : Type u_2
Y : Type ?u.121553
Z : Type ?u.121556
α : Type u_4
β : Type ?u.121562
γ : Type ?u.121565
𝓕 : Type ?u.121568
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : HasBasis (𝓝 x₀) p s
⊢ (∀ (ib : Set (α × α)),
      ib ∈ 𝓤 α →
        ∃ ia,
          p ia ∧
            ∀ (x : X),
              x ∈ s ia →
                (↑UniformFun.ofFun (Function.swap F x₀), ↑UniformFun.ofFun (Function.swap F x)) ∈
                  UniformFun.gen ι α ib) ↔
    ∀ (U : Set (α × α)), U ∈ 𝓤 α → ∃ k, p k ∧ ∀ (x : X), x ∈ s k → ∀ (i : ι), (F i x₀, F i x) ∈ U
Theorem: BilinForm.IsAlt.neg_eq
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: have H1 : B₁ (x + y) (x + y) = 0 := self_eq_zero H (x + y)
state_before: R : Type ?u.957968
M : Type ?u.957971
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type ?u.958619
M₂ : Type ?u.958622
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.958809
M₃ : Type ?u.958812
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.959400
K : Type ?u.959403
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.960617
M₂'' : Type ?u.960620
inst✝³ : AddCommMonoid M₂'
inst✝² : AddCommMonoid M₂''
inst✝¹ : Module R₂ M₂'
inst✝ : Module R₂ M₂''
H : IsAlt B₁
x y : M₁
⊢ -bilin B₁ x y = bilin B₁ y x

tactic: rw [add_left, add_right, add_right, self_eq_zero H, self_eq_zero H, zero_add, add_zero,
  add_eq_zero_iff_neg_eq] at H1
state_before: R : Type ?u.957968
M : Type ?u.957971
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type ?u.958619
M₂ : Type ?u.958622
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.958809
M₃ : Type ?u.958812
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.959400
K : Type ?u.959403
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.960617
M₂'' : Type ?u.960620
inst✝³ : AddCommMonoid M₂'
inst✝² : AddCommMonoid M₂''
inst✝¹ : Module R₂ M₂'
inst✝ : Module R₂ M₂''
H : IsAlt B₁
x y : M₁
H1 : bilin B₁ (x + y) (x + y) = 0
⊢ -bilin B₁ x y = bilin B₁ y x

tactic: exact H1
state_before: R : Type ?u.957968
M : Type ?u.957971
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type ?u.958619
M₂ : Type ?u.958622
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type ?u.958809
M₃ : Type ?u.958812
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type ?u.959400
K : Type ?u.959403
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.960617
M₂'' : Type ?u.960620
inst✝³ : AddCommMonoid M₂'
inst✝² : AddCommMonoid M₂''
inst✝¹ : Module R₂ M₂'
inst✝ : Module R₂ M₂''
H : IsAlt B₁
x y : M₁
H1 : -bilin B₁ x y = bilin B₁ y x
⊢ -bilin B₁ x y = bilin B₁ y x
Theorem: MeasureTheory.Measure.haveLebesgueDecomposition_spec
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: rw [singularPart, rnDeriv, dif_pos h, dif_pos h]
state_before: α : Type u_1
β : Type ?u.2715
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : HaveLebesgueDecomposition μ ν
⊢ Measurable (rnDeriv μ ν) ∧ singularPart μ ν ⟂ₘ ν ∧ μ = singularPart μ ν + withDensity ν (rnDeriv μ ν)

tactic: exact Classical.choose_spec h.lebesgue_decomposition
state_before: α : Type u_1
β : Type ?u.2715
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : HaveLebesgueDecomposition μ ν
⊢ Measurable (Classical.choose (_ : ∃ p, Measurable p.snd ∧ p.fst ⟂ₘ ν ∧ μ = p.fst + withDensity ν p.snd)).snd ∧
    (Classical.choose (_ : ∃ p, Measurable p.snd ∧ p.fst ⟂ₘ ν ∧ μ = p.fst + withDensity ν p.snd)).fst ⟂ₘ ν ∧
      μ =
        (Classical.choose (_ : ∃ p, Measurable p.snd ∧ p.fst ⟂ₘ ν ∧ μ = p.fst + withDensity ν p.snd)).fst +
          withDensity ν
            (Classical.choose (_ : ∃ p, Measurable p.snd ∧ p.fst ⟂ₘ ν ∧ μ = p.fst + withDensity ν p.snd)).snd
Theorem: Nat.Linear.Expr.of_cancel_eq
File: src/lean/Init/Data/Nat/Linear.lean

tactic: have := Poly.denote_eq_cancel_eq ctx a.toNormPoly b.toNormPoly
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
⊢ (denote ctx a = denote ctx b) = (denote ctx c = denote ctx d)

tactic: rw [h] at this
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : Poly.denote_eq ctx (Poly.cancel (toNormPoly a) (toNormPoly b)) = Poly.denote_eq ctx (toNormPoly a, toNormPoly b)
⊢ (denote ctx a = denote ctx b) = (denote ctx c = denote ctx d)

tactic: simp [toNormPoly, Poly.norm, Poly.denote_eq] at this
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : Poly.denote_eq ctx (toPoly c, toPoly d) = Poly.denote_eq ctx (toNormPoly a, toNormPoly b)
⊢ (denote ctx a = denote ctx b) = (denote ctx c = denote ctx d)

tactic: exact this.symm
state_before: ctx : Context
a b c d : Expr
h : Poly.cancel (toNormPoly a) (toNormPoly b) = (toPoly c, toPoly d)
this : (denote ctx c = denote ctx d) = (denote ctx a = denote ctx b)
⊢ (denote ctx a = denote ctx b) = (denote ctx c = denote ctx d)
Theorem: List.foldl_hom
File: Std/Data/List/Lemmas.lean

tactic: induction l generalizing init <;> simp [*, H]
state_before: α₁ : Type u_1
α₂ : Type u_2
β : Type u_3
f : α₁ → α₂
g₁ : α₁ → β → α₁
g₂ : α₂ → β → α₂
l : List β
init : α₁
H : ∀ (x : α₁) (y : β), g₂ (f x) y = f (g₁ x y)
⊢ foldl g₂ (f init) l = f (foldl g₁ init l)
Theorem: contDiffAt_norm
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: have : ‖id x‖ ^ 2 ≠ 0 := pow_ne_zero 2 (norm_pos_iff.2 hx).ne'
state_before: 𝕜 : Type ?u.131195
E : Type u_1
F : Type ?u.131201
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.131330
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : E
hx : x ≠ 0
⊢ ContDiffAt ℝ n Norm.norm x

tactic: simpa only [id, sqrt_sq, norm_nonneg] using (contDiffAt_id.norm_sq 𝕜).sqrt this
state_before: 𝕜 : Type ?u.131195
E : Type u_1
F : Type ?u.131201
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type ?u.131330
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x✝ : G
n : ℕ∞
x : E
hx : x ≠ 0
this : ‖id x‖ ^ 2 ≠ 0
⊢ ContDiffAt ℝ n Norm.norm x
Theorem: FDerivMeasurableAux.le_of_mem_a
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: rcases hx with ⟨r', r'mem, hr'⟩
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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x : E
hx : x ∈ A f L r ε
y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
⊢ ‖f z - f y - ↑L (z - y)‖ ≤ ε * r

tactic: exact hr' _ ((mem_closedBall.1 hy).trans_lt r'mem.1) _ ((mem_closedBall.1 hz).trans_lt r'mem.1)
state_before: case intro.intro
𝕜 : 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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : E), y ∈ ball x r' → ∀ (z : E), z ∈ ball x r' → ‖f z - f y - ↑L (z - y)‖ ≤ ε * r
⊢ ‖f z - f y - ↑L (z - y)‖ ≤ ε * r
Theorem: Substring.Valid.isEmpty
File: Std/Data/String/Lemmas.lean

tactic: simp [h.isEmpty, h.toString, ext_iff]
state_before: x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.isEmpty x✝ = true ↔ toString x✝ = ""
Theorem: MeasureTheory.Measure.Regular.map
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: haveI := OuterRegular.map f μ
state_before: α : Type u_1
β : Type u_2
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
μ : Measure α
inst✝⁵ : OpensMeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : BorelSpace β
inst✝ : Regular μ
f : α ≃ₜ β
⊢ Regular (map (↑f) μ)

tactic: haveI := IsFiniteMeasureOnCompacts.map μ f
state_before: α : Type u_1
β : Type u_2
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
μ : Measure α
inst✝⁵ : OpensMeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : BorelSpace β
inst✝ : Regular μ
f : α ≃ₜ β
this : OuterRegular (map (↑f) μ)
⊢ Regular (map (↑f) μ)

tactic: exact
  ⟨Regular.innerRegular.map f.toEquiv f.measurable.aemeasurable
      (fun U hU => hU.preimage f.continuous) (fun K hK => hK.image f.continuous)
      (fun K hK => hK.measurableSet) fun U hU => hU.measurableSet⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
μ : Measure α
inst✝⁵ : OpensMeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : BorelSpace β
inst✝ : Regular μ
f : α ≃ₜ β
this✝ : OuterRegular (map (↑f) μ)
this : IsFiniteMeasureOnCompacts (map (↑f) μ)
⊢ Regular (map (↑f) μ)
Theorem: PosNum.size_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [size, succ_to_nat, size_to_nat n, cast_bit0, Nat.size_bit0 <| ne_of_gt <| to_nat_pos n]
state_before: α : Type ?u.330131
n : PosNum
⊢ ↑(size (bit0 n)) = Nat.size ↑(bit0 n)

tactic: rw [size, succ_to_nat, size_to_nat n, cast_bit1, Nat.size_bit1]
state_before: α : Type ?u.330131
n : PosNum
⊢ ↑(size (bit1 n)) = Nat.size ↑(bit1 n)
Theorem: Int.lt_sub_right_of_add_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h (-b)
state_before: a b c : Int
h : a + b < c
⊢ a < c - b

tactic: rwa [Int.add_neg_cancel_right] at h
state_before: a b c : Int
h✝ : a + b < c
h : a + b + -b < c + -b
⊢ a < c - b
Theorem: CauSeq.lim_mul_lim
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: have h :
  const abv (lim f * lim g) - f * g =
    (const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g) := by
        apply Subtype.ext
        rw [coe_add]
        simp [sub_mul, mul_sub]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ LimZero (const abv (lim f * lim g) - f * g)

tactic: rw [h]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (lim f * lim g) - f * g = (const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g)
⊢ LimZero (const abv (lim f * lim g) - f * g)

tactic: exact
  add_limZero (mul_limZero_left _ (Setoid.symm (equiv_lim _)))
    (mul_limZero_right _ (Setoid.symm (equiv_lim _)))
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (lim f * lim g) - f * g = (const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g)
⊢ LimZero ((const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g))

tactic: apply Subtype.ext
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ const abv (lim f * lim g) - f * g = (const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g)

tactic: rw [coe_add]
state_before: case a
α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ ↑(const abv (lim f * lim g) - f * g) = ↑((const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g))

tactic: simp [sub_mul, mul_sub]
state_before: case a
α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ ↑(const abv (lim f * lim g) - f * g) = ↑((const abv (lim f) - f) * g) + ↑(const abv (lim f) * (const abv (lim g) - g))
Theorem: Cardinal.lift_umax_eq
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_lift.{v, w, u}, ← lift_lift.{u, w, v}, lift_inj]
state_before: α β : Type u
a : Cardinal
b : Cardinal
⊢ lift a = lift b ↔ lift a = lift b
Theorem: Urysohns.CU.approx_mem_Icc_right_left
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: induction' n with n ihn generalizing c
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
n : ℕ
x : X
⊢ approx n c x ∈ Icc (approx n (right c) x) (approx n (left c) x)

tactic: exact ⟨le_rfl, indicator_le_indicator_of_subset (compl_subset_compl.2 c.left_U_subset)
  (fun _ => zero_le_one) _⟩
state_before: case zero
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
c : CU X
⊢ approx Nat.zero c x ∈ Icc (approx Nat.zero (right c) x) (approx Nat.zero (left c) x)

tactic: simp only [approx, mem_Icc]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), approx n c x ∈ Icc (approx n (right c) x) (approx n (left c) x)
c : CU X
⊢ approx (Nat.succ n) c x ∈ Icc (approx (Nat.succ n) (right c) x) (approx (Nat.succ n) (left c) x)

tactic: refine' ⟨midpoint_le_midpoint _ (ihn _).1, midpoint_le_midpoint (ihn _).2 _⟩ <;>
  apply approx_le_approx_of_U_sub_C
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), approx n c x ∈ Icc (approx n (right c) x) (approx n (left c) x)
c : CU X
⊢ midpoint ℝ (approx n (left (right c)) x) (approx n (right (right c)) x) ≤
      midpoint ℝ (approx n (left c) x) (approx n (right c) x) ∧
    midpoint ℝ (approx n (left c) x) (approx n (right c) x) ≤
      midpoint ℝ (approx n (left (left c)) x) (approx n (right (left c)) x)

tactic: exacts [subset_closure, subset_closure]
state_before: case succ.refine'_1.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), approx n c x ∈ Icc (approx n (right c) x) (approx n (left c) x)
c : CU X
⊢ (left c).U ⊆ (left (right c)).C

case succ.refine'_2.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
n : ℕ
ihn : ∀ (c : CU X), approx n c x ∈ Icc (approx n (right c) x) (approx n (left c) x)
c : CU X
⊢ (right (left c)).U ⊆ (right c).C
Theorem: Int.coe_nat_pow
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: induction' m with m _ <;> simp
state_before: α : Type ?u.267168
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
n m : ℕ
⊢ ↑(n ^ m) = ↑n ^ m
Theorem: MeasureTheory.SimpleFunc.range_one
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.124150
δ : Type ?u.124153
inst✝² : MeasurableSpace α
inst✝¹ : Nonempty α
inst✝ : One β
x : β
⊢ x ∈ SimpleFunc.range 1 ↔ x ∈ {1}
Theorem: List.mem_filter_of_mem
File: Mathlib/Data/List/Basic.lean

tactic: rcases mem_cons.1 h with rfl | h
state_before: ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a x : α
l : List α
h : a ∈ x :: l
h1 : p a = true
⊢ a ∈ filter p (x :: l)

tactic: . simp [filter, h1]
state_before: case inl
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a : α
l : List α
h1 : p a = true
h : a ∈ a :: l
⊢ a ∈ filter p (a :: l)

case inr
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a x : α
l : List α
h✝ : a ∈ x :: l
h1 : p a = true
h : a ∈ l
⊢ a ∈ filter p (x :: l)

tactic: . rw [filter]
  cases p x <;> simp [mem_filter_of_mem h h1]
state_before: case inr
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a x : α
l : List α
h✝ : a ∈ x :: l
h1 : p a = true
h : a ∈ l
⊢ a ∈ filter p (x :: l)

tactic: simp [filter, h1]
state_before: case inl
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a : α
l : List α
h1 : p a = true
h : a ∈ a :: l
⊢ a ∈ filter p (a :: l)

tactic: rw [filter]
state_before: case inr
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a x : α
l : List α
h✝ : a ∈ x :: l
h1 : p a = true
h : a ∈ l
⊢ a ∈ filter p (x :: l)

tactic: cases p x <;> simp [mem_filter_of_mem h h1]
state_before: case inr
ι : Type ?u.372560
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
a x : α
l : List α
h✝ : a ∈ x :: l
h1 : p a = true
h : a ∈ l
⊢ a ∈
    match p x with
    | true => x :: filter p l
    | false => filter p l
Theorem: Rat.normalize_num_den
File: Std/Data/Rat/Lemmas.lean

tactic: have := normalize_num_den' n d z
state_before: n : Int
d : Nat
z : d ≠ 0
n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
h : normalize n d = mk' n' d'
⊢ ∃ m, m ≠ 0 ∧ n = n' * ↑m ∧ d = d' * m

tactic: rwa [h] at this
state_before: n : Int
d : Nat
z : d ≠ 0
n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
h : normalize n d = mk' n' d'
this : ∃ d_1, d_1 ≠ 0 ∧ n = (normalize n d).num * ↑d_1 ∧ d = (normalize n d).den * d_1
⊢ ∃ m, m ≠ 0 ∧ n = n' * ↑m ∧ d = d' * m