Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | rank int64 0 2.4k |
|---|---|---|---|---|---|---|
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 85 | 90 | theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by |
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
| 1,742 |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
@[simp]
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 93 | 98 | theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by |
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
| 1,742 |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
@[simp]
theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
def gradedComm :
(β¨ i, π i) β[R] (β¨ i, β¬ i) ββ[R] (β¨ i, β¬ i) β[R] (β¨ i, π i) := by
refine TensorProduct.directSum R R π β¬ βͺβ«β ?_ βͺβ«β (TensorProduct.directSum R R β¬ π).symm
exact LinearEquiv.ofLinear (gradedCommAux _ _ _) (gradedCommAux _ _ _)
(gradedCommAux_comp_gradedCommAux _ _ _) (gradedCommAux_comp_gradedCommAux _ _ _)
@[simp]
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 111 | 114 | theorem gradedComm_symm : (gradedComm R π β¬).symm = gradedComm R β¬ π := by |
rw [gradedComm, gradedComm, LinearEquiv.trans_symm, LinearEquiv.symm_symm]
ext
rfl
| 1,742 |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
@[simp]
theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
def gradedComm :
(β¨ i, π i) β[R] (β¨ i, β¬ i) ββ[R] (β¨ i, β¬ i) β[R] (β¨ i, π i) := by
refine TensorProduct.directSum R R π β¬ βͺβ«β ?_ βͺβ«β (TensorProduct.directSum R R β¬ π).symm
exact LinearEquiv.ofLinear (gradedCommAux _ _ _) (gradedCommAux _ _ _)
(gradedCommAux_comp_gradedCommAux _ _ _) (gradedCommAux_comp_gradedCommAux _ _ _)
@[simp]
theorem gradedComm_symm : (gradedComm R π β¬).symm = gradedComm R β¬ π := by
rw [gradedComm, gradedComm, LinearEquiv.trans_symm, LinearEquiv.symm_symm]
ext
rfl
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 116 | 124 | theorem gradedComm_of_tmul_of (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedComm R π β¬ (lof R _ π i a ββ lof R _ β¬ j b) =
(-1 : β€Λ£)^(j * i) β’ (lof R _ β¬ _ b ββ lof R _ π _ a) := by |
rw [gradedComm]
dsimp only [LinearEquiv.trans_apply, LinearEquiv.ofLinear_apply]
rw [TensorProduct.directSum_lof_tmul_lof, gradedCommAux_lof_tmul, Units.smul_def,
-- Note: #8386 specialized `map_smul` to `LinearEquiv.map_smul` to avoid timeouts.
zsmul_eq_smul_cast R, LinearEquiv.map_smul, TensorProduct.directSum_symm_lof_tmul,
β zsmul_eq_smul_cast, β Units.smul_def]
| 1,742 |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
@[simp]
theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
def gradedComm :
(β¨ i, π i) β[R] (β¨ i, β¬ i) ββ[R] (β¨ i, β¬ i) β[R] (β¨ i, π i) := by
refine TensorProduct.directSum R R π β¬ βͺβ«β ?_ βͺβ«β (TensorProduct.directSum R R β¬ π).symm
exact LinearEquiv.ofLinear (gradedCommAux _ _ _) (gradedCommAux _ _ _)
(gradedCommAux_comp_gradedCommAux _ _ _) (gradedCommAux_comp_gradedCommAux _ _ _)
@[simp]
theorem gradedComm_symm : (gradedComm R π β¬).symm = gradedComm R β¬ π := by
rw [gradedComm, gradedComm, LinearEquiv.trans_symm, LinearEquiv.symm_symm]
ext
rfl
theorem gradedComm_of_tmul_of (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedComm R π β¬ (lof R _ π i a ββ lof R _ β¬ j b) =
(-1 : β€Λ£)^(j * i) β’ (lof R _ β¬ _ b ββ lof R _ π _ a) := by
rw [gradedComm]
dsimp only [LinearEquiv.trans_apply, LinearEquiv.ofLinear_apply]
rw [TensorProduct.directSum_lof_tmul_lof, gradedCommAux_lof_tmul, Units.smul_def,
-- Note: #8386 specialized `map_smul` to `LinearEquiv.map_smul` to avoid timeouts.
zsmul_eq_smul_cast R, LinearEquiv.map_smul, TensorProduct.directSum_symm_lof_tmul,
β zsmul_eq_smul_cast, β Units.smul_def]
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 126 | 135 | theorem gradedComm_tmul_of_zero (a : β¨ i, π i) (b : β¬ 0) :
gradedComm R π β¬ (a ββ lof R _ β¬ 0 b) = lof R _ β¬ _ b ββ a := by |
suffices
(gradedComm R π β¬).toLinearMap ββ
(TensorProduct.mk R (β¨ i, π i) (β¨ i, β¬ i)).flip (lof R _ β¬ 0 b) =
TensorProduct.mk R _ _ (lof R _ β¬ 0 b) from
DFunLike.congr_fun this a
ext i a
dsimp
rw [gradedComm_of_tmul_of, zero_mul, uzpow_zero, one_smul]
| 1,742 |
import Mathlib.Data.Int.Order.Units
import Mathlib.Data.ZMod.IntUnitsPower
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Algebra.DirectSum.Algebra
suppress_compilation
open scoped TensorProduct DirectSum
variable {R ΞΉ A B : Type*}
namespace TensorProduct
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable (π : ΞΉ β Type*) (β¬ : ΞΉ β Type*)
variable [CommRing R]
variable [β i, AddCommGroup (π i)] [β i, AddCommGroup (β¬ i)]
variable [β i, Module R (π i)] [β i, Module R (β¬ i)]
variable [DirectSum.GRing π] [DirectSum.GRing β¬]
variable [DirectSum.GAlgebra R π] [DirectSum.GAlgebra R β¬]
-- this helps with performance
instance (i : ΞΉ Γ ΞΉ) : Module R (π (Prod.fst i) β[R] β¬ (Prod.snd i)) :=
TensorProduct.leftModule
open DirectSum (lof)
variable (R)
section gradedComm
local notation "πβ¬" => (fun i : ΞΉ Γ ΞΉ => π (Prod.fst i) β[R] β¬ (Prod.snd i))
local notation "β¬π" => (fun i : ΞΉ Γ ΞΉ => β¬ (Prod.fst i) β[R] π (Prod.snd i))
def gradedCommAux : DirectSum _ πβ¬ ββ[R] DirectSum _ β¬π := by
refine DirectSum.toModule R _ _ fun i => ?_
have o := DirectSum.lof R _ β¬π i.swap
have s : β€Λ£ := ((-1 : β€Λ£)^(i.1* i.2 : ΞΉ) : β€Λ£)
exact (s β’ o) ββ (TensorProduct.comm R _ _).toLinearMap
@[simp]
theorem gradedCommAux_lof_tmul (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedCommAux R π β¬ (lof R _ πβ¬ (i, j) (a ββ b)) =
(-1 : β€Λ£)^(j * i) β’ lof R _ β¬π (j, i) (b ββ a) := by
rw [gradedCommAux]
dsimp
simp [mul_comm i j]
@[simp]
theorem gradedCommAux_comp_gradedCommAux :
gradedCommAux R π β¬ ββ gradedCommAux R β¬ π = LinearMap.id := by
ext i a b
dsimp
rw [gradedCommAux_lof_tmul, LinearMap.map_smul_of_tower, gradedCommAux_lof_tmul, smul_smul,
mul_comm i.2 i.1, Int.units_mul_self, one_smul]
def gradedComm :
(β¨ i, π i) β[R] (β¨ i, β¬ i) ββ[R] (β¨ i, β¬ i) β[R] (β¨ i, π i) := by
refine TensorProduct.directSum R R π β¬ βͺβ«β ?_ βͺβ«β (TensorProduct.directSum R R β¬ π).symm
exact LinearEquiv.ofLinear (gradedCommAux _ _ _) (gradedCommAux _ _ _)
(gradedCommAux_comp_gradedCommAux _ _ _) (gradedCommAux_comp_gradedCommAux _ _ _)
@[simp]
theorem gradedComm_symm : (gradedComm R π β¬).symm = gradedComm R β¬ π := by
rw [gradedComm, gradedComm, LinearEquiv.trans_symm, LinearEquiv.symm_symm]
ext
rfl
theorem gradedComm_of_tmul_of (i j : ΞΉ) (a : π i) (b : β¬ j) :
gradedComm R π β¬ (lof R _ π i a ββ lof R _ β¬ j b) =
(-1 : β€Λ£)^(j * i) β’ (lof R _ β¬ _ b ββ lof R _ π _ a) := by
rw [gradedComm]
dsimp only [LinearEquiv.trans_apply, LinearEquiv.ofLinear_apply]
rw [TensorProduct.directSum_lof_tmul_lof, gradedCommAux_lof_tmul, Units.smul_def,
-- Note: #8386 specialized `map_smul` to `LinearEquiv.map_smul` to avoid timeouts.
zsmul_eq_smul_cast R, LinearEquiv.map_smul, TensorProduct.directSum_symm_lof_tmul,
β zsmul_eq_smul_cast, β Units.smul_def]
theorem gradedComm_tmul_of_zero (a : β¨ i, π i) (b : β¬ 0) :
gradedComm R π β¬ (a ββ lof R _ β¬ 0 b) = lof R _ β¬ _ b ββ a := by
suffices
(gradedComm R π β¬).toLinearMap ββ
(TensorProduct.mk R (β¨ i, π i) (β¨ i, β¬ i)).flip (lof R _ β¬ 0 b) =
TensorProduct.mk R _ _ (lof R _ β¬ 0 b) from
DFunLike.congr_fun this a
ext i a
dsimp
rw [gradedComm_of_tmul_of, zero_mul, uzpow_zero, one_smul]
| Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean | 137 | 145 | theorem gradedComm_of_zero_tmul (a : π 0) (b : β¨ i, β¬ i) :
gradedComm R π β¬ (lof R _ π 0 a ββ b) = b ββ lof R _ π _ a := by |
suffices
(gradedComm R π β¬).toLinearMap ββ (TensorProduct.mk R (β¨ i, π i) (β¨ i, β¬ i)) (lof R _ π 0 a) =
(TensorProduct.mk R _ _).flip (lof R _ π 0 a) from
DFunLike.congr_fun this b
ext i b
dsimp
rw [gradedComm_of_tmul_of, mul_zero, uzpow_zero, one_smul]
| 1,742 |
import Mathlib.LinearAlgebra.TensorProduct.Graded.External
import Mathlib.RingTheory.GradedAlgebra.Basic
import Mathlib.GroupTheory.GroupAction.Ring
suppress_compilation
open scoped TensorProduct
variable {R ΞΉ A B : Type*}
variable [CommSemiring ΞΉ] [Module ΞΉ (Additive β€Λ£)] [DecidableEq ΞΉ]
variable [CommRing R] [Ring A] [Ring B] [Algebra R A] [Algebra R B]
variable (π : ΞΉ β Submodule R A) (β¬ : ΞΉ β Submodule R B)
variable [GradedAlgebra π] [GradedAlgebra β¬]
open DirectSum
variable (R) in
@[nolint unusedArguments]
def GradedTensorProduct
(π : ΞΉ β Submodule R A) (β¬ : ΞΉ β Submodule R B)
[GradedAlgebra π] [GradedAlgebra β¬] :
Type _ :=
A β[R] B
namespace GradedTensorProduct
open TensorProduct
@[inherit_doc GradedTensorProduct]
scoped[TensorProduct] notation:100 π " α΅β[" R "] " β¬:100 => GradedTensorProduct R π β¬
instance instAddCommGroupWithOne : AddCommGroupWithOne (π α΅β[R] β¬) :=
Algebra.TensorProduct.instAddCommGroupWithOne
instance : Module R (π α΅β[R] β¬) := TensorProduct.leftModule
variable (R) in
def of : A β[R] B ββ[R] π α΅β[R] β¬ := LinearEquiv.refl _ _
@[simp]
theorem of_one : of R π β¬ 1 = 1 := rfl
@[simp]
theorem of_symm_one : (of R π β¬).symm 1 = 1 := rfl
-- for dsimp
@[simp, nolint simpNF]
theorem of_symm_of (x : A β[R] B) : (of R π β¬).symm (of R π β¬ x) = x := rfl
-- for dsimp
@[simp, nolint simpNF]
theorem symm_of_of (x : π α΅β[R] β¬) : of R π β¬ ((of R π β¬).symm x) = x := rfl
@[ext]
theorem hom_ext {M} [AddCommMonoid M] [Module R M] β¦f g : π α΅β[R] β¬ ββ[R] Mβ¦
(h : f ββ of R π β¬ = (g ββ of R π β¬ : A β[R] B ββ[R] M)) :
f = g :=
h
variable (R) {π β¬} in
abbrev tmul (a : A) (b : B) : π α΅β[R] β¬ := of R π β¬ (a ββ b)
@[inherit_doc]
notation:100 x " α΅ββ" y:100 => tmul _ x y
@[inherit_doc]
notation:100 x " α΅ββ[" R "] " y:100 => tmul R x y
variable (R) in
noncomputable def auxEquiv : (π α΅β[R] β¬) ββ[R] (β¨ i, π i) β[R] (β¨ i, β¬ i) :=
let fA := (decomposeAlgEquiv π).toLinearEquiv
let fB := (decomposeAlgEquiv β¬).toLinearEquiv
(of R π β¬).symm.trans (TensorProduct.congr fA fB)
theorem auxEquiv_tmul (a : A) (b : B) :
auxEquiv R π β¬ (a α΅ββ b) = decompose π a ββ decompose β¬ b := rfl
| Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean | 133 | 135 | theorem auxEquiv_one : auxEquiv R π β¬ 1 = 1 := by |
rw [β of_one, Algebra.TensorProduct.one_def, auxEquiv_tmul π β¬, DirectSum.decompose_one,
DirectSum.decompose_one, Algebra.TensorProduct.one_def]
| 1,743 |
import Mathlib.LinearAlgebra.CliffordAlgebra.Grading
import Mathlib.LinearAlgebra.TensorProduct.Graded.Internal
import Mathlib.LinearAlgebra.QuadraticForm.Prod
suppress_compilation
variable {R Mβ Mβ N : Type*}
variable [CommRing R] [AddCommGroup Mβ] [AddCommGroup Mβ] [AddCommGroup N]
variable [Module R Mβ] [Module R Mβ] [Module R N]
variable (Qβ : QuadraticForm R Mβ) (Qβ : QuadraticForm R Mβ) (Qβ : QuadraticForm R N)
open scoped TensorProduct
namespace CliffordAlgebra
section map_mul_map
variable {Qβ Qβ Qβ}
variable (fβ : Qβ βqα΅’ Qβ) (fβ : Qβ βqα΅’ Qβ) (hf : β x y, Qβ.IsOrtho (fβ x) (fβ y))
variable (mβ : CliffordAlgebra Qβ) (mβ : CliffordAlgebra Qβ)
nonrec theorem map_mul_map_of_isOrtho_of_mem_evenOdd
{iβ iβ : ZMod 2} (hmβ : mβ β evenOdd Qβ iβ) (hmβ : mβ β evenOdd Qβ iβ) :
map fβ mβ * map fβ mβ = (-1 : β€Λ£) ^ (iβ * iβ) β’ (map fβ mβ * map fβ mβ) := by
-- the strategy; for each variable, induct on powers of `ΞΉ`, then on the exponent of each
-- power.
induction hmβ using Submodule.iSup_induction' with
| zero => rw [map_zero, zero_mul, mul_zero, smul_zero]
| add _ _ _ _ ihx ihy => rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
| mem iβ' mβ' hmβ =>
obtain β¨iβn, rflβ© := iβ'
dsimp only at *
induction hmβ using Submodule.pow_induction_on_left' with
| algebraMap =>
rw [AlgHom.commutes, Nat.cast_zero, mul_zero, uzpow_zero, one_smul, Algebra.commutes]
| add _ _ _ _ _ ihx ihy =>
rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
| mem_mul mβ hmβ i xβ _hxβ ihβ =>
obtain β¨vβ, rflβ© := hmβ
-- this is the first interesting goal
rw [map_mul, mul_assoc, ihβ, mul_smul_comm, map_apply_ΞΉ, Nat.cast_succ, mul_add_one,
uzpow_add, mul_smul, β mul_assoc, β mul_assoc, β smul_mul_assoc ((-1) ^ iβ)]
clear ihβ
congr 2
induction hmβ using Submodule.iSup_induction' with
| zero => rw [map_zero, zero_mul, mul_zero, smul_zero]
| add _ _ _ _ ihx ihy => rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
| mem iβ' mβ' hmβ =>
clear mβ
obtain β¨iβn, rflβ© := iβ'
dsimp only at *
induction hmβ using Submodule.pow_induction_on_left' with
| algebraMap =>
rw [AlgHom.commutes, Nat.cast_zero, uzpow_zero, one_smul, Algebra.commutes]
| add _ _ _ _ _ ihx ihy =>
rw [map_add, add_mul, mul_add, ihx, ihy, smul_add]
| mem_mul mβ hmβ i xβ _hxβ ihβ =>
obtain β¨vβ, rflβ© := hmβ
-- this is the second interesting goal
rw [map_mul, map_apply_ΞΉ, Nat.cast_succ, β mul_assoc,
ΞΉ_mul_ΞΉ_comm_of_isOrtho (hf _ _), neg_mul, mul_assoc, ihβ, mul_smul_comm,
β mul_assoc, β Units.neg_smul, uzpow_add, uzpow_one, mul_neg_one]
theorem commute_map_mul_map_of_isOrtho_of_mem_evenOdd_zero_left
{iβ : ZMod 2} (hmβ : mβ β evenOdd Qβ 0) (hmβ : mβ β evenOdd Qβ iβ) :
Commute (map fβ mβ) (map fβ mβ) :=
(map_mul_map_of_isOrtho_of_mem_evenOdd _ _ hf _ _ hmβ hmβ).trans <| by simp
theorem commute_map_mul_map_of_isOrtho_of_mem_evenOdd_zero_right
{iβ : ZMod 2} (hmβ : mβ β evenOdd Qβ iβ) (hmβ : mβ β evenOdd Qβ 0) :
Commute (map fβ mβ) (map fβ mβ) :=
(map_mul_map_of_isOrtho_of_mem_evenOdd _ _ hf _ _ hmβ hmβ).trans <| by simp
| Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean | 101 | 104 | theorem map_mul_map_eq_neg_of_isOrtho_of_mem_evenOdd_one
(hmβ : mβ β evenOdd Qβ 1) (hmβ : mβ β evenOdd Qβ 1) :
map fβ mβ * map fβ mβ = - map fβ mβ * map fβ mβ := by |
simp [map_mul_map_of_isOrtho_of_mem_evenOdd _ _ hf _ _ hmβ hmβ]
| 1,744 |
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.RingTheory.Adjoin.Basic
#align_import topology.algebra.algebra from "leanprover-community/mathlib"@"43afc5ad87891456c57b5a183e3e617d67c2b1db"
open scoped Classical
open Set TopologicalSpace Algebra
open scoped Classical
universe u v w
section TopologicalAlgebra
variable (R : Type*) (A : Type u)
variable [CommSemiring R] [Semiring A] [Algebra R A]
variable [TopologicalSpace R] [TopologicalSpace A]
@[continuity, fun_prop]
| Mathlib/Topology/Algebra/Algebra.lean | 42 | 44 | theorem continuous_algebraMap [ContinuousSMul R A] : Continuous (algebraMap R A) := by |
rw [algebraMap_eq_smul_one']
exact continuous_id.smul continuous_const
| 1,745 |
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.RingTheory.Adjoin.Basic
#align_import topology.algebra.algebra from "leanprover-community/mathlib"@"43afc5ad87891456c57b5a183e3e617d67c2b1db"
open scoped Classical
open Set TopologicalSpace Algebra
open scoped Classical
universe u v w
section TopologicalAlgebra
variable (R : Type*) (A : Type u)
variable [CommSemiring R] [Semiring A] [Algebra R A]
variable [TopologicalSpace R] [TopologicalSpace A]
@[continuity, fun_prop]
theorem continuous_algebraMap [ContinuousSMul R A] : Continuous (algebraMap R A) := by
rw [algebraMap_eq_smul_one']
exact continuous_id.smul continuous_const
#align continuous_algebra_map continuous_algebraMap
| Mathlib/Topology/Algebra/Algebra.lean | 47 | 51 | theorem continuous_algebraMap_iff_smul [TopologicalSemiring A] :
Continuous (algebraMap R A) β Continuous fun p : R Γ A => p.1 β’ p.2 := by |
refine β¨fun h => ?_, fun h => have : ContinuousSMul R A := β¨hβ©; continuous_algebraMap _ _β©
simp only [Algebra.smul_def]
exact (h.comp continuous_fst).mul continuous_snd
| 1,745 |
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.RingTheory.Adjoin.Basic
#align_import topology.algebra.algebra from "leanprover-community/mathlib"@"43afc5ad87891456c57b5a183e3e617d67c2b1db"
open scoped Classical
open Set TopologicalSpace Algebra
open scoped Classical
universe u v w
section TopologicalAlgebra
variable {R : Type*} [CommSemiring R]
variable {A : Type u} [TopologicalSpace A]
variable [Semiring A] [Algebra R A]
#align subalgebra.has_continuous_smul SMulMemClass.continuousSMul
variable [TopologicalSemiring A]
def Subalgebra.topologicalClosure (s : Subalgebra R A) : Subalgebra R A :=
{ s.toSubsemiring.topologicalClosure with
carrier := closure (s : Set A)
algebraMap_mem' := fun r => s.toSubsemiring.le_topologicalClosure (s.algebraMap_mem r) }
#align subalgebra.topological_closure Subalgebra.topologicalClosure
@[simp]
theorem Subalgebra.topologicalClosure_coe (s : Subalgebra R A) :
(s.topologicalClosure : Set A) = closure (s : Set A) :=
rfl
#align subalgebra.topological_closure_coe Subalgebra.topologicalClosure_coe
instance Subalgebra.topologicalSemiring (s : Subalgebra R A) : TopologicalSemiring s :=
s.toSubsemiring.topologicalSemiring
#align subalgebra.topological_semiring Subalgebra.topologicalSemiring
theorem Subalgebra.le_topologicalClosure (s : Subalgebra R A) : s β€ s.topologicalClosure :=
subset_closure
#align subalgebra.le_topological_closure Subalgebra.le_topologicalClosure
| Mathlib/Topology/Algebra/Algebra.lean | 110 | 111 | theorem Subalgebra.isClosed_topologicalClosure (s : Subalgebra R A) :
IsClosed (s.topologicalClosure : Set A) := by | convert @isClosed_closure A s _
| 1,745 |
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.RingTheory.Adjoin.Basic
#align_import topology.algebra.algebra from "leanprover-community/mathlib"@"43afc5ad87891456c57b5a183e3e617d67c2b1db"
open scoped Classical
open Set TopologicalSpace Algebra
open scoped Classical
universe u v w
section TopologicalAlgebra
variable {R : Type*} [CommSemiring R]
variable {A : Type u} [TopologicalSpace A]
variable [Semiring A] [Algebra R A]
#align subalgebra.has_continuous_smul SMulMemClass.continuousSMul
variable [TopologicalSemiring A]
def Subalgebra.topologicalClosure (s : Subalgebra R A) : Subalgebra R A :=
{ s.toSubsemiring.topologicalClosure with
carrier := closure (s : Set A)
algebraMap_mem' := fun r => s.toSubsemiring.le_topologicalClosure (s.algebraMap_mem r) }
#align subalgebra.topological_closure Subalgebra.topologicalClosure
@[simp]
theorem Subalgebra.topologicalClosure_coe (s : Subalgebra R A) :
(s.topologicalClosure : Set A) = closure (s : Set A) :=
rfl
#align subalgebra.topological_closure_coe Subalgebra.topologicalClosure_coe
instance Subalgebra.topologicalSemiring (s : Subalgebra R A) : TopologicalSemiring s :=
s.toSubsemiring.topologicalSemiring
#align subalgebra.topological_semiring Subalgebra.topologicalSemiring
theorem Subalgebra.le_topologicalClosure (s : Subalgebra R A) : s β€ s.topologicalClosure :=
subset_closure
#align subalgebra.le_topological_closure Subalgebra.le_topologicalClosure
theorem Subalgebra.isClosed_topologicalClosure (s : Subalgebra R A) :
IsClosed (s.topologicalClosure : Set A) := by convert @isClosed_closure A s _
#align subalgebra.is_closed_topological_closure Subalgebra.isClosed_topologicalClosure
theorem Subalgebra.topologicalClosure_minimal (s : Subalgebra R A) {t : Subalgebra R A} (h : s β€ t)
(ht : IsClosed (t : Set A)) : s.topologicalClosure β€ t :=
closure_minimal h ht
#align subalgebra.topological_closure_minimal Subalgebra.topologicalClosure_minimal
def Subalgebra.commSemiringTopologicalClosure [T2Space A] (s : Subalgebra R A)
(hs : β x y : s, x * y = y * x) : CommSemiring s.topologicalClosure :=
{ s.topologicalClosure.toSemiring, s.toSubmonoid.commMonoidTopologicalClosure hs with }
#align subalgebra.comm_semiring_topological_closure Subalgebra.commSemiringTopologicalClosure
| Mathlib/Topology/Algebra/Algebra.lean | 130 | 137 | theorem Subalgebra.topologicalClosure_comap_homeomorph (s : Subalgebra R A) {B : Type*}
[TopologicalSpace B] [Ring B] [TopologicalRing B] [Algebra R B] (f : B ββ[R] A) (f' : B ββ A)
(w : (f : B β A) = f') : s.topologicalClosure.comap f = (s.comap f).topologicalClosure := by |
apply SetLike.ext'
simp only [Subalgebra.topologicalClosure_coe]
simp only [Subalgebra.coe_comap, Subsemiring.coe_comap, AlgHom.coe_toRingHom]
rw [w]
exact f'.preimage_closure _
| 1,745 |
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.Star
#align_import topology.algebra.star_subalgebra from "leanprover-community/mathlib"@"b7f5a77fa29ad9a3ccc484109b0d7534178e7ecd"
open scoped Classical
open Set TopologicalSpace
open scoped Classical
namespace StarSubalgebra
section TopologicalStarAlgebra
variable {R A B : Type*} [CommSemiring R] [StarRing R]
variable [TopologicalSpace A] [Semiring A] [Algebra R A] [StarRing A] [StarModule R A]
instance [TopologicalSemiring A] (s : StarSubalgebra R A) : TopologicalSemiring s :=
s.toSubalgebra.topologicalSemiring
theorem embedding_inclusion {Sβ Sβ : StarSubalgebra R A} (h : Sβ β€ Sβ) : Embedding (inclusion h) :=
{ induced := Eq.symm induced_compose
inj := Subtype.map_injective h Function.injective_id }
#align star_subalgebra.embedding_inclusion StarSubalgebra.embedding_inclusion
theorem closedEmbedding_inclusion {Sβ Sβ : StarSubalgebra R A} (h : Sβ β€ Sβ)
(hSβ : IsClosed (Sβ : Set A)) : ClosedEmbedding (inclusion h) :=
{ embedding_inclusion h with
isClosed_range := isClosed_induced_iff.2
β¨Sβ, hSβ, by
convert (Set.range_subtype_map id _).symm
Β· rw [Set.image_id]; rfl
Β· intro _ h'
apply h h' β© }
#align star_subalgebra.closed_embedding_inclusion StarSubalgebra.closedEmbedding_inclusion
variable [TopologicalSemiring A] [ContinuousStar A]
variable [TopologicalSpace B] [Semiring B] [Algebra R B] [StarRing B]
def topologicalClosure (s : StarSubalgebra R A) : StarSubalgebra R A :=
{
s.toSubalgebra.topologicalClosure with
carrier := closure (s : Set A)
star_mem' := fun ha =>
map_mem_closure continuous_star ha fun x => (star_mem : x β s β star x β s) }
#align star_subalgebra.topological_closure StarSubalgebra.topologicalClosure
theorem topologicalClosure_toSubalgebra_comm (s : StarSubalgebra R A) :
s.topologicalClosure.toSubalgebra = s.toSubalgebra.topologicalClosure :=
SetLike.coe_injective rfl
@[simp]
theorem topologicalClosure_coe (s : StarSubalgebra R A) :
(s.topologicalClosure : Set A) = closure (s : Set A) :=
rfl
#align star_subalgebra.topological_closure_coe StarSubalgebra.topologicalClosure_coe
theorem le_topologicalClosure (s : StarSubalgebra R A) : s β€ s.topologicalClosure :=
subset_closure
#align star_subalgebra.le_topological_closure StarSubalgebra.le_topologicalClosure
theorem isClosed_topologicalClosure (s : StarSubalgebra R A) :
IsClosed (s.topologicalClosure : Set A) :=
isClosed_closure
#align star_subalgebra.is_closed_topological_closure StarSubalgebra.isClosed_topologicalClosure
instance {A : Type*} [UniformSpace A] [CompleteSpace A] [Semiring A] [StarRing A]
[TopologicalSemiring A] [ContinuousStar A] [Algebra R A] [StarModule R A]
{S : StarSubalgebra R A} : CompleteSpace S.topologicalClosure :=
isClosed_closure.completeSpace_coe
theorem topologicalClosure_minimal {s t : StarSubalgebra R A} (h : s β€ t)
(ht : IsClosed (t : Set A)) : s.topologicalClosure β€ t :=
closure_minimal h ht
#align star_subalgebra.topological_closure_minimal StarSubalgebra.topologicalClosure_minimal
theorem topologicalClosure_mono : Monotone (topologicalClosure : _ β StarSubalgebra R A) :=
fun _ Sβ h =>
topologicalClosure_minimal (h.trans <| le_topologicalClosure Sβ) (isClosed_topologicalClosure Sβ)
#align star_subalgebra.topological_closure_mono StarSubalgebra.topologicalClosure_mono
theorem topologicalClosure_map_le [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : IsClosedMap Ο) :
(map Ο s).topologicalClosure β€ map Ο s.topologicalClosure :=
hΟ.closure_image_subset _
theorem map_topologicalClosure_le [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : Continuous Ο) :
map Ο s.topologicalClosure β€ (map Ο s).topologicalClosure :=
image_closure_subset_closure_image hΟ
theorem topologicalClosure_map [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : ClosedEmbedding Ο) :
(map Ο s).topologicalClosure = map Ο s.topologicalClosure :=
SetLike.coe_injective <| hΟ.closure_image_eq _
| Mathlib/Topology/Algebra/StarSubalgebra.lean | 122 | 127 | theorem _root_.Subalgebra.topologicalClosure_star_comm (s : Subalgebra R A) :
(star s).topologicalClosure = star s.topologicalClosure := by |
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)))
exact fun t => (star t).topologicalClosure_minimal (Subalgebra.star_mono subset_closure)
(isClosed_closure.preimage continuous_star)
| 1,746 |
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.Star
#align_import topology.algebra.star_subalgebra from "leanprover-community/mathlib"@"b7f5a77fa29ad9a3ccc484109b0d7534178e7ecd"
open scoped Classical
open Set TopologicalSpace
open scoped Classical
namespace StarSubalgebra
section TopologicalStarAlgebra
variable {R A B : Type*} [CommSemiring R] [StarRing R]
variable [TopologicalSpace A] [Semiring A] [Algebra R A] [StarRing A] [StarModule R A]
instance [TopologicalSemiring A] (s : StarSubalgebra R A) : TopologicalSemiring s :=
s.toSubalgebra.topologicalSemiring
theorem embedding_inclusion {Sβ Sβ : StarSubalgebra R A} (h : Sβ β€ Sβ) : Embedding (inclusion h) :=
{ induced := Eq.symm induced_compose
inj := Subtype.map_injective h Function.injective_id }
#align star_subalgebra.embedding_inclusion StarSubalgebra.embedding_inclusion
theorem closedEmbedding_inclusion {Sβ Sβ : StarSubalgebra R A} (h : Sβ β€ Sβ)
(hSβ : IsClosed (Sβ : Set A)) : ClosedEmbedding (inclusion h) :=
{ embedding_inclusion h with
isClosed_range := isClosed_induced_iff.2
β¨Sβ, hSβ, by
convert (Set.range_subtype_map id _).symm
Β· rw [Set.image_id]; rfl
Β· intro _ h'
apply h h' β© }
#align star_subalgebra.closed_embedding_inclusion StarSubalgebra.closedEmbedding_inclusion
variable [TopologicalSemiring A] [ContinuousStar A]
variable [TopologicalSpace B] [Semiring B] [Algebra R B] [StarRing B]
def topologicalClosure (s : StarSubalgebra R A) : StarSubalgebra R A :=
{
s.toSubalgebra.topologicalClosure with
carrier := closure (s : Set A)
star_mem' := fun ha =>
map_mem_closure continuous_star ha fun x => (star_mem : x β s β star x β s) }
#align star_subalgebra.topological_closure StarSubalgebra.topologicalClosure
theorem topologicalClosure_toSubalgebra_comm (s : StarSubalgebra R A) :
s.topologicalClosure.toSubalgebra = s.toSubalgebra.topologicalClosure :=
SetLike.coe_injective rfl
@[simp]
theorem topologicalClosure_coe (s : StarSubalgebra R A) :
(s.topologicalClosure : Set A) = closure (s : Set A) :=
rfl
#align star_subalgebra.topological_closure_coe StarSubalgebra.topologicalClosure_coe
theorem le_topologicalClosure (s : StarSubalgebra R A) : s β€ s.topologicalClosure :=
subset_closure
#align star_subalgebra.le_topological_closure StarSubalgebra.le_topologicalClosure
theorem isClosed_topologicalClosure (s : StarSubalgebra R A) :
IsClosed (s.topologicalClosure : Set A) :=
isClosed_closure
#align star_subalgebra.is_closed_topological_closure StarSubalgebra.isClosed_topologicalClosure
instance {A : Type*} [UniformSpace A] [CompleteSpace A] [Semiring A] [StarRing A]
[TopologicalSemiring A] [ContinuousStar A] [Algebra R A] [StarModule R A]
{S : StarSubalgebra R A} : CompleteSpace S.topologicalClosure :=
isClosed_closure.completeSpace_coe
theorem topologicalClosure_minimal {s t : StarSubalgebra R A} (h : s β€ t)
(ht : IsClosed (t : Set A)) : s.topologicalClosure β€ t :=
closure_minimal h ht
#align star_subalgebra.topological_closure_minimal StarSubalgebra.topologicalClosure_minimal
theorem topologicalClosure_mono : Monotone (topologicalClosure : _ β StarSubalgebra R A) :=
fun _ Sβ h =>
topologicalClosure_minimal (h.trans <| le_topologicalClosure Sβ) (isClosed_topologicalClosure Sβ)
#align star_subalgebra.topological_closure_mono StarSubalgebra.topologicalClosure_mono
theorem topologicalClosure_map_le [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : IsClosedMap Ο) :
(map Ο s).topologicalClosure β€ map Ο s.topologicalClosure :=
hΟ.closure_image_subset _
theorem map_topologicalClosure_le [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : Continuous Ο) :
map Ο s.topologicalClosure β€ (map Ο s).topologicalClosure :=
image_closure_subset_closure_image hΟ
theorem topologicalClosure_map [StarModule R B] [TopologicalSemiring B] [ContinuousStar B]
(s : StarSubalgebra R A) (Ο : A βββ[R] B) (hΟ : ClosedEmbedding Ο) :
(map Ο s).topologicalClosure = map Ο s.topologicalClosure :=
SetLike.coe_injective <| hΟ.closure_image_eq _
theorem _root_.Subalgebra.topologicalClosure_star_comm (s : Subalgebra R A) :
(star s).topologicalClosure = star s.topologicalClosure := by
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)))
exact fun t => (star t).topologicalClosure_minimal (Subalgebra.star_mono subset_closure)
(isClosed_closure.preimage continuous_star)
abbrev commSemiringTopologicalClosure [T2Space A] (s : StarSubalgebra R A)
(hs : β x y : s, x * y = y * x) : CommSemiring s.topologicalClosure :=
s.toSubalgebra.commSemiringTopologicalClosure hs
#align star_subalgebra.comm_semiring_topological_closure StarSubalgebra.commSemiringTopologicalClosure
abbrev commRingTopologicalClosure {R A} [CommRing R] [StarRing R] [TopologicalSpace A] [Ring A]
[Algebra R A] [StarRing A] [StarModule R A] [TopologicalRing A] [ContinuousStar A] [T2Space A]
(s : StarSubalgebra R A) (hs : β x y : s, x * y = y * x) : CommRing s.topologicalClosure :=
s.toSubalgebra.commRingTopologicalClosure hs
#align star_subalgebra.comm_ring_topological_closure StarSubalgebra.commRingTopologicalClosure
| Mathlib/Topology/Algebra/StarSubalgebra.lean | 146 | 163 | theorem _root_.StarAlgHom.ext_topologicalClosure [T2Space B] {S : StarSubalgebra R A}
{Ο Ο : S.topologicalClosure βββ[R] B} (hΟ : Continuous Ο) (hΟ : Continuous Ο)
(h :
Ο.comp (inclusion (le_topologicalClosure S)) = Ο.comp (inclusion (le_topologicalClosure S))) :
Ο = Ο := by |
rw [DFunLike.ext'_iff]
have : Dense (Set.range <| inclusion (le_topologicalClosure S)) := by
refine embedding_subtype_val.toInducing.dense_iff.2 fun x => ?_
convert show βx β closure (S : Set A) from x.prop
rw [β Set.range_comp]
exact
Set.ext fun y =>
β¨by
rintro β¨y, rflβ©
exact y.prop, fun hy => β¨β¨y, hyβ©, rflβ©β©
refine Continuous.ext_on this hΟ hΟ ?_
rintro _ β¨x, rflβ©
simpa only using DFunLike.congr_fun h x
| 1,746 |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_inverse_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
#align tendsto_inverse_at_top_nhds_0_nat tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_inverse_atTop_nhds_0_nat := tendsto_inverse_atTop_nhds_zero_nat
| Mathlib/Analysis/SpecificLimits/Basic.lean | 39 | 41 | theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by |
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
| 1,747 |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_inverse_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
#align tendsto_inverse_at_top_nhds_0_nat tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_inverse_atTop_nhds_0_nat := tendsto_inverse_atTop_nhds_zero_nat
theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
#align tendsto_const_div_at_top_nhds_0_nat tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_const_div_atTop_nhds_0_nat := tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ 1/(n : β)) atTop (π 0) :=
tendsto_const_div_atTop_nhds_zero_nat 1
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_atTop_nhds_0_nat := tendsto_one_div_atTop_nhds_zero_nat
| Mathlib/Analysis/SpecificLimits/Basic.lean | 51 | 54 | theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by |
rw [β NNReal.tendsto_coe]
exact _root_.tendsto_inverse_atTop_nhds_zero_nat
| 1,747 |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_inverse_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
#align tendsto_inverse_at_top_nhds_0_nat tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_inverse_atTop_nhds_0_nat := tendsto_inverse_atTop_nhds_zero_nat
theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
#align tendsto_const_div_at_top_nhds_0_nat tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_const_div_atTop_nhds_0_nat := tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ 1/(n : β)) atTop (π 0) :=
tendsto_const_div_atTop_nhds_zero_nat 1
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_atTop_nhds_0_nat := tendsto_one_div_atTop_nhds_zero_nat
theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by
rw [β NNReal.tendsto_coe]
exact _root_.tendsto_inverse_atTop_nhds_zero_nat
#align nnreal.tendsto_inverse_at_top_nhds_0_nat NNReal.tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_inverse_atTop_nhds_0_nat := NNReal.tendsto_inverse_atTop_nhds_zero_nat
| Mathlib/Analysis/SpecificLimits/Basic.lean | 59 | 61 | theorem NNReal.tendsto_const_div_atTop_nhds_zero_nat (C : ββ₯0) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by |
simpa using tendsto_const_nhds.mul NNReal.tendsto_inverse_atTop_nhds_zero_nat
| 1,747 |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_inverse_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
#align tendsto_inverse_at_top_nhds_0_nat tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_inverse_atTop_nhds_0_nat := tendsto_inverse_atTop_nhds_zero_nat
theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
#align tendsto_const_div_at_top_nhds_0_nat tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_const_div_atTop_nhds_0_nat := tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ 1/(n : β)) atTop (π 0) :=
tendsto_const_div_atTop_nhds_zero_nat 1
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_atTop_nhds_0_nat := tendsto_one_div_atTop_nhds_zero_nat
theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by
rw [β NNReal.tendsto_coe]
exact _root_.tendsto_inverse_atTop_nhds_zero_nat
#align nnreal.tendsto_inverse_at_top_nhds_0_nat NNReal.tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_inverse_atTop_nhds_0_nat := NNReal.tendsto_inverse_atTop_nhds_zero_nat
theorem NNReal.tendsto_const_div_atTop_nhds_zero_nat (C : ββ₯0) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa using tendsto_const_nhds.mul NNReal.tendsto_inverse_atTop_nhds_zero_nat
#align nnreal.tendsto_const_div_at_top_nhds_0_nat NNReal.tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_const_div_atTop_nhds_0_nat := NNReal.tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_add_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ 1 / ((n : β) + 1)) atTop (π 0) :=
suffices Tendsto (fun n : β β¦ 1 / (β(n + 1) : β)) atTop (π 0) by simpa
(tendsto_add_atTop_iff_nat 1).2 (_root_.tendsto_const_div_atTop_nhds_zero_nat 1)
#align tendsto_one_div_add_at_top_nhds_0_nat tendsto_one_div_add_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_add_atTop_nhds_0_nat := tendsto_one_div_add_atTop_nhds_zero_nat
| Mathlib/Analysis/SpecificLimits/Basic.lean | 74 | 79 | theorem NNReal.tendsto_algebraMap_inverse_atTop_nhds_zero_nat (π : Type*) [Semiring π]
[Algebra ββ₯0 π] [TopologicalSpace π] [ContinuousSMul ββ₯0 π] :
Tendsto (algebraMap ββ₯0 π β fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by |
convert (continuous_algebraMap ββ₯0 π).continuousAt.tendsto.comp
tendsto_inverse_atTop_nhds_zero_nat
rw [map_zero]
| 1,747 |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_inverse_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
tendsto_inv_atTop_zero.comp tendsto_natCast_atTop_atTop
#align tendsto_inverse_at_top_nhds_0_nat tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_inverse_atTop_nhds_0_nat := tendsto_inverse_atTop_nhds_zero_nat
theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
#align tendsto_const_div_at_top_nhds_0_nat tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_const_div_atTop_nhds_0_nat := tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_atTop_nhds_zero_nat : Tendsto (fun n : β β¦ 1/(n : β)) atTop (π 0) :=
tendsto_const_div_atTop_nhds_zero_nat 1
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_atTop_nhds_0_nat := tendsto_one_div_atTop_nhds_zero_nat
theorem NNReal.tendsto_inverse_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by
rw [β NNReal.tendsto_coe]
exact _root_.tendsto_inverse_atTop_nhds_zero_nat
#align nnreal.tendsto_inverse_at_top_nhds_0_nat NNReal.tendsto_inverse_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_inverse_atTop_nhds_0_nat := NNReal.tendsto_inverse_atTop_nhds_zero_nat
theorem NNReal.tendsto_const_div_atTop_nhds_zero_nat (C : ββ₯0) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by
simpa using tendsto_const_nhds.mul NNReal.tendsto_inverse_atTop_nhds_zero_nat
#align nnreal.tendsto_const_div_at_top_nhds_0_nat NNReal.tendsto_const_div_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_const_div_atTop_nhds_0_nat := NNReal.tendsto_const_div_atTop_nhds_zero_nat
theorem tendsto_one_div_add_atTop_nhds_zero_nat :
Tendsto (fun n : β β¦ 1 / ((n : β) + 1)) atTop (π 0) :=
suffices Tendsto (fun n : β β¦ 1 / (β(n + 1) : β)) atTop (π 0) by simpa
(tendsto_add_atTop_iff_nat 1).2 (_root_.tendsto_const_div_atTop_nhds_zero_nat 1)
#align tendsto_one_div_add_at_top_nhds_0_nat tendsto_one_div_add_atTop_nhds_zero_nat
@[deprecated (since := "2024-01-31")]
alias tendsto_one_div_add_atTop_nhds_0_nat := tendsto_one_div_add_atTop_nhds_zero_nat
theorem NNReal.tendsto_algebraMap_inverse_atTop_nhds_zero_nat (π : Type*) [Semiring π]
[Algebra ββ₯0 π] [TopologicalSpace π] [ContinuousSMul ββ₯0 π] :
Tendsto (algebraMap ββ₯0 π β fun n : β β¦ (n : ββ₯0)β»ΒΉ) atTop (π 0) := by
convert (continuous_algebraMap ββ₯0 π).continuousAt.tendsto.comp
tendsto_inverse_atTop_nhds_zero_nat
rw [map_zero]
@[deprecated (since := "2024-01-31")]
alias NNReal.tendsto_algebraMap_inverse_atTop_nhds_0_nat :=
NNReal.tendsto_algebraMap_inverse_atTop_nhds_zero_nat
theorem tendsto_algebraMap_inverse_atTop_nhds_zero_nat (π : Type*) [Semiring π] [Algebra β π]
[TopologicalSpace π] [ContinuousSMul β π] :
Tendsto (algebraMap β π β fun n : β β¦ (n : β)β»ΒΉ) atTop (π 0) :=
NNReal.tendsto_algebraMap_inverse_atTop_nhds_zero_nat π
@[deprecated (since := "2024-01-31")]
alias tendsto_algebraMap_inverse_atTop_nhds_0_nat :=
_root_.tendsto_algebraMap_inverse_atTop_nhds_zero_nat
| Mathlib/Analysis/SpecificLimits/Basic.lean | 97 | 113 | theorem tendsto_natCast_div_add_atTop {π : Type*} [DivisionRing π] [TopologicalSpace π]
[CharZero π] [Algebra β π] [ContinuousSMul β π] [TopologicalDivisionRing π] (x : π) :
Tendsto (fun n : β β¦ (n : π) / (n + x)) atTop (π 1) := by |
convert Tendsto.congr' ((eventually_ne_atTop 0).mp (eventually_of_forall fun n hn β¦ _)) _
Β· exact fun n : β β¦ 1 / (1 + x / n)
Β· field_simp [Nat.cast_ne_zero.mpr hn]
Β· have : π (1 : π) = π (1 / (1 + x * (0 : π))) := by
rw [mul_zero, add_zero, div_one]
rw [this]
refine tendsto_const_nhds.div (tendsto_const_nhds.add ?_) (by simp)
simp_rw [div_eq_mul_inv]
refine tendsto_const_nhds.mul ?_
have := ((continuous_algebraMap β π).tendsto _).comp tendsto_inverse_atTop_nhds_zero_nat
rw [map_zero, Filter.tendsto_atTop'] at this
refine Iff.mpr tendsto_atTop' ?_
intros
simp_all only [comp_apply, map_invβ, map_natCast]
| 1,747 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.specific_limits.floor_pow from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Filter Finset
open Topology
| Mathlib/Analysis/SpecificLimits/FloorPow.lean | 28 | 182 | theorem tendsto_div_of_monotone_of_exists_subseq_tendsto_div (u : β β β) (l : β)
(hmono : Monotone u)
(hlim : β a : β, 1 < a β β c : β β β, (βαΆ n in atTop, (c (n + 1) : β) β€ a * c n) β§
Tendsto c atTop atTop β§ Tendsto (fun n => u (c n) / c n) atTop (π l)) :
Tendsto (fun n => u n / n) atTop (π l) := by |
/- To check the result up to some `Ξ΅ > 0`, we use a sequence `c` for which the ratio
`c (N+1) / c N` is bounded by `1 + Ξ΅`. Sandwiching a given `n` between two consecutive values of
`c`, say `c N` and `c (N+1)`, one can then bound `u n / n` from above by `u (c N) / c (N - 1)`
and from below by `u (c (N - 1)) / c N` (using that `u` is monotone), which are both comparable
to the limit `l` up to `1 + Ξ΅`.
We give a version of this proof by clearing out denominators first, to avoid discussing the sign
of different quantities. -/
have lnonneg : 0 β€ l := by
rcases hlim 2 one_lt_two with β¨c, _, ctop, climβ©
have : Tendsto (fun n => u 0 / c n) atTop (π 0) :=
tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_iff.2 ctop)
apply le_of_tendsto_of_tendsto' this clim fun n => ?_
gcongr
exact hmono (zero_le _)
have A : β Ξ΅ : β, 0 < Ξ΅ β βαΆ n in atTop, u n - n * l β€ Ξ΅ * (1 + Ξ΅ + l) * n := by
intro Ξ΅ Ξ΅pos
rcases hlim (1 + Ξ΅) ((lt_add_iff_pos_right _).2 Ξ΅pos) with β¨c, cgrowth, ctop, climβ©
have L : βαΆ n in atTop, u (c n) - c n * l β€ Ξ΅ * c n := by
rw [β tendsto_sub_nhds_zero_iff, β Asymptotics.isLittleO_one_iff β,
Asymptotics.isLittleO_iff] at clim
filter_upwards [clim Ξ΅pos, ctop (Ioi_mem_atTop 0)] with n hn cnpos'
have cnpos : 0 < c n := cnpos'
calc
u (c n) - c n * l = (u (c n) / c n - l) * c n := by
simp only [cnpos.ne', Ne, Nat.cast_eq_zero, not_false_iff, field_simps]
_ β€ Ξ΅ * c n := by
gcongr
refine (le_abs_self _).trans ?_
simpa using hn
obtain β¨a, haβ© :
β a : β, β b : β, a β€ b β (c (b + 1) : β) β€ (1 + Ξ΅) * c b β§ u (c b) - c b * l β€ Ξ΅ * c b :=
eventually_atTop.1 (cgrowth.and L)
let M := ((Finset.range (a + 1)).image fun i => c i).max' (by simp)
filter_upwards [Ici_mem_atTop M] with n hn
have exN : β N, n < c N := by
rcases (tendsto_atTop.1 ctop (n + 1)).exists with β¨N, hNβ©
exact β¨N, by linarith only [hN]β©
let N := Nat.find exN
have ncN : n < c N := Nat.find_spec exN
have aN : a + 1 β€ N := by
by_contra! h
have cNM : c N β€ M := by
apply le_max'
apply mem_image_of_mem
exact mem_range.2 h
exact lt_irrefl _ ((cNM.trans hn).trans_lt ncN)
have Npos : 0 < N := lt_of_lt_of_le Nat.succ_pos' aN
have cNn : c (N - 1) β€ n := by
have : N - 1 < N := Nat.pred_lt Npos.ne'
simpa only [not_lt] using Nat.find_min exN this
have IcN : (c N : β) β€ (1 + Ξ΅) * c (N - 1) := by
have A : a β€ N - 1 := by
apply @Nat.le_of_add_le_add_right a 1 (N - 1)
rw [Nat.sub_add_cancel Npos]
exact aN
have B : N - 1 + 1 = N := Nat.succ_pred_eq_of_pos Npos
have := (ha _ A).1
rwa [B] at this
calc
u n - n * l β€ u (c N) - c (N - 1) * l := by gcongr; exact hmono ncN.le
_ = u (c N) - c N * l + (c N - c (N - 1)) * l := by ring
_ β€ Ξ΅ * c N + Ξ΅ * c (N - 1) * l := by
gcongr
Β· exact (ha N (a.le_succ.trans aN)).2
Β· linarith only [IcN]
_ β€ Ξ΅ * ((1 + Ξ΅) * c (N - 1)) + Ξ΅ * c (N - 1) * l := by gcongr
_ = Ξ΅ * (1 + Ξ΅ + l) * c (N - 1) := by ring
_ β€ Ξ΅ * (1 + Ξ΅ + l) * n := by gcongr
have B : β Ξ΅ : β, 0 < Ξ΅ β βαΆ n : β in atTop, (n : β) * l - u n β€ Ξ΅ * (1 + l) * n := by
intro Ξ΅ Ξ΅pos
rcases hlim (1 + Ξ΅) ((lt_add_iff_pos_right _).2 Ξ΅pos) with β¨c, cgrowth, ctop, climβ©
have L : βαΆ n : β in atTop, (c n : β) * l - u (c n) β€ Ξ΅ * c n := by
rw [β tendsto_sub_nhds_zero_iff, β Asymptotics.isLittleO_one_iff β,
Asymptotics.isLittleO_iff] at clim
filter_upwards [clim Ξ΅pos, ctop (Ioi_mem_atTop 0)] with n hn cnpos'
have cnpos : 0 < c n := cnpos'
calc
(c n : β) * l - u (c n) = -(u (c n) / c n - l) * c n := by
simp only [cnpos.ne', Ne, Nat.cast_eq_zero, not_false_iff, neg_sub, field_simps]
_ β€ Ξ΅ * c n := by
gcongr
refine le_trans (neg_le_abs _) ?_
simpa using hn
obtain β¨a, haβ© :
β a : β,
β b : β, a β€ b β (c (b + 1) : β) β€ (1 + Ξ΅) * c b β§ (c b : β) * l - u (c b) β€ Ξ΅ * c b :=
eventually_atTop.1 (cgrowth.and L)
let M := ((Finset.range (a + 1)).image fun i => c i).max' (by simp)
filter_upwards [Ici_mem_atTop M] with n hn
have exN : β N, n < c N := by
rcases (tendsto_atTop.1 ctop (n + 1)).exists with β¨N, hNβ©
exact β¨N, by linarith only [hN]β©
let N := Nat.find exN
have ncN : n < c N := Nat.find_spec exN
have aN : a + 1 β€ N := by
by_contra! h
have cNM : c N β€ M := by
apply le_max'
apply mem_image_of_mem
exact mem_range.2 h
exact lt_irrefl _ ((cNM.trans hn).trans_lt ncN)
have Npos : 0 < N := lt_of_lt_of_le Nat.succ_pos' aN
have aN' : a β€ N - 1 := by
apply @Nat.le_of_add_le_add_right a 1 (N - 1)
rw [Nat.sub_add_cancel Npos]
exact aN
have cNn : c (N - 1) β€ n := by
have : N - 1 < N := Nat.pred_lt Npos.ne'
simpa only [not_lt] using Nat.find_min exN this
calc
(n : β) * l - u n β€ c N * l - u (c (N - 1)) := by
gcongr
exact hmono cNn
_ β€ (1 + Ξ΅) * c (N - 1) * l - u (c (N - 1)) := by
gcongr
have B : N - 1 + 1 = N := Nat.succ_pred_eq_of_pos Npos
simpa [B] using (ha _ aN').1
_ = c (N - 1) * l - u (c (N - 1)) + Ξ΅ * c (N - 1) * l := by ring
_ β€ Ξ΅ * c (N - 1) + Ξ΅ * c (N - 1) * l := add_le_add (ha _ aN').2 le_rfl
_ = Ξ΅ * (1 + l) * c (N - 1) := by ring
_ β€ Ξ΅ * (1 + l) * n := by gcongr
refine tendsto_order.2 β¨fun d hd => ?_, fun d hd => ?_β©
Β· obtain β¨Ξ΅, hΞ΅, Ξ΅posβ© : β Ξ΅ : β, d + Ξ΅ * (1 + l) < l β§ 0 < Ξ΅ := by
have L : Tendsto (fun Ξ΅ => d + Ξ΅ * (1 + l)) (π[>] 0) (π (d + 0 * (1 + l))) := by
apply Tendsto.mono_left _ nhdsWithin_le_nhds
exact tendsto_const_nhds.add (tendsto_id.mul tendsto_const_nhds)
simp only [zero_mul, add_zero] at L
exact (((tendsto_order.1 L).2 l hd).and self_mem_nhdsWithin).exists
filter_upwards [B Ξ΅ Ξ΅pos, Ioi_mem_atTop 0] with n hn npos
simp_rw [div_eq_inv_mul]
calc
d < (n : β)β»ΒΉ * n * (l - Ξ΅ * (1 + l)) := by
rw [inv_mul_cancel, one_mul]
Β· linarith only [hΞ΅]
Β· exact Nat.cast_ne_zero.2 (ne_of_gt npos)
_ = (n : β)β»ΒΉ * (n * l - Ξ΅ * (1 + l) * n) := by ring
_ β€ (n : β)β»ΒΉ * u n := by gcongr; linarith only [hn]
Β· obtain β¨Ξ΅, hΞ΅, Ξ΅posβ© : β Ξ΅ : β, l + Ξ΅ * (1 + Ξ΅ + l) < d β§ 0 < Ξ΅ := by
have L : Tendsto (fun Ξ΅ => l + Ξ΅ * (1 + Ξ΅ + l)) (π[>] 0) (π (l + 0 * (1 + 0 + l))) := by
apply Tendsto.mono_left _ nhdsWithin_le_nhds
exact
tendsto_const_nhds.add
(tendsto_id.mul ((tendsto_const_nhds.add tendsto_id).add tendsto_const_nhds))
simp only [zero_mul, add_zero] at L
exact (((tendsto_order.1 L).2 d hd).and self_mem_nhdsWithin).exists
filter_upwards [A Ξ΅ Ξ΅pos, Ioi_mem_atTop 0] with n hn (npos : 0 < n)
calc
u n / n β€ (n * l + Ξ΅ * (1 + Ξ΅ + l) * n) / n := by gcongr; linarith only [hn]
_ = (l + Ξ΅ * (1 + Ξ΅ + l)) := by field_simp; ring
_ < d := hΞ΅
| 1,748 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Analysis.RCLike.Basic
open Set Algebra Filter
open scoped Topology
variable (π : Type*) [RCLike π]
| Mathlib/Analysis/SpecificLimits/RCLike.lean | 19 | 22 | theorem RCLike.tendsto_inverse_atTop_nhds_zero_nat :
Tendsto (fun n : β => (n : π)β»ΒΉ) atTop (π 0) := by |
convert tendsto_algebraMap_inverse_atTop_nhds_zero_nat π
simp
| 1,749 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Iterate
import Mathlib.Order.SemiconjSup
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Order.MonotoneContinuity
#align_import dynamics.circle.rotation_number.translation_number from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open Filter Set Int Topology
open Function hiding Commute
structure CircleDeg1Lift extends β βo β : Type where
map_add_one' : β x, toFun (x + 1) = toFun x + 1
#align circle_deg1_lift CircleDeg1Lift
namespace CircleDeg1Lift
instance : FunLike CircleDeg1Lift β β where
coe f := f.toFun
coe_injective' | β¨β¨_, _β©, _β©, β¨β¨_, _β©, _β©, rfl => rfl
instance : OrderHomClass CircleDeg1Lift β β where
map_rel f _ _ h := f.monotone' h
@[simp] theorem coe_mk (f h) : β(mk f h) = f := rfl
#align circle_deg1_lift.coe_mk CircleDeg1Lift.coe_mk
variable (f g : CircleDeg1Lift)
@[simp] theorem coe_toOrderHom : βf.toOrderHom = f := rfl
protected theorem monotone : Monotone f := f.monotone'
#align circle_deg1_lift.monotone CircleDeg1Lift.monotone
@[mono] theorem mono {x y} (h : x β€ y) : f x β€ f y := f.monotone h
#align circle_deg1_lift.mono CircleDeg1Lift.mono
theorem strictMono_iff_injective : StrictMono f β Injective f :=
f.monotone.strictMono_iff_injective
#align circle_deg1_lift.strict_mono_iff_injective CircleDeg1Lift.strictMono_iff_injective
@[simp]
theorem map_add_one : β x, f (x + 1) = f x + 1 :=
f.map_add_one'
#align circle_deg1_lift.map_add_one CircleDeg1Lift.map_add_one
@[simp]
| Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean | 167 | 167 | theorem map_one_add (x : β) : f (1 + x) = 1 + f x := by | rw [add_comm, map_add_one, add_comm 1]
| 1,750 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Iterate
import Mathlib.Order.SemiconjSup
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Order.MonotoneContinuity
#align_import dynamics.circle.rotation_number.translation_number from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open Filter Set Int Topology
open Function hiding Commute
structure CircleDeg1Lift extends β βo β : Type where
map_add_one' : β x, toFun (x + 1) = toFun x + 1
#align circle_deg1_lift CircleDeg1Lift
namespace CircleDeg1Lift
instance : FunLike CircleDeg1Lift β β where
coe f := f.toFun
coe_injective' | β¨β¨_, _β©, _β©, β¨β¨_, _β©, _β©, rfl => rfl
instance : OrderHomClass CircleDeg1Lift β β where
map_rel f _ _ h := f.monotone' h
@[simp] theorem coe_mk (f h) : β(mk f h) = f := rfl
#align circle_deg1_lift.coe_mk CircleDeg1Lift.coe_mk
variable (f g : CircleDeg1Lift)
@[simp] theorem coe_toOrderHom : βf.toOrderHom = f := rfl
protected theorem monotone : Monotone f := f.monotone'
#align circle_deg1_lift.monotone CircleDeg1Lift.monotone
@[mono] theorem mono {x y} (h : x β€ y) : f x β€ f y := f.monotone h
#align circle_deg1_lift.mono CircleDeg1Lift.mono
theorem strictMono_iff_injective : StrictMono f β Injective f :=
f.monotone.strictMono_iff_injective
#align circle_deg1_lift.strict_mono_iff_injective CircleDeg1Lift.strictMono_iff_injective
@[simp]
theorem map_add_one : β x, f (x + 1) = f x + 1 :=
f.map_add_one'
#align circle_deg1_lift.map_add_one CircleDeg1Lift.map_add_one
@[simp]
theorem map_one_add (x : β) : f (1 + x) = 1 + f x := by rw [add_comm, map_add_one, add_comm 1]
#align circle_deg1_lift.map_one_add CircleDeg1Lift.map_one_add
#noalign circle_deg1_lift.coe_inj -- Use `DFunLike.coe_inj`
@[ext]
theorem ext β¦f g : CircleDeg1Liftβ¦ (h : β x, f x = g x) : f = g :=
DFunLike.ext f g h
#align circle_deg1_lift.ext CircleDeg1Lift.ext
theorem ext_iff {f g : CircleDeg1Lift} : f = g β β x, f x = g x :=
DFunLike.ext_iff
#align circle_deg1_lift.ext_iff CircleDeg1Lift.ext_iff
instance : Monoid CircleDeg1Lift where
mul f g :=
{ toOrderHom := f.1.comp g.1
map_add_one' := fun x => by simp [map_add_one] }
one := β¨.id, fun _ => rflβ©
mul_one f := rfl
one_mul f := rfl
mul_assoc fβ fβ fβ := DFunLike.coe_injective rfl
instance : Inhabited CircleDeg1Lift := β¨1β©
@[simp]
theorem coe_mul : β(f * g) = f β g :=
rfl
#align circle_deg1_lift.coe_mul CircleDeg1Lift.coe_mul
theorem mul_apply (x) : (f * g) x = f (g x) :=
rfl
#align circle_deg1_lift.mul_apply CircleDeg1Lift.mul_apply
@[simp]
theorem coe_one : β(1 : CircleDeg1Lift) = id :=
rfl
#align circle_deg1_lift.coe_one CircleDeg1Lift.coe_one
instance unitsHasCoeToFun : CoeFun CircleDeg1LiftΛ£ fun _ => β β β :=
β¨fun f => β(f : CircleDeg1Lift)β©
#align circle_deg1_lift.units_has_coe_to_fun CircleDeg1Lift.unitsHasCoeToFun
#noalign circle_deg1_lift.units_coe -- now LHS = RHS
@[simp]
| Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean | 213 | 214 | theorem units_inv_apply_apply (f : CircleDeg1LiftΛ£) (x : β) :
(fβ»ΒΉ : CircleDeg1LiftΛ£) (f x) = x := by | simp only [β mul_apply, f.inv_mul, coe_one, id]
| 1,750 |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Iterate
import Mathlib.Order.SemiconjSup
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Order.MonotoneContinuity
#align_import dynamics.circle.rotation_number.translation_number from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open Filter Set Int Topology
open Function hiding Commute
structure CircleDeg1Lift extends β βo β : Type where
map_add_one' : β x, toFun (x + 1) = toFun x + 1
#align circle_deg1_lift CircleDeg1Lift
namespace CircleDeg1Lift
instance : FunLike CircleDeg1Lift β β where
coe f := f.toFun
coe_injective' | β¨β¨_, _β©, _β©, β¨β¨_, _β©, _β©, rfl => rfl
instance : OrderHomClass CircleDeg1Lift β β where
map_rel f _ _ h := f.monotone' h
@[simp] theorem coe_mk (f h) : β(mk f h) = f := rfl
#align circle_deg1_lift.coe_mk CircleDeg1Lift.coe_mk
variable (f g : CircleDeg1Lift)
@[simp] theorem coe_toOrderHom : βf.toOrderHom = f := rfl
protected theorem monotone : Monotone f := f.monotone'
#align circle_deg1_lift.monotone CircleDeg1Lift.monotone
@[mono] theorem mono {x y} (h : x β€ y) : f x β€ f y := f.monotone h
#align circle_deg1_lift.mono CircleDeg1Lift.mono
theorem strictMono_iff_injective : StrictMono f β Injective f :=
f.monotone.strictMono_iff_injective
#align circle_deg1_lift.strict_mono_iff_injective CircleDeg1Lift.strictMono_iff_injective
@[simp]
theorem map_add_one : β x, f (x + 1) = f x + 1 :=
f.map_add_one'
#align circle_deg1_lift.map_add_one CircleDeg1Lift.map_add_one
@[simp]
theorem map_one_add (x : β) : f (1 + x) = 1 + f x := by rw [add_comm, map_add_one, add_comm 1]
#align circle_deg1_lift.map_one_add CircleDeg1Lift.map_one_add
#noalign circle_deg1_lift.coe_inj -- Use `DFunLike.coe_inj`
@[ext]
theorem ext β¦f g : CircleDeg1Liftβ¦ (h : β x, f x = g x) : f = g :=
DFunLike.ext f g h
#align circle_deg1_lift.ext CircleDeg1Lift.ext
theorem ext_iff {f g : CircleDeg1Lift} : f = g β β x, f x = g x :=
DFunLike.ext_iff
#align circle_deg1_lift.ext_iff CircleDeg1Lift.ext_iff
instance : Monoid CircleDeg1Lift where
mul f g :=
{ toOrderHom := f.1.comp g.1
map_add_one' := fun x => by simp [map_add_one] }
one := β¨.id, fun _ => rflβ©
mul_one f := rfl
one_mul f := rfl
mul_assoc fβ fβ fβ := DFunLike.coe_injective rfl
instance : Inhabited CircleDeg1Lift := β¨1β©
@[simp]
theorem coe_mul : β(f * g) = f β g :=
rfl
#align circle_deg1_lift.coe_mul CircleDeg1Lift.coe_mul
theorem mul_apply (x) : (f * g) x = f (g x) :=
rfl
#align circle_deg1_lift.mul_apply CircleDeg1Lift.mul_apply
@[simp]
theorem coe_one : β(1 : CircleDeg1Lift) = id :=
rfl
#align circle_deg1_lift.coe_one CircleDeg1Lift.coe_one
instance unitsHasCoeToFun : CoeFun CircleDeg1LiftΛ£ fun _ => β β β :=
β¨fun f => β(f : CircleDeg1Lift)β©
#align circle_deg1_lift.units_has_coe_to_fun CircleDeg1Lift.unitsHasCoeToFun
#noalign circle_deg1_lift.units_coe -- now LHS = RHS
@[simp]
theorem units_inv_apply_apply (f : CircleDeg1LiftΛ£) (x : β) :
(fβ»ΒΉ : CircleDeg1LiftΛ£) (f x) = x := by simp only [β mul_apply, f.inv_mul, coe_one, id]
#align circle_deg1_lift.units_inv_apply_apply CircleDeg1Lift.units_inv_apply_apply
@[simp]
| Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean | 218 | 219 | theorem units_apply_inv_apply (f : CircleDeg1LiftΛ£) (x : β) :
f ((fβ»ΒΉ : CircleDeg1LiftΛ£) x) = x := by | simp only [β mul_apply, f.mul_inv, coe_one, id]
| 1,750 |
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.hofer from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open Topology
open Filter Finset
local notation "d" => dist
#noalign pos_div_pow_pos
| Mathlib/Analysis/Hofer.lean | 33 | 104 | theorem hofer {X : Type*} [MetricSpace X] [CompleteSpace X] (x : X) (Ξ΅ : β) (Ξ΅_pos : 0 < Ξ΅)
{Ο : X β β} (cont : Continuous Ο) (nonneg : β y, 0 β€ Ο y) : β Ξ΅' > 0, β x' : X,
Ξ΅' β€ Ξ΅ β§ d x' x β€ 2 * Ξ΅ β§ Ξ΅ * Ο x β€ Ξ΅' * Ο x' β§ β y, d x' y β€ Ξ΅' β Ο y β€ 2 * Ο x' := by |
by_contra H
have reformulation : β (x') (k : β), Ξ΅ * Ο x β€ Ξ΅ / 2 ^ k * Ο x' β 2 ^ k * Ο x β€ Ο x' := by
intro x' k
rw [div_mul_eq_mul_div, le_div_iff, mul_assoc, mul_le_mul_left Ξ΅_pos, mul_comm]
positivity
-- Now let's specialize to `Ξ΅/2^k`
replace H : β k : β, β x', d x' x β€ 2 * Ξ΅ β§ 2 ^ k * Ο x β€ Ο x' β
β y, d x' y β€ Ξ΅ / 2 ^ k β§ 2 * Ο x' < Ο y := by
intro k x'
push_neg at H
have := H (Ξ΅ / 2 ^ k) (by positivity) x' (by simp [Ξ΅_pos.le, one_le_two])
simpa [reformulation] using this
clear reformulation
haveI : Nonempty X := β¨xβ©
choose! F hF using H
-- Use the axiom of choice
-- Now define u by induction starting at x, with u_{n+1} = F(n, u_n)
let u : β β X := fun n => Nat.recOn n x F
-- The properties of F translate to properties of u
have hu :
β n,
d (u n) x β€ 2 * Ξ΅ β§ 2 ^ n * Ο x β€ Ο (u n) β
d (u n) (u <| n + 1) β€ Ξ΅ / 2 ^ n β§ 2 * Ο (u n) < Ο (u <| n + 1) := by
intro n
exact hF n (u n)
clear hF
-- Key properties of u, to be proven by induction
have key : β n, d (u n) (u (n + 1)) β€ Ξ΅ / 2 ^ n β§ 2 * Ο (u n) < Ο (u (n + 1)) := by
intro n
induction' n using Nat.case_strong_induction_on with n IH
Β· simpa [u, Ξ΅_pos.le] using hu 0
have A : d (u (n + 1)) x β€ 2 * Ξ΅ := by
rw [dist_comm]
let r := range (n + 1) -- range (n+1) = {0, ..., n}
calc
d (u 0) (u (n + 1)) β€ β i β r, d (u i) (u <| i + 1) := dist_le_range_sum_dist u (n + 1)
_ β€ β i β r, Ξ΅ / 2 ^ i :=
(sum_le_sum fun i i_in => (IH i <| Nat.lt_succ_iff.mp <| Finset.mem_range.mp i_in).1)
_ = (β i β r, (1 / 2 : β) ^ i) * Ξ΅ := by
rw [Finset.sum_mul]
congr with i
field_simp
_ β€ 2 * Ξ΅ := by gcongr; apply sum_geometric_two_le
have B : 2 ^ (n + 1) * Ο x β€ Ο (u (n + 1)) := by
refine @geom_le (Ο β u) _ zero_le_two (n + 1) fun m hm => ?_
exact (IH _ <| Nat.lt_add_one_iff.1 hm).2.le
exact hu (n + 1) β¨A, Bβ©
cases' forall_and.mp key with keyβ keyβ
clear hu key
-- Hence u is Cauchy
have cauchy_u : CauchySeq u := by
refine cauchySeq_of_le_geometric _ Ξ΅ one_half_lt_one fun n => ?_
simpa only [one_div, inv_pow] using keyβ n
-- So u converges to some y
obtain β¨y, limyβ© : β y, Tendsto u atTop (π y) := CompleteSpace.complete cauchy_u
-- And Ο β u goes to +β
have lim_top : Tendsto (Ο β u) atTop atTop := by
let v n := (Ο β u) (n + 1)
suffices Tendsto v atTop atTop by rwa [tendsto_add_atTop_iff_nat] at this
have hvβ : 0 < v 0 := by
calc
0 β€ 2 * Ο (u 0) := by specialize nonneg x; positivity
_ < Ο (u (0 + 1)) := keyβ 0
apply tendsto_atTop_of_geom_le hvβ one_lt_two
exact fun n => (keyβ (n + 1)).le
-- But Ο β u also needs to go to Ο(y)
have lim : Tendsto (Ο β u) atTop (π (Ο y)) := Tendsto.comp cont.continuousAt limy
-- So we have our contradiction!
exact not_tendsto_atTop_of_tendsto_nhds lim lim_top
| 1,751 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Setoid.Basic
import Mathlib.Dynamics.FixedPoints.Topology
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.contracting from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open NNReal Topology ENNReal Filter Function
variable {Ξ± : Type*}
def ContractingWith [EMetricSpace Ξ±] (K : ββ₯0) (f : Ξ± β Ξ±) :=
K < 1 β§ LipschitzWith K f
#align contracting_with ContractingWith
namespace ContractingWith
variable [EMetricSpace Ξ±] [cs : CompleteSpace Ξ±] {K : ββ₯0} {f : Ξ± β Ξ±}
open EMetric Set
theorem toLipschitzWith (hf : ContractingWith K f) : LipschitzWith K f := hf.2
#align contracting_with.to_lipschitz_with ContractingWith.toLipschitzWith
| Mathlib/Topology/MetricSpace/Contracting.lean | 53 | 53 | theorem one_sub_K_pos' (hf : ContractingWith K f) : (0 : ββ₯0β) < 1 - K := by | simp [hf.1]
| 1,752 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Setoid.Basic
import Mathlib.Dynamics.FixedPoints.Topology
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.contracting from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open NNReal Topology ENNReal Filter Function
variable {Ξ± : Type*}
def ContractingWith [EMetricSpace Ξ±] (K : ββ₯0) (f : Ξ± β Ξ±) :=
K < 1 β§ LipschitzWith K f
#align contracting_with ContractingWith
namespace ContractingWith
variable [EMetricSpace Ξ±] [cs : CompleteSpace Ξ±] {K : ββ₯0} {f : Ξ± β Ξ±}
open EMetric Set
theorem toLipschitzWith (hf : ContractingWith K f) : LipschitzWith K f := hf.2
#align contracting_with.to_lipschitz_with ContractingWith.toLipschitzWith
theorem one_sub_K_pos' (hf : ContractingWith K f) : (0 : ββ₯0β) < 1 - K := by simp [hf.1]
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_pos' ContractingWith.one_sub_K_pos'
theorem one_sub_K_ne_zero (hf : ContractingWith K f) : (1 : ββ₯0β) - K β 0 :=
ne_of_gt hf.one_sub_K_pos'
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_zero ContractingWith.one_sub_K_ne_zero
| Mathlib/Topology/MetricSpace/Contracting.lean | 62 | 64 | theorem one_sub_K_ne_top : (1 : ββ₯0β) - K β β := by |
norm_cast
exact ENNReal.coe_ne_top
| 1,752 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Setoid.Basic
import Mathlib.Dynamics.FixedPoints.Topology
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.contracting from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open NNReal Topology ENNReal Filter Function
variable {Ξ± : Type*}
def ContractingWith [EMetricSpace Ξ±] (K : ββ₯0) (f : Ξ± β Ξ±) :=
K < 1 β§ LipschitzWith K f
#align contracting_with ContractingWith
namespace ContractingWith
variable [EMetricSpace Ξ±] [cs : CompleteSpace Ξ±] {K : ββ₯0} {f : Ξ± β Ξ±}
open EMetric Set
theorem toLipschitzWith (hf : ContractingWith K f) : LipschitzWith K f := hf.2
#align contracting_with.to_lipschitz_with ContractingWith.toLipschitzWith
theorem one_sub_K_pos' (hf : ContractingWith K f) : (0 : ββ₯0β) < 1 - K := by simp [hf.1]
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_pos' ContractingWith.one_sub_K_pos'
theorem one_sub_K_ne_zero (hf : ContractingWith K f) : (1 : ββ₯0β) - K β 0 :=
ne_of_gt hf.one_sub_K_pos'
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_zero ContractingWith.one_sub_K_ne_zero
theorem one_sub_K_ne_top : (1 : ββ₯0β) - K β β := by
norm_cast
exact ENNReal.coe_ne_top
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_top ContractingWith.one_sub_K_ne_top
| Mathlib/Topology/MetricSpace/Contracting.lean | 68 | 76 | theorem edist_inequality (hf : ContractingWith K f) {x y} (h : edist x y β β) :
edist x y β€ (edist x (f x) + edist y (f y)) / (1 - K) :=
suffices edist x y β€ edist x (f x) + edist y (f y) + K * edist x y by
rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
mul_comm, ENNReal.sub_mul fun _ _ β¦ h, one_mul, tsub_le_iff_right]
calc
edist x y β€ edist x (f x) + edist (f x) (f y) + edist (f y) y := edist_triangle4 _ _ _ _
_ = edist x (f x) + edist y (f y) + edist (f x) (f y) := by | rw [edist_comm y, add_right_comm]
_ β€ edist x (f x) + edist y (f y) + K * edist x y := add_le_add le_rfl (hf.2 _ _)
| 1,752 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Setoid.Basic
import Mathlib.Dynamics.FixedPoints.Topology
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.contracting from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open NNReal Topology ENNReal Filter Function
variable {Ξ± : Type*}
def ContractingWith [EMetricSpace Ξ±] (K : ββ₯0) (f : Ξ± β Ξ±) :=
K < 1 β§ LipschitzWith K f
#align contracting_with ContractingWith
namespace ContractingWith
variable [EMetricSpace Ξ±] [cs : CompleteSpace Ξ±] {K : ββ₯0} {f : Ξ± β Ξ±}
open EMetric Set
theorem toLipschitzWith (hf : ContractingWith K f) : LipschitzWith K f := hf.2
#align contracting_with.to_lipschitz_with ContractingWith.toLipschitzWith
theorem one_sub_K_pos' (hf : ContractingWith K f) : (0 : ββ₯0β) < 1 - K := by simp [hf.1]
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_pos' ContractingWith.one_sub_K_pos'
theorem one_sub_K_ne_zero (hf : ContractingWith K f) : (1 : ββ₯0β) - K β 0 :=
ne_of_gt hf.one_sub_K_pos'
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_zero ContractingWith.one_sub_K_ne_zero
theorem one_sub_K_ne_top : (1 : ββ₯0β) - K β β := by
norm_cast
exact ENNReal.coe_ne_top
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_top ContractingWith.one_sub_K_ne_top
theorem edist_inequality (hf : ContractingWith K f) {x y} (h : edist x y β β) :
edist x y β€ (edist x (f x) + edist y (f y)) / (1 - K) :=
suffices edist x y β€ edist x (f x) + edist y (f y) + K * edist x y by
rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
mul_comm, ENNReal.sub_mul fun _ _ β¦ h, one_mul, tsub_le_iff_right]
calc
edist x y β€ edist x (f x) + edist (f x) (f y) + edist (f y) y := edist_triangle4 _ _ _ _
_ = edist x (f x) + edist y (f y) + edist (f x) (f y) := by rw [edist_comm y, add_right_comm]
_ β€ edist x (f x) + edist y (f y) + K * edist x y := add_le_add le_rfl (hf.2 _ _)
#align contracting_with.edist_inequality ContractingWith.edist_inequality
| Mathlib/Topology/MetricSpace/Contracting.lean | 79 | 81 | theorem edist_le_of_fixedPoint (hf : ContractingWith K f) {x y} (h : edist x y β β)
(hy : IsFixedPt f y) : edist x y β€ edist x (f x) / (1 - K) := by |
simpa only [hy.eq, edist_self, add_zero] using hf.edist_inequality h
| 1,752 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Setoid.Basic
import Mathlib.Dynamics.FixedPoints.Topology
import Mathlib.Topology.MetricSpace.Lipschitz
#align_import topology.metric_space.contracting from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open scoped Classical
open NNReal Topology ENNReal Filter Function
variable {Ξ± : Type*}
def ContractingWith [EMetricSpace Ξ±] (K : ββ₯0) (f : Ξ± β Ξ±) :=
K < 1 β§ LipschitzWith K f
#align contracting_with ContractingWith
namespace ContractingWith
variable [EMetricSpace Ξ±] [cs : CompleteSpace Ξ±] {K : ββ₯0} {f : Ξ± β Ξ±}
open EMetric Set
theorem toLipschitzWith (hf : ContractingWith K f) : LipschitzWith K f := hf.2
#align contracting_with.to_lipschitz_with ContractingWith.toLipschitzWith
theorem one_sub_K_pos' (hf : ContractingWith K f) : (0 : ββ₯0β) < 1 - K := by simp [hf.1]
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_pos' ContractingWith.one_sub_K_pos'
theorem one_sub_K_ne_zero (hf : ContractingWith K f) : (1 : ββ₯0β) - K β 0 :=
ne_of_gt hf.one_sub_K_pos'
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_zero ContractingWith.one_sub_K_ne_zero
theorem one_sub_K_ne_top : (1 : ββ₯0β) - K β β := by
norm_cast
exact ENNReal.coe_ne_top
set_option linter.uppercaseLean3 false in
#align contracting_with.one_sub_K_ne_top ContractingWith.one_sub_K_ne_top
theorem edist_inequality (hf : ContractingWith K f) {x y} (h : edist x y β β) :
edist x y β€ (edist x (f x) + edist y (f y)) / (1 - K) :=
suffices edist x y β€ edist x (f x) + edist y (f y) + K * edist x y by
rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
mul_comm, ENNReal.sub_mul fun _ _ β¦ h, one_mul, tsub_le_iff_right]
calc
edist x y β€ edist x (f x) + edist (f x) (f y) + edist (f y) y := edist_triangle4 _ _ _ _
_ = edist x (f x) + edist y (f y) + edist (f x) (f y) := by rw [edist_comm y, add_right_comm]
_ β€ edist x (f x) + edist y (f y) + K * edist x y := add_le_add le_rfl (hf.2 _ _)
#align contracting_with.edist_inequality ContractingWith.edist_inequality
theorem edist_le_of_fixedPoint (hf : ContractingWith K f) {x y} (h : edist x y β β)
(hy : IsFixedPt f y) : edist x y β€ edist x (f x) / (1 - K) := by
simpa only [hy.eq, edist_self, add_zero] using hf.edist_inequality h
#align contracting_with.edist_le_of_fixed_point ContractingWith.edist_le_of_fixedPoint
| Mathlib/Topology/MetricSpace/Contracting.lean | 84 | 87 | theorem eq_or_edist_eq_top_of_fixedPoints (hf : ContractingWith K f) {x y} (hx : IsFixedPt f x)
(hy : IsFixedPt f y) : x = y β¨ edist x y = β := by |
refine or_iff_not_imp_right.2 fun h β¦ edist_le_zero.1 ?_
simpa only [hx.eq, edist_self, add_zero, ENNReal.zero_div] using hf.edist_le_of_fixedPoint h hy
| 1,752 |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
variable {X : Type*} [TopologicalSpace X]
open Set Filter TopologicalSpace Topology Filter
open scoped Pointwise
namespace Urysohns
set_option linter.uppercaseLean3 false
structure CU {X : Type*} [TopologicalSpace X] (P : Set X β Prop) where
protected C : Set X
protected U : Set X
protected P_C : P C
protected closed_C : IsClosed C
protected open_U : IsOpen U
protected subset : C β U
protected hP : β {c u : Set X}, IsClosed c β P c β IsOpen u β c β u β
β v, IsOpen v β§ c β v β§ closure v β u β§ P (closure v)
#align urysohns.CU Urysohns.CU
namespace CU
variable {P : Set X β Prop}
@[simps C]
def left (c : CU P) : CU P where
C := c.C
U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose
closed_C := c.closed_C
P_C := c.P_C
open_U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.1
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.1
hP := c.hP
#align urysohns.CU.left Urysohns.CU.left
@[simps U]
def right (c : CU P) : CU P where
C := closure (c.hP c.closed_C c.P_C c.open_U c.subset).choose
U := c.U
closed_C := isClosed_closure
P_C := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.2
open_U := c.open_U
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.1
hP := c.hP
#align urysohns.CU.right Urysohns.CU.right
theorem left_U_subset_right_C (c : CU P) : c.left.U β c.right.C :=
subset_closure
#align urysohns.CU.left_U_subset_right_C Urysohns.CU.left_U_subset_right_C
theorem left_U_subset (c : CU P) : c.left.U β c.U :=
Subset.trans c.left_U_subset_right_C c.right.subset
#align urysohns.CU.left_U_subset Urysohns.CU.left_U_subset
theorem subset_right_C (c : CU P) : c.C β c.right.C :=
Subset.trans c.left.subset c.left_U_subset_right_C
#align urysohns.CU.subset_right_C Urysohns.CU.subset_right_C
noncomputable def approx : β β CU P β X β β
| 0, c, x => indicator c.UαΆ 1 x
| n + 1, c, x => midpoint β (approx n c.left x) (approx n c.right x)
#align urysohns.CU.approx Urysohns.CU.approx
| Mathlib/Topology/UrysohnsLemma.lean | 161 | 166 | theorem approx_of_mem_C (c : CU P) (n : β) {x : X} (hx : x β c.C) : c.approx n x = 0 := by |
induction' n with n ihn generalizing c
Β· exact indicator_of_not_mem (fun (hU : x β c.UαΆ) => hU <| c.subset hx) _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [c.subset_right_C hx, hx]
| 1,753 |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
variable {X : Type*} [TopologicalSpace X]
open Set Filter TopologicalSpace Topology Filter
open scoped Pointwise
namespace Urysohns
set_option linter.uppercaseLean3 false
structure CU {X : Type*} [TopologicalSpace X] (P : Set X β Prop) where
protected C : Set X
protected U : Set X
protected P_C : P C
protected closed_C : IsClosed C
protected open_U : IsOpen U
protected subset : C β U
protected hP : β {c u : Set X}, IsClosed c β P c β IsOpen u β c β u β
β v, IsOpen v β§ c β v β§ closure v β u β§ P (closure v)
#align urysohns.CU Urysohns.CU
namespace CU
variable {P : Set X β Prop}
@[simps C]
def left (c : CU P) : CU P where
C := c.C
U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose
closed_C := c.closed_C
P_C := c.P_C
open_U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.1
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.1
hP := c.hP
#align urysohns.CU.left Urysohns.CU.left
@[simps U]
def right (c : CU P) : CU P where
C := closure (c.hP c.closed_C c.P_C c.open_U c.subset).choose
U := c.U
closed_C := isClosed_closure
P_C := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.2
open_U := c.open_U
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.1
hP := c.hP
#align urysohns.CU.right Urysohns.CU.right
theorem left_U_subset_right_C (c : CU P) : c.left.U β c.right.C :=
subset_closure
#align urysohns.CU.left_U_subset_right_C Urysohns.CU.left_U_subset_right_C
theorem left_U_subset (c : CU P) : c.left.U β c.U :=
Subset.trans c.left_U_subset_right_C c.right.subset
#align urysohns.CU.left_U_subset Urysohns.CU.left_U_subset
theorem subset_right_C (c : CU P) : c.C β c.right.C :=
Subset.trans c.left.subset c.left_U_subset_right_C
#align urysohns.CU.subset_right_C Urysohns.CU.subset_right_C
noncomputable def approx : β β CU P β X β β
| 0, c, x => indicator c.UαΆ 1 x
| n + 1, c, x => midpoint β (approx n c.left x) (approx n c.right x)
#align urysohns.CU.approx Urysohns.CU.approx
theorem approx_of_mem_C (c : CU P) (n : β) {x : X} (hx : x β c.C) : c.approx n x = 0 := by
induction' n with n ihn generalizing c
Β· exact indicator_of_not_mem (fun (hU : x β c.UαΆ) => hU <| c.subset hx) _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [c.subset_right_C hx, hx]
#align urysohns.CU.approx_of_mem_C Urysohns.CU.approx_of_mem_C
| Mathlib/Topology/UrysohnsLemma.lean | 169 | 175 | theorem approx_of_nmem_U (c : CU P) (n : β) {x : X} (hx : x β c.U) : c.approx n x = 1 := by |
induction' n with n ihn generalizing c
Β· rw [β mem_compl_iff] at hx
exact indicator_of_mem hx _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [hx, fun hU => hx <| c.left_U_subset hU]
| 1,753 |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
variable {X : Type*} [TopologicalSpace X]
open Set Filter TopologicalSpace Topology Filter
open scoped Pointwise
namespace Urysohns
set_option linter.uppercaseLean3 false
structure CU {X : Type*} [TopologicalSpace X] (P : Set X β Prop) where
protected C : Set X
protected U : Set X
protected P_C : P C
protected closed_C : IsClosed C
protected open_U : IsOpen U
protected subset : C β U
protected hP : β {c u : Set X}, IsClosed c β P c β IsOpen u β c β u β
β v, IsOpen v β§ c β v β§ closure v β u β§ P (closure v)
#align urysohns.CU Urysohns.CU
namespace CU
variable {P : Set X β Prop}
@[simps C]
def left (c : CU P) : CU P where
C := c.C
U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose
closed_C := c.closed_C
P_C := c.P_C
open_U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.1
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.1
hP := c.hP
#align urysohns.CU.left Urysohns.CU.left
@[simps U]
def right (c : CU P) : CU P where
C := closure (c.hP c.closed_C c.P_C c.open_U c.subset).choose
U := c.U
closed_C := isClosed_closure
P_C := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.2
open_U := c.open_U
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.1
hP := c.hP
#align urysohns.CU.right Urysohns.CU.right
theorem left_U_subset_right_C (c : CU P) : c.left.U β c.right.C :=
subset_closure
#align urysohns.CU.left_U_subset_right_C Urysohns.CU.left_U_subset_right_C
theorem left_U_subset (c : CU P) : c.left.U β c.U :=
Subset.trans c.left_U_subset_right_C c.right.subset
#align urysohns.CU.left_U_subset Urysohns.CU.left_U_subset
theorem subset_right_C (c : CU P) : c.C β c.right.C :=
Subset.trans c.left.subset c.left_U_subset_right_C
#align urysohns.CU.subset_right_C Urysohns.CU.subset_right_C
noncomputable def approx : β β CU P β X β β
| 0, c, x => indicator c.UαΆ 1 x
| n + 1, c, x => midpoint β (approx n c.left x) (approx n c.right x)
#align urysohns.CU.approx Urysohns.CU.approx
theorem approx_of_mem_C (c : CU P) (n : β) {x : X} (hx : x β c.C) : c.approx n x = 0 := by
induction' n with n ihn generalizing c
Β· exact indicator_of_not_mem (fun (hU : x β c.UαΆ) => hU <| c.subset hx) _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [c.subset_right_C hx, hx]
#align urysohns.CU.approx_of_mem_C Urysohns.CU.approx_of_mem_C
theorem approx_of_nmem_U (c : CU P) (n : β) {x : X} (hx : x β c.U) : c.approx n x = 1 := by
induction' n with n ihn generalizing c
Β· rw [β mem_compl_iff] at hx
exact indicator_of_mem hx _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [hx, fun hU => hx <| c.left_U_subset hU]
#align urysohns.CU.approx_of_nmem_U Urysohns.CU.approx_of_nmem_U
| Mathlib/Topology/UrysohnsLemma.lean | 178 | 182 | theorem approx_nonneg (c : CU P) (n : β) (x : X) : 0 β€ c.approx n x := by |
induction' n with n ihn generalizing c
Β· exact indicator_nonneg (fun _ _ => zero_le_one) _
Β· simp only [approx, midpoint_eq_smul_add, invOf_eq_inv]
refine mul_nonneg (inv_nonneg.2 zero_le_two) (add_nonneg ?_ ?_) <;> apply ihn
| 1,753 |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
variable {X : Type*} [TopologicalSpace X]
open Set Filter TopologicalSpace Topology Filter
open scoped Pointwise
namespace Urysohns
set_option linter.uppercaseLean3 false
structure CU {X : Type*} [TopologicalSpace X] (P : Set X β Prop) where
protected C : Set X
protected U : Set X
protected P_C : P C
protected closed_C : IsClosed C
protected open_U : IsOpen U
protected subset : C β U
protected hP : β {c u : Set X}, IsClosed c β P c β IsOpen u β c β u β
β v, IsOpen v β§ c β v β§ closure v β u β§ P (closure v)
#align urysohns.CU Urysohns.CU
namespace CU
variable {P : Set X β Prop}
@[simps C]
def left (c : CU P) : CU P where
C := c.C
U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose
closed_C := c.closed_C
P_C := c.P_C
open_U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.1
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.1
hP := c.hP
#align urysohns.CU.left Urysohns.CU.left
@[simps U]
def right (c : CU P) : CU P where
C := closure (c.hP c.closed_C c.P_C c.open_U c.subset).choose
U := c.U
closed_C := isClosed_closure
P_C := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.2
open_U := c.open_U
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.1
hP := c.hP
#align urysohns.CU.right Urysohns.CU.right
theorem left_U_subset_right_C (c : CU P) : c.left.U β c.right.C :=
subset_closure
#align urysohns.CU.left_U_subset_right_C Urysohns.CU.left_U_subset_right_C
theorem left_U_subset (c : CU P) : c.left.U β c.U :=
Subset.trans c.left_U_subset_right_C c.right.subset
#align urysohns.CU.left_U_subset Urysohns.CU.left_U_subset
theorem subset_right_C (c : CU P) : c.C β c.right.C :=
Subset.trans c.left.subset c.left_U_subset_right_C
#align urysohns.CU.subset_right_C Urysohns.CU.subset_right_C
noncomputable def approx : β β CU P β X β β
| 0, c, x => indicator c.UαΆ 1 x
| n + 1, c, x => midpoint β (approx n c.left x) (approx n c.right x)
#align urysohns.CU.approx Urysohns.CU.approx
theorem approx_of_mem_C (c : CU P) (n : β) {x : X} (hx : x β c.C) : c.approx n x = 0 := by
induction' n with n ihn generalizing c
Β· exact indicator_of_not_mem (fun (hU : x β c.UαΆ) => hU <| c.subset hx) _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [c.subset_right_C hx, hx]
#align urysohns.CU.approx_of_mem_C Urysohns.CU.approx_of_mem_C
theorem approx_of_nmem_U (c : CU P) (n : β) {x : X} (hx : x β c.U) : c.approx n x = 1 := by
induction' n with n ihn generalizing c
Β· rw [β mem_compl_iff] at hx
exact indicator_of_mem hx _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [hx, fun hU => hx <| c.left_U_subset hU]
#align urysohns.CU.approx_of_nmem_U Urysohns.CU.approx_of_nmem_U
theorem approx_nonneg (c : CU P) (n : β) (x : X) : 0 β€ c.approx n x := by
induction' n with n ihn generalizing c
Β· exact indicator_nonneg (fun _ _ => zero_le_one) _
Β· simp only [approx, midpoint_eq_smul_add, invOf_eq_inv]
refine mul_nonneg (inv_nonneg.2 zero_le_two) (add_nonneg ?_ ?_) <;> apply ihn
#align urysohns.CU.approx_nonneg Urysohns.CU.approx_nonneg
| Mathlib/Topology/UrysohnsLemma.lean | 185 | 192 | theorem approx_le_one (c : CU P) (n : β) (x : X) : c.approx n x β€ 1 := by |
induction' n with n ihn generalizing c
Β· exact indicator_apply_le' (fun _ => le_rfl) fun _ => zero_le_one
Β· simp only [approx, midpoint_eq_smul_add, invOf_eq_inv, smul_eq_mul, β div_eq_inv_mul]
have := add_le_add (ihn (left c)) (ihn (right c))
set_option tactic.skipAssignedInstances false in
norm_num at this
exact Iff.mpr (div_le_one zero_lt_two) this
| 1,753 |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
variable {X : Type*} [TopologicalSpace X]
open Set Filter TopologicalSpace Topology Filter
open scoped Pointwise
namespace Urysohns
set_option linter.uppercaseLean3 false
structure CU {X : Type*} [TopologicalSpace X] (P : Set X β Prop) where
protected C : Set X
protected U : Set X
protected P_C : P C
protected closed_C : IsClosed C
protected open_U : IsOpen U
protected subset : C β U
protected hP : β {c u : Set X}, IsClosed c β P c β IsOpen u β c β u β
β v, IsOpen v β§ c β v β§ closure v β u β§ P (closure v)
#align urysohns.CU Urysohns.CU
namespace CU
variable {P : Set X β Prop}
@[simps C]
def left (c : CU P) : CU P where
C := c.C
U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose
closed_C := c.closed_C
P_C := c.P_C
open_U := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.1
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.1
hP := c.hP
#align urysohns.CU.left Urysohns.CU.left
@[simps U]
def right (c : CU P) : CU P where
C := closure (c.hP c.closed_C c.P_C c.open_U c.subset).choose
U := c.U
closed_C := isClosed_closure
P_C := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.2
open_U := c.open_U
subset := (c.hP c.closed_C c.P_C c.open_U c.subset).choose_spec.2.2.1
hP := c.hP
#align urysohns.CU.right Urysohns.CU.right
theorem left_U_subset_right_C (c : CU P) : c.left.U β c.right.C :=
subset_closure
#align urysohns.CU.left_U_subset_right_C Urysohns.CU.left_U_subset_right_C
theorem left_U_subset (c : CU P) : c.left.U β c.U :=
Subset.trans c.left_U_subset_right_C c.right.subset
#align urysohns.CU.left_U_subset Urysohns.CU.left_U_subset
theorem subset_right_C (c : CU P) : c.C β c.right.C :=
Subset.trans c.left.subset c.left_U_subset_right_C
#align urysohns.CU.subset_right_C Urysohns.CU.subset_right_C
noncomputable def approx : β β CU P β X β β
| 0, c, x => indicator c.UαΆ 1 x
| n + 1, c, x => midpoint β (approx n c.left x) (approx n c.right x)
#align urysohns.CU.approx Urysohns.CU.approx
theorem approx_of_mem_C (c : CU P) (n : β) {x : X} (hx : x β c.C) : c.approx n x = 0 := by
induction' n with n ihn generalizing c
Β· exact indicator_of_not_mem (fun (hU : x β c.UαΆ) => hU <| c.subset hx) _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [c.subset_right_C hx, hx]
#align urysohns.CU.approx_of_mem_C Urysohns.CU.approx_of_mem_C
theorem approx_of_nmem_U (c : CU P) (n : β) {x : X} (hx : x β c.U) : c.approx n x = 1 := by
induction' n with n ihn generalizing c
Β· rw [β mem_compl_iff] at hx
exact indicator_of_mem hx _
Β· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [hx, fun hU => hx <| c.left_U_subset hU]
#align urysohns.CU.approx_of_nmem_U Urysohns.CU.approx_of_nmem_U
theorem approx_nonneg (c : CU P) (n : β) (x : X) : 0 β€ c.approx n x := by
induction' n with n ihn generalizing c
Β· exact indicator_nonneg (fun _ _ => zero_le_one) _
Β· simp only [approx, midpoint_eq_smul_add, invOf_eq_inv]
refine mul_nonneg (inv_nonneg.2 zero_le_two) (add_nonneg ?_ ?_) <;> apply ihn
#align urysohns.CU.approx_nonneg Urysohns.CU.approx_nonneg
theorem approx_le_one (c : CU P) (n : β) (x : X) : c.approx n x β€ 1 := by
induction' n with n ihn generalizing c
Β· exact indicator_apply_le' (fun _ => le_rfl) fun _ => zero_le_one
Β· simp only [approx, midpoint_eq_smul_add, invOf_eq_inv, smul_eq_mul, β div_eq_inv_mul]
have := add_le_add (ihn (left c)) (ihn (right c))
set_option tactic.skipAssignedInstances false in
norm_num at this
exact Iff.mpr (div_le_one zero_lt_two) this
#align urysohns.CU.approx_le_one Urysohns.CU.approx_le_one
theorem bddAbove_range_approx (c : CU P) (x : X) : BddAbove (range fun n => c.approx n x) :=
β¨1, fun _ β¨n, hnβ© => hn βΈ c.approx_le_one n xβ©
#align urysohns.CU.bdd_above_range_approx Urysohns.CU.bddAbove_range_approx
| Mathlib/Topology/UrysohnsLemma.lean | 199 | 207 | theorem approx_le_approx_of_U_sub_C {cβ cβ : CU P} (h : cβ.U β cβ.C) (nβ nβ : β) (x : X) :
cβ.approx nβ x β€ cβ.approx nβ x := by |
by_cases hx : x β cβ.U
Β· calc
approx nβ cβ x = 0 := approx_of_mem_C _ _ (h hx)
_ β€ approx nβ cβ x := approx_nonneg _ _ _
Β· calc
approx nβ cβ x β€ 1 := approx_le_one _ _ _
_ = approx nβ cβ x := (approx_of_nmem_U _ _ hx).symm
| 1,753 |
import Mathlib.CategoryTheory.Adjunction.Reflective
import Mathlib.Topology.StoneCech
import Mathlib.CategoryTheory.Monad.Limits
import Mathlib.Topology.UrysohnsLemma
import Mathlib.Topology.Category.TopCat.Limits.Basic
import Mathlib.Data.Set.Subsingleton
import Mathlib.CategoryTheory.Elementwise
#align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
universe v u
-- This was a global instance prior to #13170. We may experiment with removing it.
attribute [local instance] CategoryTheory.ConcreteCategory.instFunLike
open CategoryTheory
structure CompHaus where
toTop : TopCat
-- Porting note: Renamed field.
[is_compact : CompactSpace toTop]
[is_hausdorff : T2Space toTop]
set_option linter.uppercaseLean3 false in
#align CompHaus CompHaus
namespace CompHaus
instance : Inhabited CompHaus :=
β¨{ toTop := { Ξ± := PEmpty } }β©
instance : CoeSort CompHaus Type* :=
β¨fun X => X.toTopβ©
instance {X : CompHaus} : CompactSpace X :=
X.is_compact
instance {X : CompHaus} : T2Space X :=
X.is_hausdorff
instance category : Category CompHaus :=
InducedCategory.category toTop
set_option linter.uppercaseLean3 false in
#align CompHaus.category CompHaus.category
instance concreteCategory : ConcreteCategory CompHaus :=
InducedCategory.concreteCategory _
set_option linter.uppercaseLean3 false in
#align CompHaus.concrete_category CompHaus.concreteCategory
variable (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
def of : CompHaus where
toTop := TopCat.of X
is_compact := βΉ_βΊ
is_hausdorff := βΉ_βΊ
set_option linter.uppercaseLean3 false in
#align CompHaus.of CompHaus.of
@[simp]
theorem coe_of : (CompHaus.of X : Type _) = X :=
rfl
set_option linter.uppercaseLean3 false in
#align CompHaus.coe_of CompHaus.coe_of
-- Porting note (#10754): Adding instance
instance (X : CompHaus.{u}) : TopologicalSpace ((forget CompHaus).obj X) :=
show TopologicalSpace X.toTop from inferInstance
-- Porting note (#10754): Adding instance
instance (X : CompHaus.{u}) : CompactSpace ((forget CompHaus).obj X) :=
show CompactSpace X.toTop from inferInstance
-- Porting note (#10754): Adding instance
instance (X : CompHaus.{u}) : T2Space ((forget CompHaus).obj X) :=
show T2Space X.toTop from inferInstance
theorem isClosedMap {X Y : CompHaus.{u}} (f : X βΆ Y) : IsClosedMap f := fun _ hC =>
(hC.isCompact.image f.continuous).isClosed
set_option linter.uppercaseLean3 false in
#align CompHaus.is_closed_map CompHaus.isClosedMap
| Mathlib/Topology/Category/CompHaus/Basic.lean | 123 | 135 | theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X βΆ Y) (bij : Function.Bijective f) :
IsIso f := by |
let E := Equiv.ofBijective _ bij
have hE : Continuous E.symm := by
rw [continuous_iff_isClosed]
intro S hS
rw [β E.image_eq_preimage]
exact isClosedMap f S hS
refine β¨β¨β¨E.symm, hEβ©, ?_, ?_β©β©
Β· ext x
apply E.symm_apply_apply
Β· ext x
apply E.apply_symm_apply
| 1,754 |
import Mathlib.CategoryTheory.Monad.Types
import Mathlib.CategoryTheory.Monad.Limits
import Mathlib.CategoryTheory.Equivalence
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.Topology.Category.Profinite.Basic
import Mathlib.Data.Set.Constructions
#align_import topology.category.Compactum from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
-- Porting note: "Compactum" is already upper case
set_option linter.uppercaseLean3 false
universe u
open CategoryTheory Filter Ultrafilter TopologicalSpace CategoryTheory.Limits FiniteInter
open scoped Classical
open Topology
local notation "Ξ²" => ofTypeMonad Ultrafilter
def Compactum :=
Monad.Algebra Ξ² deriving Category, Inhabited
#align Compactum Compactum
namespace Compactum
def forget : Compactum β₯€ Type* :=
Monad.forget _ --deriving CreatesLimits, Faithful
-- Porting note: deriving fails, adding manually. Note `CreatesLimits` now noncomputable
#align Compactum.forget Compactum.forget
instance : forget.Faithful :=
show (Monad.forget _).Faithful from inferInstance
noncomputable instance : CreatesLimits forget :=
show CreatesLimits <| Monad.forget _ from inferInstance
def free : Type* β₯€ Compactum :=
Monad.free _
#align Compactum.free Compactum.free
def adj : free β£ forget :=
Monad.adj _
#align Compactum.adj Compactum.adj
-- Basic instances
instance : ConcreteCategory Compactum where forget := forget
-- Porting note: changed from forget to X.A
instance : CoeSort Compactum Type* :=
β¨fun X => X.Aβ©
instance {X Y : Compactum} : CoeFun (X βΆ Y) fun _ => X β Y :=
β¨fun f => f.fβ©
instance : HasLimits Compactum :=
hasLimits_of_hasLimits_createsLimits forget
def str (X : Compactum) : Ultrafilter X β X :=
X.a
#align Compactum.str Compactum.str
def join (X : Compactum) : Ultrafilter (Ultrafilter X) β Ultrafilter X :=
(Ξ² ).ΞΌ.app _
#align Compactum.join Compactum.join
def incl (X : Compactum) : X β Ultrafilter X :=
(Ξ² ).Ξ·.app _
#align Compactum.incl Compactum.incl
@[simp]
| Mathlib/Topology/Category/Compactum.lean | 143 | 146 | theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x := by |
change ((Ξ² ).Ξ·.app _ β« X.a) _ = _
rw [Monad.Algebra.unit]
rfl
| 1,755 |
import Mathlib.CategoryTheory.Monad.Types
import Mathlib.CategoryTheory.Monad.Limits
import Mathlib.CategoryTheory.Equivalence
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.Topology.Category.Profinite.Basic
import Mathlib.Data.Set.Constructions
#align_import topology.category.Compactum from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
-- Porting note: "Compactum" is already upper case
set_option linter.uppercaseLean3 false
universe u
open CategoryTheory Filter Ultrafilter TopologicalSpace CategoryTheory.Limits FiniteInter
open scoped Classical
open Topology
local notation "Ξ²" => ofTypeMonad Ultrafilter
def Compactum :=
Monad.Algebra Ξ² deriving Category, Inhabited
#align Compactum Compactum
namespace Compactum
def forget : Compactum β₯€ Type* :=
Monad.forget _ --deriving CreatesLimits, Faithful
-- Porting note: deriving fails, adding manually. Note `CreatesLimits` now noncomputable
#align Compactum.forget Compactum.forget
instance : forget.Faithful :=
show (Monad.forget _).Faithful from inferInstance
noncomputable instance : CreatesLimits forget :=
show CreatesLimits <| Monad.forget _ from inferInstance
def free : Type* β₯€ Compactum :=
Monad.free _
#align Compactum.free Compactum.free
def adj : free β£ forget :=
Monad.adj _
#align Compactum.adj Compactum.adj
-- Basic instances
instance : ConcreteCategory Compactum where forget := forget
-- Porting note: changed from forget to X.A
instance : CoeSort Compactum Type* :=
β¨fun X => X.Aβ©
instance {X Y : Compactum} : CoeFun (X βΆ Y) fun _ => X β Y :=
β¨fun f => f.fβ©
instance : HasLimits Compactum :=
hasLimits_of_hasLimits_createsLimits forget
def str (X : Compactum) : Ultrafilter X β X :=
X.a
#align Compactum.str Compactum.str
def join (X : Compactum) : Ultrafilter (Ultrafilter X) β Ultrafilter X :=
(Ξ² ).ΞΌ.app _
#align Compactum.join Compactum.join
def incl (X : Compactum) : X β Ultrafilter X :=
(Ξ² ).Ξ·.app _
#align Compactum.incl Compactum.incl
@[simp]
theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x := by
change ((Ξ² ).Ξ·.app _ β« X.a) _ = _
rw [Monad.Algebra.unit]
rfl
#align Compactum.str_incl Compactum.str_incl
@[simp]
| Mathlib/Topology/Category/Compactum.lean | 150 | 154 | theorem str_hom_commute (X Y : Compactum) (f : X βΆ Y) (xs : Ultrafilter X) :
f (X.str xs) = Y.str (map f xs) := by |
change (X.a β« f.f) _ = _
rw [β f.h]
rfl
| 1,755 |
import Mathlib.CategoryTheory.Monad.Types
import Mathlib.CategoryTheory.Monad.Limits
import Mathlib.CategoryTheory.Equivalence
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.Topology.Category.Profinite.Basic
import Mathlib.Data.Set.Constructions
#align_import topology.category.Compactum from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
-- Porting note: "Compactum" is already upper case
set_option linter.uppercaseLean3 false
universe u
open CategoryTheory Filter Ultrafilter TopologicalSpace CategoryTheory.Limits FiniteInter
open scoped Classical
open Topology
local notation "Ξ²" => ofTypeMonad Ultrafilter
def Compactum :=
Monad.Algebra Ξ² deriving Category, Inhabited
#align Compactum Compactum
namespace Compactum
def forget : Compactum β₯€ Type* :=
Monad.forget _ --deriving CreatesLimits, Faithful
-- Porting note: deriving fails, adding manually. Note `CreatesLimits` now noncomputable
#align Compactum.forget Compactum.forget
instance : forget.Faithful :=
show (Monad.forget _).Faithful from inferInstance
noncomputable instance : CreatesLimits forget :=
show CreatesLimits <| Monad.forget _ from inferInstance
def free : Type* β₯€ Compactum :=
Monad.free _
#align Compactum.free Compactum.free
def adj : free β£ forget :=
Monad.adj _
#align Compactum.adj Compactum.adj
-- Basic instances
instance : ConcreteCategory Compactum where forget := forget
-- Porting note: changed from forget to X.A
instance : CoeSort Compactum Type* :=
β¨fun X => X.Aβ©
instance {X Y : Compactum} : CoeFun (X βΆ Y) fun _ => X β Y :=
β¨fun f => f.fβ©
instance : HasLimits Compactum :=
hasLimits_of_hasLimits_createsLimits forget
def str (X : Compactum) : Ultrafilter X β X :=
X.a
#align Compactum.str Compactum.str
def join (X : Compactum) : Ultrafilter (Ultrafilter X) β Ultrafilter X :=
(Ξ² ).ΞΌ.app _
#align Compactum.join Compactum.join
def incl (X : Compactum) : X β Ultrafilter X :=
(Ξ² ).Ξ·.app _
#align Compactum.incl Compactum.incl
@[simp]
theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x := by
change ((Ξ² ).Ξ·.app _ β« X.a) _ = _
rw [Monad.Algebra.unit]
rfl
#align Compactum.str_incl Compactum.str_incl
@[simp]
theorem str_hom_commute (X Y : Compactum) (f : X βΆ Y) (xs : Ultrafilter X) :
f (X.str xs) = Y.str (map f xs) := by
change (X.a β« f.f) _ = _
rw [β f.h]
rfl
#align Compactum.str_hom_commute Compactum.str_hom_commute
@[simp]
| Mathlib/Topology/Category/Compactum.lean | 158 | 162 | theorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
X.str (X.join uux) = X.str (map X.str uux) := by |
change ((Ξ² ).ΞΌ.app _ β« X.a) _ = _
rw [Monad.Algebra.assoc]
rfl
| 1,755 |
import Mathlib.CategoryTheory.Monad.Types
import Mathlib.CategoryTheory.Monad.Limits
import Mathlib.CategoryTheory.Equivalence
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.Topology.Category.Profinite.Basic
import Mathlib.Data.Set.Constructions
#align_import topology.category.Compactum from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
-- Porting note: "Compactum" is already upper case
set_option linter.uppercaseLean3 false
universe u
open CategoryTheory Filter Ultrafilter TopologicalSpace CategoryTheory.Limits FiniteInter
open scoped Classical
open Topology
local notation "Ξ²" => ofTypeMonad Ultrafilter
def Compactum :=
Monad.Algebra Ξ² deriving Category, Inhabited
#align Compactum Compactum
namespace Compactum
def forget : Compactum β₯€ Type* :=
Monad.forget _ --deriving CreatesLimits, Faithful
-- Porting note: deriving fails, adding manually. Note `CreatesLimits` now noncomputable
#align Compactum.forget Compactum.forget
instance : forget.Faithful :=
show (Monad.forget _).Faithful from inferInstance
noncomputable instance : CreatesLimits forget :=
show CreatesLimits <| Monad.forget _ from inferInstance
def free : Type* β₯€ Compactum :=
Monad.free _
#align Compactum.free Compactum.free
def adj : free β£ forget :=
Monad.adj _
#align Compactum.adj Compactum.adj
-- Basic instances
instance : ConcreteCategory Compactum where forget := forget
-- Porting note: changed from forget to X.A
instance : CoeSort Compactum Type* :=
β¨fun X => X.Aβ©
instance {X Y : Compactum} : CoeFun (X βΆ Y) fun _ => X β Y :=
β¨fun f => f.fβ©
instance : HasLimits Compactum :=
hasLimits_of_hasLimits_createsLimits forget
def str (X : Compactum) : Ultrafilter X β X :=
X.a
#align Compactum.str Compactum.str
def join (X : Compactum) : Ultrafilter (Ultrafilter X) β Ultrafilter X :=
(Ξ² ).ΞΌ.app _
#align Compactum.join Compactum.join
def incl (X : Compactum) : X β Ultrafilter X :=
(Ξ² ).Ξ·.app _
#align Compactum.incl Compactum.incl
@[simp]
theorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x := by
change ((Ξ² ).Ξ·.app _ β« X.a) _ = _
rw [Monad.Algebra.unit]
rfl
#align Compactum.str_incl Compactum.str_incl
@[simp]
theorem str_hom_commute (X Y : Compactum) (f : X βΆ Y) (xs : Ultrafilter X) :
f (X.str xs) = Y.str (map f xs) := by
change (X.a β« f.f) _ = _
rw [β f.h]
rfl
#align Compactum.str_hom_commute Compactum.str_hom_commute
@[simp]
theorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :
X.str (X.join uux) = X.str (map X.str uux) := by
change ((Ξ² ).ΞΌ.app _ β« X.a) _ = _
rw [Monad.Algebra.assoc]
rfl
#align Compactum.join_distrib Compactum.join_distrib
-- Porting note: changes to X.A from X since Lean can't see through X to X.A below
instance {X : Compactum} : TopologicalSpace X.A where
IsOpen U := β F : Ultrafilter X, X.str F β U β U β F
isOpen_univ _ _ := Filter.univ_sets _
isOpen_inter _ _ h3 h4 _ h6 := Filter.inter_sets _ (h3 _ h6.1) (h4 _ h6.2)
isOpen_sUnion := fun _ h1 _ β¨T, hT, h2β© =>
mem_of_superset (h1 T hT _ h2) (Set.subset_sUnion_of_mem hT)
| Mathlib/Topology/Category/Compactum.lean | 173 | 185 | theorem isClosed_iff {X : Compactum} (S : Set X) :
IsClosed S β β F : Ultrafilter X, S β F β X.str F β S := by |
rw [β isOpen_compl_iff]
constructor
Β· intro cond F h
by_contra c
specialize cond F c
rw [compl_mem_iff_not_mem] at cond
contradiction
Β· intro h1 F h2
specialize h1 F
cases' F.mem_or_compl_mem S with h h
exacts [absurd (h1 h) h2, h]
| 1,755 |
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Extensive
import Mathlib.CategoryTheory.Limits.Preserves.Finite
namespace CompHaus
attribute [local instance] CategoryTheory.ConcreteCategory.instFunLike
universe u w
open CategoryTheory Limits
section Pullbacks
variable {X Y B : CompHaus.{u}} (f : X βΆ B) (g : Y βΆ B)
def pullback : CompHaus.{u} :=
letI set := { xy : X Γ Y | f xy.fst = g xy.snd }
haveI : CompactSpace set :=
isCompact_iff_compactSpace.mp (isClosed_eq (f.continuous.comp continuous_fst)
(g.continuous.comp continuous_snd)).isCompact
CompHaus.of set
def pullback.fst : pullback f g βΆ X where
toFun := fun β¨β¨x,_β©,_β© => x
continuous_toFun := Continuous.comp continuous_fst continuous_subtype_val
def pullback.snd : pullback f g βΆ Y where
toFun := fun β¨β¨_,yβ©,_β© => y
continuous_toFun := Continuous.comp continuous_snd continuous_subtype_val
@[reassoc]
lemma pullback.condition : pullback.fst f g β« f = pullback.snd f g β« g := by
ext β¨_,hβ©; exact h
def pullback.lift {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
Z βΆ pullback f g where
toFun := fun z => β¨β¨a z, b zβ©, by apply_fun (fun q => q z) at w; exact wβ©
continuous_toFun := by
apply Continuous.subtype_mk
rw [continuous_prod_mk]
exact β¨a.continuous, b.continuousβ©
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.fst f g = a := rfl
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.snd f g = b := rfl
lemma pullback.hom_ext {Z : CompHaus.{u}} (a b : Z βΆ pullback f g)
(hfst : a β« pullback.fst f g = b β« pullback.fst f g)
(hsnd : a β« pullback.snd f g = b β« pullback.snd f g) : a = b := by
ext z
apply_fun (fun q => q z) at hfst hsnd
apply Subtype.ext
apply Prod.ext
Β· exact hfst
Β· exact hsnd
@[simps! pt Ο]
def pullback.cone : Limits.PullbackCone f g :=
Limits.PullbackCone.mk (pullback.fst f g) (pullback.snd f g) (pullback.condition f g)
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) :=
Limits.PullbackCone.isLimitAux _
(fun s => pullback.lift f g s.fst s.snd s.condition)
(fun _ => pullback.lift_fst _ _ _ _ _)
(fun _ => pullback.lift_snd _ _ _ _ _)
(fun _ _ hm => pullback.hom_ext _ _ _ _ (hm .left) (hm .right))
section Isos
noncomputable
def pullbackIsoPullback : CompHaus.pullback f g β
Limits.pullback f g :=
Limits.IsLimit.conePointUniqueUpToIso (pullback.isLimit f g) (Limits.limit.isLimit _)
noncomputable
def pullbackHomeoPullback : (CompHaus.pullback f g).toTop ββ (Limits.pullback f g).toTop :=
CompHaus.homeoOfIso (pullbackIsoPullback f g)
| Mathlib/Topology/Category/CompHaus/Limits.lean | 131 | 134 | theorem pullback_fst_eq :
CompHaus.pullback.fst f g = (pullbackIsoPullback f g).hom β« Limits.pullback.fst := by |
dsimp [pullbackIsoPullback]
simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_Ο]
| 1,756 |
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Extensive
import Mathlib.CategoryTheory.Limits.Preserves.Finite
namespace CompHaus
attribute [local instance] CategoryTheory.ConcreteCategory.instFunLike
universe u w
open CategoryTheory Limits
section Pullbacks
variable {X Y B : CompHaus.{u}} (f : X βΆ B) (g : Y βΆ B)
def pullback : CompHaus.{u} :=
letI set := { xy : X Γ Y | f xy.fst = g xy.snd }
haveI : CompactSpace set :=
isCompact_iff_compactSpace.mp (isClosed_eq (f.continuous.comp continuous_fst)
(g.continuous.comp continuous_snd)).isCompact
CompHaus.of set
def pullback.fst : pullback f g βΆ X where
toFun := fun β¨β¨x,_β©,_β© => x
continuous_toFun := Continuous.comp continuous_fst continuous_subtype_val
def pullback.snd : pullback f g βΆ Y where
toFun := fun β¨β¨_,yβ©,_β© => y
continuous_toFun := Continuous.comp continuous_snd continuous_subtype_val
@[reassoc]
lemma pullback.condition : pullback.fst f g β« f = pullback.snd f g β« g := by
ext β¨_,hβ©; exact h
def pullback.lift {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
Z βΆ pullback f g where
toFun := fun z => β¨β¨a z, b zβ©, by apply_fun (fun q => q z) at w; exact wβ©
continuous_toFun := by
apply Continuous.subtype_mk
rw [continuous_prod_mk]
exact β¨a.continuous, b.continuousβ©
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.fst f g = a := rfl
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.snd f g = b := rfl
lemma pullback.hom_ext {Z : CompHaus.{u}} (a b : Z βΆ pullback f g)
(hfst : a β« pullback.fst f g = b β« pullback.fst f g)
(hsnd : a β« pullback.snd f g = b β« pullback.snd f g) : a = b := by
ext z
apply_fun (fun q => q z) at hfst hsnd
apply Subtype.ext
apply Prod.ext
Β· exact hfst
Β· exact hsnd
@[simps! pt Ο]
def pullback.cone : Limits.PullbackCone f g :=
Limits.PullbackCone.mk (pullback.fst f g) (pullback.snd f g) (pullback.condition f g)
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) :=
Limits.PullbackCone.isLimitAux _
(fun s => pullback.lift f g s.fst s.snd s.condition)
(fun _ => pullback.lift_fst _ _ _ _ _)
(fun _ => pullback.lift_snd _ _ _ _ _)
(fun _ _ hm => pullback.hom_ext _ _ _ _ (hm .left) (hm .right))
section Isos
noncomputable
def pullbackIsoPullback : CompHaus.pullback f g β
Limits.pullback f g :=
Limits.IsLimit.conePointUniqueUpToIso (pullback.isLimit f g) (Limits.limit.isLimit _)
noncomputable
def pullbackHomeoPullback : (CompHaus.pullback f g).toTop ββ (Limits.pullback f g).toTop :=
CompHaus.homeoOfIso (pullbackIsoPullback f g)
theorem pullback_fst_eq :
CompHaus.pullback.fst f g = (pullbackIsoPullback f g).hom β« Limits.pullback.fst := by
dsimp [pullbackIsoPullback]
simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_Ο]
| Mathlib/Topology/Category/CompHaus/Limits.lean | 136 | 139 | theorem pullback_snd_eq :
CompHaus.pullback.snd f g = (pullbackIsoPullback f g).hom β« Limits.pullback.snd := by |
dsimp [pullbackIsoPullback]
simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_Ο]
| 1,756 |
import Mathlib.Topology.Category.CompHaus.Basic
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Extensive
import Mathlib.CategoryTheory.Limits.Preserves.Finite
namespace CompHaus
attribute [local instance] CategoryTheory.ConcreteCategory.instFunLike
universe u w
open CategoryTheory Limits
section Pullbacks
variable {X Y B : CompHaus.{u}} (f : X βΆ B) (g : Y βΆ B)
def pullback : CompHaus.{u} :=
letI set := { xy : X Γ Y | f xy.fst = g xy.snd }
haveI : CompactSpace set :=
isCompact_iff_compactSpace.mp (isClosed_eq (f.continuous.comp continuous_fst)
(g.continuous.comp continuous_snd)).isCompact
CompHaus.of set
def pullback.fst : pullback f g βΆ X where
toFun := fun β¨β¨x,_β©,_β© => x
continuous_toFun := Continuous.comp continuous_fst continuous_subtype_val
def pullback.snd : pullback f g βΆ Y where
toFun := fun β¨β¨_,yβ©,_β© => y
continuous_toFun := Continuous.comp continuous_snd continuous_subtype_val
@[reassoc]
lemma pullback.condition : pullback.fst f g β« f = pullback.snd f g β« g := by
ext β¨_,hβ©; exact h
def pullback.lift {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
Z βΆ pullback f g where
toFun := fun z => β¨β¨a z, b zβ©, by apply_fun (fun q => q z) at w; exact wβ©
continuous_toFun := by
apply Continuous.subtype_mk
rw [continuous_prod_mk]
exact β¨a.continuous, b.continuousβ©
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.fst f g = a := rfl
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : CompHaus.{u}} (a : Z βΆ X) (b : Z βΆ Y) (w : a β« f = b β« g) :
pullback.lift f g a b w β« pullback.snd f g = b := rfl
lemma pullback.hom_ext {Z : CompHaus.{u}} (a b : Z βΆ pullback f g)
(hfst : a β« pullback.fst f g = b β« pullback.fst f g)
(hsnd : a β« pullback.snd f g = b β« pullback.snd f g) : a = b := by
ext z
apply_fun (fun q => q z) at hfst hsnd
apply Subtype.ext
apply Prod.ext
Β· exact hfst
Β· exact hsnd
@[simps! pt Ο]
def pullback.cone : Limits.PullbackCone f g :=
Limits.PullbackCone.mk (pullback.fst f g) (pullback.snd f g) (pullback.condition f g)
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) :=
Limits.PullbackCone.isLimitAux _
(fun s => pullback.lift f g s.fst s.snd s.condition)
(fun _ => pullback.lift_fst _ _ _ _ _)
(fun _ => pullback.lift_snd _ _ _ _ _)
(fun _ _ hm => pullback.hom_ext _ _ _ _ (hm .left) (hm .right))
section FiniteCoproducts
variable {Ξ± : Type w} [Finite Ξ±] (X : Ξ± β CompHaus)
def finiteCoproduct : CompHaus := CompHaus.of <| Ξ£ (a : Ξ±), X a
def finiteCoproduct.ΞΉ (a : Ξ±) : X a βΆ finiteCoproduct X where
toFun := fun x => β¨a,xβ©
continuous_toFun := continuous_sigmaMk (Ο := fun a => X a)
def finiteCoproduct.desc {B : CompHaus} (e : (a : Ξ±) β (X a βΆ B)) :
finiteCoproduct X βΆ B where
toFun := fun β¨a,xβ© => e a x
continuous_toFun := by
apply continuous_sigma
intro a; exact (e a).continuous
@[reassoc (attr := simp)]
lemma finiteCoproduct.ΞΉ_desc {B : CompHaus} (e : (a : Ξ±) β (X a βΆ B)) (a : Ξ±) :
finiteCoproduct.ΞΉ X a β« finiteCoproduct.desc X e = e a := rfl
lemma finiteCoproduct.hom_ext {B : CompHaus} (f g : finiteCoproduct X βΆ B)
(h : β a : Ξ±, finiteCoproduct.ΞΉ X a β« f = finiteCoproduct.ΞΉ X a β« g) : f = g := by
ext β¨a,xβ©
specialize h a
apply_fun (fun q => q x) at h
exact h
abbrev finiteCoproduct.cofan : Limits.Cofan X :=
Cofan.mk (finiteCoproduct X) (finiteCoproduct.ΞΉ X)
def finiteCoproduct.isColimit : Limits.IsColimit (finiteCoproduct.cofan X) :=
mkCofanColimit _
(fun s β¦ desc _ fun a β¦ s.inj a)
(fun _ _ β¦ ΞΉ_desc _ _ _)
fun _ _ hm β¦ finiteCoproduct.hom_ext _ _ _ fun a β¦
(DFunLike.ext _ _ fun t β¦ congrFun (congrArg DFunLike.coe (hm a)) t)
section Iso
noncomputable
def coproductIsoCoproduct : finiteCoproduct X β
β X :=
Limits.IsColimit.coconePointUniqueUpToIso (finiteCoproduct.isColimit X)
(Limits.colimit.isColimit _)
| Mathlib/Topology/Category/CompHaus/Limits.lean | 205 | 207 | theorem Sigma.ΞΉ_comp_toFiniteCoproduct (a : Ξ±) :
(Limits.Sigma.ΞΉ X a) β« (coproductIsoCoproduct X).inv = finiteCoproduct.ΞΉ X a := by |
simp [coproductIsoCoproduct]
| 1,756 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Topology.UrysohnsLemma
import Mathlib.Topology.ContinuousFunction.Bounded
import Mathlib.Topology.Metrizable.Basic
#align_import topology.metric_space.metrizable from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Metric
open scoped Topology BoundedContinuousFunction
namespace TopologicalSpace
section RegularSpace
variable (X : Type*) [TopologicalSpace X] [RegularSpace X] [SecondCountableTopology X]
| Mathlib/Topology/Metrizable/Urysohn.lean | 37 | 106 | theorem exists_inducing_l_infty : β f : X β β βα΅ β, Inducing f := by |
-- Choose a countable basis, and consider the set `s` of pairs of set `(U, V)` such that `U β B`,
-- `V β B`, and `closure U β V`.
rcases exists_countable_basis X with β¨B, hBc, -, hBβ©
let s : Set (Set X Γ Set X) := { UV β B ΓΛ’ B | closure UV.1 β UV.2 }
-- `s` is a countable set.
haveI : Encodable s := ((hBc.prod hBc).mono inter_subset_left).toEncodable
-- We don't have the space of bounded (possibly discontinuous) functions, so we equip `s`
-- with the discrete topology and deal with `s βα΅ β` instead.
letI : TopologicalSpace s := β₯
haveI : DiscreteTopology s := β¨rflβ©
rsuffices β¨f, hfβ© : β f : X β s βα΅ β, Inducing f
Β· exact β¨fun x => (f x).extend (Encodable.encode' s) 0,
(BoundedContinuousFunction.isometry_extend (Encodable.encode' s)
(0 : β βα΅ β)).embedding.toInducing.comp hfβ©
have hd : β UV : s, Disjoint (closure UV.1.1) UV.1.2αΆ :=
fun UV => disjoint_compl_right.mono_right (compl_subset_compl.2 UV.2.2)
-- Choose a sequence of `Ξ΅β > 0`, `n : s`, that is bounded above by `1` and tends to zero
-- along the `cofinite` filter.
obtain β¨Ξ΅, Ξ΅01, hΞ΅β© : β Ξ΅ : s β β, (β UV, Ξ΅ UV β Ioc (0 : β) 1) β§ Tendsto Ξ΅ cofinite (π 0) := by
rcases posSumOfEncodable zero_lt_one s with β¨Ξ΅, Ξ΅0, c, hΞ΅c, hc1β©
refine β¨Ξ΅, fun UV => β¨Ξ΅0 UV, ?_β©, hΞ΅c.summable.tendsto_cofinite_zeroβ©
exact (le_hasSum hΞ΅c UV fun _ _ => (Ξ΅0 _).le).trans hc1
/- For each `UV = (U, V) β s` we use Urysohn's lemma to choose a function `f UV` that is equal to
zero on `U` and is equal to `Ξ΅ UV` on the complement to `V`. -/
have : β UV : s, β f : C(X, β),
EqOn f 0 UV.1.1 β§ EqOn f (fun _ => Ξ΅ UV) UV.1.2αΆ β§ β x, f x β Icc 0 (Ξ΅ UV) := by
intro UV
rcases exists_continuous_zero_one_of_isClosed isClosed_closure
(hB.isOpen UV.2.1.2).isClosed_compl (hd UV) with
β¨f, hfβ, hfβ, hf01β©
exact β¨Ξ΅ UV β’ f, fun x hx => by simp [hfβ (subset_closure hx)], fun x hx => by simp [hfβ hx],
fun x => β¨mul_nonneg (Ξ΅01 _).1.le (hf01 _).1, mul_le_of_le_one_right (Ξ΅01 _).1.le (hf01 _).2β©β©
choose f hf0 hfΞ΅ hf0Ξ΅ using this
have hf01 : β UV x, f UV x β Icc (0 : β) 1 :=
fun UV x => Icc_subset_Icc_right (Ξ΅01 _).2 (hf0Ξ΅ _ _)
-- The embedding is given by `F x UV = f UV x`.
set F : X β s βα΅ β := fun x =>
β¨β¨fun UV => f UV x, continuous_of_discreteTopologyβ©, 1,
fun UVβ UVβ => Real.dist_le_of_mem_Icc_01 (hf01 _ _) (hf01 _ _)β©
have hF : β x UV, F x UV = f UV x := fun _ _ => rfl
refine β¨F, inducing_iff_nhds.2 fun x => le_antisymm ?_ ?_β©
Β· /- First we prove that `F` is continuous. Given `Ξ΄ > 0`, consider the set `T` of `(U, V) β s`
such that `Ξ΅ (U, V) β₯ Ξ΄`. Since `Ξ΅` tends to zero, `T` is finite. Since each `f` is continuous,
we can choose a neighborhood such that `dist (F y (U, V)) (F x (U, V)) β€ Ξ΄` for any
`(U, V) β T`. For `(U, V) β T`, the same inequality is true because both `F y (U, V)` and
`F x (U, V)` belong to the interval `[0, Ξ΅ (U, V)]`. -/
refine (nhds_basis_closedBall.comap _).ge_iff.2 fun Ξ΄ Ξ΄0 => ?_
have h_fin : { UV : s | Ξ΄ β€ Ξ΅ UV }.Finite := by simpa only [β not_lt] using hΞ΅ (gt_mem_nhds Ξ΄0)
have : βαΆ y in π x, β UV, Ξ΄ β€ Ξ΅ UV β dist (F y UV) (F x UV) β€ Ξ΄ := by
refine (eventually_all_finite h_fin).2 fun UV _ => ?_
exact (f UV).continuous.tendsto x (closedBall_mem_nhds _ Ξ΄0)
refine this.mono fun y hy => (BoundedContinuousFunction.dist_le Ξ΄0.le).2 fun UV => ?_
rcases le_total Ξ΄ (Ξ΅ UV) with hle | hle
exacts [hy _ hle, (Real.dist_le_of_mem_Icc (hf0Ξ΅ _ _) (hf0Ξ΅ _ _)).trans (by rwa [sub_zero])]
Β· /- Finally, we prove that each neighborhood `V` of `x : X`
includes a preimage of a neighborhood of `F x` under `F`.
Without loss of generality, `V` belongs to `B`.
Choose `U β B` such that `x β V` and `closure V β U`.
Then the preimage of the `(Ξ΅ (U, V))`-neighborhood of `F x` is included by `V`. -/
refine ((nhds_basis_ball.comap _).le_basis_iff hB.nhds_hasBasis).2 ?_
rintro V β¨hVB, hxVβ©
rcases hB.exists_closure_subset (hB.mem_nhds hVB hxV) with β¨U, hUB, hxU, hUVβ©
set UV : β₯s := β¨(U, V), β¨hUB, hVBβ©, hUVβ©
refine β¨Ξ΅ UV, (Ξ΅01 UV).1, fun y (hy : dist (F y) (F x) < Ξ΅ UV) => ?_β©
replace hy : dist (F y UV) (F x UV) < Ξ΅ UV :=
(BoundedContinuousFunction.dist_coe_le_dist _).trans_lt hy
contrapose! hy
rw [hF, hF, hfΞ΅ UV hy, hf0 UV hxU, Pi.zero_apply, dist_zero_right]
exact le_abs_self _
| 1,757 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
| Mathlib/Topology/PartitionOfUnity.lean | 161 | 164 | theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by |
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section finsupport
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
def finsupport : Finset ΞΉ := (Ο.locallyFinite.point_finite xβ).toFinset
@[simp]
| Mathlib/Topology/PartitionOfUnity.lean | 188 | 190 | theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by |
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section finsupport
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
def finsupport : Finset ΞΉ := (Ο.locallyFinite.point_finite xβ).toFinset
@[simp]
theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
@[simp]
| Mathlib/Topology/PartitionOfUnity.lean | 193 | 196 | theorem coe_finsupport (xβ : X) :
(Ο.finsupport xβ : Set ΞΉ) = support fun i β¦ Ο i xβ := by |
ext
rw [Finset.mem_coe, mem_finsupport]
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section finsupport
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
def finsupport : Finset ΞΉ := (Ο.locallyFinite.point_finite xβ).toFinset
@[simp]
theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
@[simp]
theorem coe_finsupport (xβ : X) :
(Ο.finsupport xβ : Set ΞΉ) = support fun i β¦ Ο i xβ := by
ext
rw [Finset.mem_coe, mem_finsupport]
variable {xβ : X}
| Mathlib/Topology/PartitionOfUnity.lean | 200 | 201 | theorem sum_finsupport (hxβ : xβ β s) : β i β Ο.finsupport xβ, Ο i xβ = 1 := by |
rw [β Ο.sum_eq_one hxβ, finsum_eq_sum_of_support_subset _ (Ο.coe_finsupport xβ).superset]
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section finsupport
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
def finsupport : Finset ΞΉ := (Ο.locallyFinite.point_finite xβ).toFinset
@[simp]
theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
@[simp]
theorem coe_finsupport (xβ : X) :
(Ο.finsupport xβ : Set ΞΉ) = support fun i β¦ Ο i xβ := by
ext
rw [Finset.mem_coe, mem_finsupport]
variable {xβ : X}
theorem sum_finsupport (hxβ : xβ β s) : β i β Ο.finsupport xβ, Ο i xβ = 1 := by
rw [β Ο.sum_eq_one hxβ, finsum_eq_sum_of_support_subset _ (Ο.coe_finsupport xβ).superset]
| Mathlib/Topology/PartitionOfUnity.lean | 203 | 212 | theorem sum_finsupport' (hxβ : xβ β s) {I : Finset ΞΉ} (hI : Ο.finsupport xβ β I) :
β i β I, Ο i xβ = 1 := by |
classical
rw [β Finset.sum_sdiff hI, Ο.sum_finsupport hxβ]
suffices β i β I \ Ο.finsupport xβ, (Ο i) xβ = β i β I \ Ο.finsupport xβ, 0 by
rw [this, add_left_eq_self, Finset.sum_const_zero]
apply Finset.sum_congr rfl
rintro x hx
simp only [Finset.mem_sdiff, Ο.mem_finsupport, mem_support, Classical.not_not] at hx
exact hx.2
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section finsupport
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
def finsupport : Finset ΞΉ := (Ο.locallyFinite.point_finite xβ).toFinset
@[simp]
theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
@[simp]
theorem coe_finsupport (xβ : X) :
(Ο.finsupport xβ : Set ΞΉ) = support fun i β¦ Ο i xβ := by
ext
rw [Finset.mem_coe, mem_finsupport]
variable {xβ : X}
theorem sum_finsupport (hxβ : xβ β s) : β i β Ο.finsupport xβ, Ο i xβ = 1 := by
rw [β Ο.sum_eq_one hxβ, finsum_eq_sum_of_support_subset _ (Ο.coe_finsupport xβ).superset]
theorem sum_finsupport' (hxβ : xβ β s) {I : Finset ΞΉ} (hI : Ο.finsupport xβ β I) :
β i β I, Ο i xβ = 1 := by
classical
rw [β Finset.sum_sdiff hI, Ο.sum_finsupport hxβ]
suffices β i β I \ Ο.finsupport xβ, (Ο i) xβ = β i β I \ Ο.finsupport xβ, 0 by
rw [this, add_left_eq_self, Finset.sum_const_zero]
apply Finset.sum_congr rfl
rintro x hx
simp only [Finset.mem_sdiff, Ο.mem_finsupport, mem_support, Classical.not_not] at hx
exact hx.2
| Mathlib/Topology/PartitionOfUnity.lean | 214 | 220 | theorem sum_finsupport_smul_eq_finsum {M : Type*} [AddCommGroup M] [Module β M] (Ο : ΞΉ β X β M) :
β i β Ο.finsupport xβ, Ο i xβ β’ Ο i xβ = βαΆ i, Ο i xβ β’ Ο i xβ := by |
apply (finsum_eq_sum_of_support_subset _ _).symm
have : (fun i β¦ (Ο i) xβ β’ Ο i xβ) = (fun i β¦ (Ο i) xβ) β’ (fun i β¦ Ο i xβ) :=
funext fun _ => (Pi.smul_apply' _ _ _).symm
rw [Ο.coe_finsupport xβ, this, support_smul]
exact inter_subset_left
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section fintsupport -- partitions of unity have locally finite `tsupport`
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
| Mathlib/Topology/PartitionOfUnity.lean | 229 | 234 | theorem finite_tsupport : {i | xβ β tsupport (Ο i)}.Finite := by |
rcases Ο.locallyFinite xβ with β¨t, t_in, htβ©
apply ht.subset
rintro i hi
simp only [inter_comm]
exact mem_closure_iff_nhds.mp hi t t_in
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
section fintsupport -- partitions of unity have locally finite `tsupport`
variable {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X)
theorem finite_tsupport : {i | xβ β tsupport (Ο i)}.Finite := by
rcases Ο.locallyFinite xβ with β¨t, t_in, htβ©
apply ht.subset
rintro i hi
simp only [inter_comm]
exact mem_closure_iff_nhds.mp hi t t_in
def fintsupport (xβ : X) : Finset ΞΉ :=
(Ο.finite_tsupport xβ).toFinset
theorem mem_fintsupport_iff (i : ΞΉ) : i β Ο.fintsupport xβ β xβ β tsupport (Ο i) :=
Finite.mem_toFinset _
| Mathlib/Topology/PartitionOfUnity.lean | 244 | 249 | theorem eventually_fintsupport_subset :
βαΆ y in π xβ, Ο.fintsupport y β Ο.fintsupport xβ := by |
apply (Ο.locallyFinite.closure.eventually_subset (fun _ β¦ isClosed_closure) xβ).mono
intro y hy z hz
rw [PartitionOfUnity.mem_fintsupport_iff] at *
exact hy hz
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
theorem continuous_smul {g : X β E} {i : ΞΉ} (hg : β x β tsupport (f i), ContinuousAt g x) :
Continuous fun x => f i x β’ g x :=
continuous_of_tsupport fun x hx =>
((f i).continuousAt x).smul <| hg x <| tsupport_smul_subset_left _ _ hx
#align partition_of_unity.continuous_smul PartitionOfUnity.continuous_smul
theorem continuous_finsum_smul [ContinuousAdd E] {g : ΞΉ β X β E}
(hg : β (i), β x β tsupport (f i), ContinuousAt (g i) x) :
Continuous fun x => βαΆ i, f i x β’ g i x :=
(continuous_finsum fun i => f.continuous_smul (hg i)) <|
f.locallyFinite.subset fun _ => support_smul_subset_left _ _
#align partition_of_unity.continuous_finsum_smul PartitionOfUnity.continuous_finsum_smul
def IsSubordinate (U : ΞΉ β Set X) : Prop :=
β i, tsupport (f i) β U i
#align partition_of_unity.is_subordinate PartitionOfUnity.IsSubordinate
variable {f}
| Mathlib/Topology/PartitionOfUnity.lean | 289 | 295 | theorem exists_finset_nhd' {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X) :
β I : Finset ΞΉ, (βαΆ x in π[s] xβ, β i β I, Ο i x = 1) β§
βαΆ x in π xβ, support (Ο Β· x) β I := by |
rcases Ο.locallyFinite.exists_finset_support xβ with β¨I, hIβ©
refine β¨I, eventually_nhdsWithin_iff.mpr (hI.mono fun x hx x_in β¦ ?_), hIβ©
have : βαΆ i : ΞΉ, Ο i x = β i β I, Ο i x := finsum_eq_sum_of_support_subset _ hx
rwa [eq_comm, Ο.sum_eq_one x_in] at this
| 1,758 |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Function Set Filter
open scoped Classical
open Topology
noncomputable section
structure PartitionOfUnity (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
sum_eq_one' : β x β s, βαΆ i, toFun i x = 1
sum_le_one' : β x, βαΆ i, toFun i x β€ 1
#align partition_of_unity PartitionOfUnity
structure BumpCovering (ΞΉ X : Type*) [TopologicalSpace X] (s : Set X := univ) where
toFun : ΞΉ β C(X, β)
locallyFinite' : LocallyFinite fun i => support (toFun i)
nonneg' : 0 β€ toFun
le_one' : toFun β€ 1
eventuallyEq_one' : β x β s, β i, toFun i =αΆ [π x] 1
#align bump_covering BumpCovering
variable {ΞΉ : Type u} {X : Type v} [TopologicalSpace X]
namespace PartitionOfUnity
variable {E : Type*} [AddCommMonoid E] [SMulWithZero β E] [TopologicalSpace E] [ContinuousSMul β E]
{s : Set X} (f : PartitionOfUnity ΞΉ X s)
instance : FunLike (PartitionOfUnity ΞΉ X s) ΞΉ C(X, β) where
coe := toFun
coe_injective' := fun f g h β¦ by cases f; cases g; congr
protected theorem locallyFinite : LocallyFinite fun i => support (f i) :=
f.locallyFinite'
#align partition_of_unity.locally_finite PartitionOfUnity.locallyFinite
theorem locallyFinite_tsupport : LocallyFinite fun i => tsupport (f i) :=
f.locallyFinite.closure
#align partition_of_unity.locally_finite_tsupport PartitionOfUnity.locallyFinite_tsupport
theorem nonneg (i : ΞΉ) (x : X) : 0 β€ f i x :=
f.nonneg' i x
#align partition_of_unity.nonneg PartitionOfUnity.nonneg
theorem sum_eq_one {x : X} (hx : x β s) : βαΆ i, f i x = 1 :=
f.sum_eq_one' x hx
#align partition_of_unity.sum_eq_one PartitionOfUnity.sum_eq_one
theorem exists_pos {x : X} (hx : x β s) : β i, 0 < f i x := by
have H := f.sum_eq_one hx
contrapose! H
simpa only [fun i => (H i).antisymm (f.nonneg i x), finsum_zero] using zero_ne_one
#align partition_of_unity.exists_pos PartitionOfUnity.exists_pos
theorem sum_le_one (x : X) : βαΆ i, f i x β€ 1 :=
f.sum_le_one' x
#align partition_of_unity.sum_le_one PartitionOfUnity.sum_le_one
theorem sum_nonneg (x : X) : 0 β€ βαΆ i, f i x :=
finsum_nonneg fun i => f.nonneg i x
#align partition_of_unity.sum_nonneg PartitionOfUnity.sum_nonneg
theorem le_one (i : ΞΉ) (x : X) : f i x β€ 1 :=
(single_le_finsum i (f.locallyFinite.point_finite x) fun j => f.nonneg j x).trans (f.sum_le_one x)
#align partition_of_unity.le_one PartitionOfUnity.le_one
theorem continuous_smul {g : X β E} {i : ΞΉ} (hg : β x β tsupport (f i), ContinuousAt g x) :
Continuous fun x => f i x β’ g x :=
continuous_of_tsupport fun x hx =>
((f i).continuousAt x).smul <| hg x <| tsupport_smul_subset_left _ _ hx
#align partition_of_unity.continuous_smul PartitionOfUnity.continuous_smul
theorem continuous_finsum_smul [ContinuousAdd E] {g : ΞΉ β X β E}
(hg : β (i), β x β tsupport (f i), ContinuousAt (g i) x) :
Continuous fun x => βαΆ i, f i x β’ g i x :=
(continuous_finsum fun i => f.continuous_smul (hg i)) <|
f.locallyFinite.subset fun _ => support_smul_subset_left _ _
#align partition_of_unity.continuous_finsum_smul PartitionOfUnity.continuous_finsum_smul
def IsSubordinate (U : ΞΉ β Set X) : Prop :=
β i, tsupport (f i) β U i
#align partition_of_unity.is_subordinate PartitionOfUnity.IsSubordinate
variable {f}
theorem exists_finset_nhd' {s : Set X} (Ο : PartitionOfUnity ΞΉ X s) (xβ : X) :
β I : Finset ΞΉ, (βαΆ x in π[s] xβ, β i β I, Ο i x = 1) β§
βαΆ x in π xβ, support (Ο Β· x) β I := by
rcases Ο.locallyFinite.exists_finset_support xβ with β¨I, hIβ©
refine β¨I, eventually_nhdsWithin_iff.mpr (hI.mono fun x hx x_in β¦ ?_), hIβ©
have : βαΆ i : ΞΉ, Ο i x = β i β I, Ο i x := finsum_eq_sum_of_support_subset _ hx
rwa [eq_comm, Ο.sum_eq_one x_in] at this
| Mathlib/Topology/PartitionOfUnity.lean | 297 | 301 | theorem exists_finset_nhd (Ο : PartitionOfUnity ΞΉ X univ) (xβ : X) :
β I : Finset ΞΉ, βαΆ x in π xβ, β i β I, Ο i x = 1 β§ support (Ο Β· x) β I := by |
rcases Ο.exists_finset_nhd' xβ with β¨I, Hβ©
use I
rwa [nhdsWithin_univ, β eventually_and] at H
| 1,758 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Topology.MetricSpace.HausdorffDistance
import Mathlib.Topology.Sets.Compacts
#align_import topology.metric_space.closeds from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Topology ENNReal
universe u
open scoped Classical
open Set Function TopologicalSpace Filter
namespace EMetric
section
variable {Ξ± : Type u} [EMetricSpace Ξ±] {s : Set Ξ±}
instance Closeds.emetricSpace : EMetricSpace (Closeds Ξ±) where
edist s t := hausdorffEdist (s : Set Ξ±) t
edist_self s := hausdorffEdist_self
edist_comm s t := hausdorffEdist_comm
edist_triangle s t u := hausdorffEdist_triangle
eq_of_edist_eq_zero {s t} h :=
Closeds.ext <| (hausdorffEdist_zero_iff_eq_of_closed s.closed t.closed).1 h
#align emetric.closeds.emetric_space EMetric.Closeds.emetricSpace
| Mathlib/Topology/MetricSpace/Closeds.lean | 56 | 69 | theorem continuous_infEdist_hausdorffEdist :
Continuous fun p : Ξ± Γ Closeds Ξ± => infEdist p.1 p.2 := by |
refine continuous_of_le_add_edist 2 (by simp) ?_
rintro β¨x, sβ© β¨y, tβ©
calc
infEdist x s β€ infEdist x t + hausdorffEdist (t : Set Ξ±) s :=
infEdist_le_infEdist_add_hausdorffEdist
_ β€ infEdist y t + edist x y + hausdorffEdist (t : Set Ξ±) s :=
(add_le_add_right infEdist_le_infEdist_add_edist _)
_ = infEdist y t + (edist x y + hausdorffEdist (s : Set Ξ±) t) := by
rw [add_assoc, hausdorffEdist_comm]
_ β€ infEdist y t + (edist (x, s) (y, t) + edist (x, s) (y, t)) :=
(add_le_add_left (add_le_add (le_max_left _ _) (le_max_right _ _)) _)
_ = infEdist y t + 2 * edist (x, s) (y, t) := by rw [β mul_two, mul_comm]
| 1,759 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Topology.MetricSpace.HausdorffDistance
import Mathlib.Topology.Sets.Compacts
#align_import topology.metric_space.closeds from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Topology ENNReal
universe u
open scoped Classical
open Set Function TopologicalSpace Filter
namespace EMetric
section
variable {Ξ± : Type u} [EMetricSpace Ξ±] {s : Set Ξ±}
instance Closeds.emetricSpace : EMetricSpace (Closeds Ξ±) where
edist s t := hausdorffEdist (s : Set Ξ±) t
edist_self s := hausdorffEdist_self
edist_comm s t := hausdorffEdist_comm
edist_triangle s t u := hausdorffEdist_triangle
eq_of_edist_eq_zero {s t} h :=
Closeds.ext <| (hausdorffEdist_zero_iff_eq_of_closed s.closed t.closed).1 h
#align emetric.closeds.emetric_space EMetric.Closeds.emetricSpace
theorem continuous_infEdist_hausdorffEdist :
Continuous fun p : Ξ± Γ Closeds Ξ± => infEdist p.1 p.2 := by
refine continuous_of_le_add_edist 2 (by simp) ?_
rintro β¨x, sβ© β¨y, tβ©
calc
infEdist x s β€ infEdist x t + hausdorffEdist (t : Set Ξ±) s :=
infEdist_le_infEdist_add_hausdorffEdist
_ β€ infEdist y t + edist x y + hausdorffEdist (t : Set Ξ±) s :=
(add_le_add_right infEdist_le_infEdist_add_edist _)
_ = infEdist y t + (edist x y + hausdorffEdist (s : Set Ξ±) t) := by
rw [add_assoc, hausdorffEdist_comm]
_ β€ infEdist y t + (edist (x, s) (y, t) + edist (x, s) (y, t)) :=
(add_le_add_left (add_le_add (le_max_left _ _) (le_max_right _ _)) _)
_ = infEdist y t + 2 * edist (x, s) (y, t) := by rw [β mul_two, mul_comm]
set_option linter.uppercaseLean3 false in
#align emetric.continuous_infEdist_hausdorffEdist EMetric.continuous_infEdist_hausdorffEdist
| Mathlib/Topology/MetricSpace/Closeds.lean | 74 | 84 | theorem isClosed_subsets_of_isClosed (hs : IsClosed s) :
IsClosed { t : Closeds Ξ± | (t : Set Ξ±) β s } := by |
refine isClosed_of_closure_subset fun
(t : Closeds Ξ±) (ht : t β closure {t : Closeds Ξ± | (t : Set Ξ±) β s}) (x : Ξ±) (hx : x β t) => ?_
have : x β closure s := by
refine mem_closure_iff.2 fun Ξ΅ Ξ΅pos => ?_
obtain β¨u : Closeds Ξ±, hu : u β {t : Closeds Ξ± | (t : Set Ξ±) β s}, Dtu : edist t u < Ξ΅β© :=
mem_closure_iff.1 ht Ξ΅ Ξ΅pos
obtain β¨y : Ξ±, hy : y β u, Dxy : edist x y < Ξ΅β© := exists_edist_lt_of_hausdorffEdist_lt hx Dtu
exact β¨y, hu hy, Dxyβ©
rwa [hs.closure_eq] at this
| 1,759 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
namespace NormedField
theorem tendsto_norm_inverse_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] :
Tendsto (fun x : π β¦ βxβ»ΒΉβ) (π[β ] 0) atTop :=
(tendsto_inv_zero_atTop.comp tendsto_norm_zero').congr fun x β¦ (norm_inv x).symm
#align normed_field.tendsto_norm_inverse_nhds_within_0_at_top NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
| Mathlib/Analysis/SpecificLimits/Normed.lean | 62 | 68 | theorem tendsto_norm_zpow_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] {m : β€}
(hm : m < 0) :
Tendsto (fun x : π β¦ βx ^ mβ) (π[β ] 0) atTop := by |
rcases neg_surjective m with β¨m, rflβ©
rw [neg_lt_zero] at hm; lift m to β using hm.le; rw [Int.natCast_pos] at hm
simp only [norm_pow, zpow_neg, zpow_natCast, β inv_pow]
exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
| 1,760 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
namespace NormedField
theorem tendsto_norm_inverse_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] :
Tendsto (fun x : π β¦ βxβ»ΒΉβ) (π[β ] 0) atTop :=
(tendsto_inv_zero_atTop.comp tendsto_norm_zero').congr fun x β¦ (norm_inv x).symm
#align normed_field.tendsto_norm_inverse_nhds_within_0_at_top NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
theorem tendsto_norm_zpow_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] {m : β€}
(hm : m < 0) :
Tendsto (fun x : π β¦ βx ^ mβ) (π[β ] 0) atTop := by
rcases neg_surjective m with β¨m, rflβ©
rw [neg_lt_zero] at hm; lift m to β using hm.le; rw [Int.natCast_pos] at hm
simp only [norm_pow, zpow_neg, zpow_natCast, β inv_pow]
exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
#align normed_field.tendsto_norm_zpow_nhds_within_0_at_top NormedField.tendsto_norm_zpow_nhdsWithin_0_atTop
| Mathlib/Analysis/SpecificLimits/Normed.lean | 72 | 77 | theorem tendsto_zero_smul_of_tendsto_zero_of_bounded {ΞΉ π πΈ : Type*} [NormedDivisionRing π]
[NormedAddCommGroup πΈ] [Module π πΈ] [BoundedSMul π πΈ] {l : Filter ΞΉ} {Ξ΅ : ΞΉ β π} {f : ΞΉ β πΈ}
(hΞ΅ : Tendsto Ξ΅ l (π 0)) (hf : Filter.IsBoundedUnder (Β· β€ Β·) l (norm β f)) :
Tendsto (Ξ΅ β’ f) l (π 0) := by |
rw [β isLittleO_one_iff π] at hΞ΅ β’
simpa using IsLittleO.smul_isBigO hΞ΅ (hf.isBigO_const (one_ne_zero : (1 : π) β 0))
| 1,760 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
namespace NormedField
theorem tendsto_norm_inverse_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] :
Tendsto (fun x : π β¦ βxβ»ΒΉβ) (π[β ] 0) atTop :=
(tendsto_inv_zero_atTop.comp tendsto_norm_zero').congr fun x β¦ (norm_inv x).symm
#align normed_field.tendsto_norm_inverse_nhds_within_0_at_top NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
theorem tendsto_norm_zpow_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] {m : β€}
(hm : m < 0) :
Tendsto (fun x : π β¦ βx ^ mβ) (π[β ] 0) atTop := by
rcases neg_surjective m with β¨m, rflβ©
rw [neg_lt_zero] at hm; lift m to β using hm.le; rw [Int.natCast_pos] at hm
simp only [norm_pow, zpow_neg, zpow_natCast, β inv_pow]
exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
#align normed_field.tendsto_norm_zpow_nhds_within_0_at_top NormedField.tendsto_norm_zpow_nhdsWithin_0_atTop
theorem tendsto_zero_smul_of_tendsto_zero_of_bounded {ΞΉ π πΈ : Type*} [NormedDivisionRing π]
[NormedAddCommGroup πΈ] [Module π πΈ] [BoundedSMul π πΈ] {l : Filter ΞΉ} {Ξ΅ : ΞΉ β π} {f : ΞΉ β πΈ}
(hΞ΅ : Tendsto Ξ΅ l (π 0)) (hf : Filter.IsBoundedUnder (Β· β€ Β·) l (norm β f)) :
Tendsto (Ξ΅ β’ f) l (π 0) := by
rw [β isLittleO_one_iff π] at hΞ΅ β’
simpa using IsLittleO.smul_isBigO hΞ΅ (hf.isBigO_const (one_ne_zero : (1 : π) β 0))
#align normed_field.tendsto_zero_smul_of_tendsto_zero_of_bounded NormedField.tendsto_zero_smul_of_tendsto_zero_of_bounded
@[simp]
| Mathlib/Analysis/SpecificLimits/Normed.lean | 81 | 86 | theorem continuousAt_zpow {π : Type*} [NontriviallyNormedField π] {m : β€} {x : π} :
ContinuousAt (fun x β¦ x ^ m) x β x β 0 β¨ 0 β€ m := by |
refine β¨?_, continuousAt_zpowβ _ _β©
contrapose!; rintro β¨rfl, hmβ© hc
exact not_tendsto_atTop_of_tendsto_nhds (hc.tendsto.mono_left nhdsWithin_le_nhds).norm
(tendsto_norm_zpow_nhdsWithin_0_atTop hm)
| 1,760 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
namespace NormedField
theorem tendsto_norm_inverse_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] :
Tendsto (fun x : π β¦ βxβ»ΒΉβ) (π[β ] 0) atTop :=
(tendsto_inv_zero_atTop.comp tendsto_norm_zero').congr fun x β¦ (norm_inv x).symm
#align normed_field.tendsto_norm_inverse_nhds_within_0_at_top NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
theorem tendsto_norm_zpow_nhdsWithin_0_atTop {π : Type*} [NormedDivisionRing π] {m : β€}
(hm : m < 0) :
Tendsto (fun x : π β¦ βx ^ mβ) (π[β ] 0) atTop := by
rcases neg_surjective m with β¨m, rflβ©
rw [neg_lt_zero] at hm; lift m to β using hm.le; rw [Int.natCast_pos] at hm
simp only [norm_pow, zpow_neg, zpow_natCast, β inv_pow]
exact (tendsto_pow_atTop hm.ne').comp NormedField.tendsto_norm_inverse_nhdsWithin_0_atTop
#align normed_field.tendsto_norm_zpow_nhds_within_0_at_top NormedField.tendsto_norm_zpow_nhdsWithin_0_atTop
theorem tendsto_zero_smul_of_tendsto_zero_of_bounded {ΞΉ π πΈ : Type*} [NormedDivisionRing π]
[NormedAddCommGroup πΈ] [Module π πΈ] [BoundedSMul π πΈ] {l : Filter ΞΉ} {Ξ΅ : ΞΉ β π} {f : ΞΉ β πΈ}
(hΞ΅ : Tendsto Ξ΅ l (π 0)) (hf : Filter.IsBoundedUnder (Β· β€ Β·) l (norm β f)) :
Tendsto (Ξ΅ β’ f) l (π 0) := by
rw [β isLittleO_one_iff π] at hΞ΅ β’
simpa using IsLittleO.smul_isBigO hΞ΅ (hf.isBigO_const (one_ne_zero : (1 : π) β 0))
#align normed_field.tendsto_zero_smul_of_tendsto_zero_of_bounded NormedField.tendsto_zero_smul_of_tendsto_zero_of_bounded
@[simp]
theorem continuousAt_zpow {π : Type*} [NontriviallyNormedField π] {m : β€} {x : π} :
ContinuousAt (fun x β¦ x ^ m) x β x β 0 β¨ 0 β€ m := by
refine β¨?_, continuousAt_zpowβ _ _β©
contrapose!; rintro β¨rfl, hmβ© hc
exact not_tendsto_atTop_of_tendsto_nhds (hc.tendsto.mono_left nhdsWithin_le_nhds).norm
(tendsto_norm_zpow_nhdsWithin_0_atTop hm)
#align normed_field.continuous_at_zpow NormedField.continuousAt_zpow
@[simp]
| Mathlib/Analysis/SpecificLimits/Normed.lean | 90 | 92 | theorem continuousAt_inv {π : Type*} [NontriviallyNormedField π] {x : π} :
ContinuousAt Inv.inv x β x β 0 := by |
simpa [(zero_lt_one' β€).not_le] using @continuousAt_zpow _ _ (-1) x
| 1,760 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
theorem isLittleO_pow_pow_of_lt_left {rβ rβ : β} (hβ : 0 β€ rβ) (hβ : rβ < rβ) :
(fun n : β β¦ rβ ^ n) =o[atTop] fun n β¦ rβ ^ n :=
have H : 0 < rβ := hβ.trans_lt hβ
(isLittleO_of_tendsto fun _ hn β¦ False.elim <| H.ne' <| pow_eq_zero hn) <|
(tendsto_pow_atTop_nhds_zero_of_lt_one
(div_nonneg hβ (hβ.trans hβ.le)) ((div_lt_one H).2 hβ)).congr fun _ β¦ div_pow _ _ _
#align is_o_pow_pow_of_lt_left isLittleO_pow_pow_of_lt_left
theorem isBigO_pow_pow_of_le_left {rβ rβ : β} (hβ : 0 β€ rβ) (hβ : rβ β€ rβ) :
(fun n : β β¦ rβ ^ n) =O[atTop] fun n β¦ rβ ^ n :=
hβ.eq_or_lt.elim (fun h β¦ h βΈ isBigO_refl _ _) fun h β¦ (isLittleO_pow_pow_of_lt_left hβ h).isBigO
set_option linter.uppercaseLean3 false in
#align is_O_pow_pow_of_le_left isBigO_pow_pow_of_le_left
| Mathlib/Analysis/SpecificLimits/Normed.lean | 111 | 114 | theorem isLittleO_pow_pow_of_abs_lt_left {rβ rβ : β} (h : |rβ| < |rβ|) :
(fun n : β β¦ rβ ^ n) =o[atTop] fun n β¦ rβ ^ n := by |
refine (IsLittleO.of_norm_left ?_).of_norm_right
exact (isLittleO_pow_pow_of_lt_left (abs_nonneg rβ) h).congr (pow_abs rβ) (pow_abs rβ)
| 1,760 |
import Mathlib.Algebra.BigOperators.Module
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Order.Filter.ModEq
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.List.TFAE
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.specific_limits.normed from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Set Function Filter Finset Metric Asymptotics
open scoped Classical
open Topology Nat uniformity NNReal ENNReal
variable {Ξ± : Type*} {Ξ² : Type*} {ΞΉ : Type*}
theorem tendsto_norm_atTop_atTop : Tendsto (norm : β β β) atTop atTop :=
tendsto_abs_atTop_atTop
#align tendsto_norm_at_top_at_top tendsto_norm_atTop_atTop
theorem summable_of_absolute_convergence_real {f : β β β} :
(β r, Tendsto (fun n β¦ β i β range n, |f i|) atTop (π r)) β Summable f
| β¨r, hrβ© => by
refine .of_norm β¨r, (hasSum_iff_tendsto_nat_of_nonneg ?_ _).2 ?_β©
Β· exact fun i β¦ norm_nonneg _
Β· simpa only using hr
#align summable_of_absolute_convergence_real summable_of_absolute_convergence_real
theorem tendsto_norm_zero' {π : Type*} [NormedAddCommGroup π] :
Tendsto (norm : π β β) (π[β ] 0) (π[>] 0) :=
tendsto_norm_zero.inf <| tendsto_principal_principal.2 fun _ hx β¦ norm_pos_iff.2 hx
#align tendsto_norm_zero' tendsto_norm_zero'
theorem isLittleO_pow_pow_of_lt_left {rβ rβ : β} (hβ : 0 β€ rβ) (hβ : rβ < rβ) :
(fun n : β β¦ rβ ^ n) =o[atTop] fun n β¦ rβ ^ n :=
have H : 0 < rβ := hβ.trans_lt hβ
(isLittleO_of_tendsto fun _ hn β¦ False.elim <| H.ne' <| pow_eq_zero hn) <|
(tendsto_pow_atTop_nhds_zero_of_lt_one
(div_nonneg hβ (hβ.trans hβ.le)) ((div_lt_one H).2 hβ)).congr fun _ β¦ div_pow _ _ _
#align is_o_pow_pow_of_lt_left isLittleO_pow_pow_of_lt_left
theorem isBigO_pow_pow_of_le_left {rβ rβ : β} (hβ : 0 β€ rβ) (hβ : rβ β€ rβ) :
(fun n : β β¦ rβ ^ n) =O[atTop] fun n β¦ rβ ^ n :=
hβ.eq_or_lt.elim (fun h β¦ h βΈ isBigO_refl _ _) fun h β¦ (isLittleO_pow_pow_of_lt_left hβ h).isBigO
set_option linter.uppercaseLean3 false in
#align is_O_pow_pow_of_le_left isBigO_pow_pow_of_le_left
theorem isLittleO_pow_pow_of_abs_lt_left {rβ rβ : β} (h : |rβ| < |rβ|) :
(fun n : β β¦ rβ ^ n) =o[atTop] fun n β¦ rβ ^ n := by
refine (IsLittleO.of_norm_left ?_).of_norm_right
exact (isLittleO_pow_pow_of_lt_left (abs_nonneg rβ) h).congr (pow_abs rβ) (pow_abs rβ)
#align is_o_pow_pow_of_abs_lt_left isLittleO_pow_pow_of_abs_lt_left
open List in
| Mathlib/Analysis/SpecificLimits/Normed.lean | 132 | 189 | theorem TFAE_exists_lt_isLittleO_pow (f : β β β) (R : β) :
TFAE
[β a β Ioo (-R) R, f =o[atTop] (a ^ Β·), β a β Ioo 0 R, f =o[atTop] (a ^ Β·),
β a β Ioo (-R) R, f =O[atTop] (a ^ Β·), β a β Ioo 0 R, f =O[atTop] (a ^ Β·),
β a < R, β C : β, (0 < C β¨ 0 < R) β§ β n, |f n| β€ C * a ^ n,
β a β Ioo 0 R, β C > 0, β n, |f n| β€ C * a ^ n, β a < R, βαΆ n in atTop, |f n| β€ a ^ n,
β a β Ioo 0 R, βαΆ n in atTop, |f n| β€ a ^ n] := by |
have A : Ico 0 R β Ioo (-R) R :=
fun x hx β¦ β¨(neg_lt_zero.2 (hx.1.trans_lt hx.2)).trans_le hx.1, hx.2β©
have B : Ioo 0 R β Ioo (-R) R := Subset.trans Ioo_subset_Ico_self A
-- First we prove that 1-4 are equivalent using 2 β 3 β 4, 1 β 3, and 2 β 1
tfae_have 1 β 3
Β· exact fun β¨a, ha, Hβ© β¦ β¨a, ha, H.isBigOβ©
tfae_have 2 β 1
Β· exact fun β¨a, ha, Hβ© β¦ β¨a, B ha, Hβ©
tfae_have 3 β 2
Β· rintro β¨a, ha, Hβ©
rcases exists_between (abs_lt.2 ha) with β¨b, hab, hbRβ©
exact β¨b, β¨(abs_nonneg a).trans_lt hab, hbRβ©,
H.trans_isLittleO (isLittleO_pow_pow_of_abs_lt_left (hab.trans_le (le_abs_self b)))β©
tfae_have 2 β 4
Β· exact fun β¨a, ha, Hβ© β¦ β¨a, ha, H.isBigOβ©
tfae_have 4 β 3
Β· exact fun β¨a, ha, Hβ© β¦ β¨a, B ha, Hβ©
-- Add 5 and 6 using 4 β 6 β 5 β 3
tfae_have 4 β 6
Β· rintro β¨a, ha, Hβ©
rcases bound_of_isBigO_nat_atTop H with β¨C, hCβ, hCβ©
refine β¨a, ha, C, hCβ, fun n β¦ ?_β©
simpa only [Real.norm_eq_abs, abs_pow, abs_of_nonneg ha.1.le] using hC (pow_ne_zero n ha.1.ne')
tfae_have 6 β 5
Β· exact fun β¨a, ha, C, Hβ, Hβ© β¦ β¨a, ha.2, C, Or.inl Hβ, Hβ©
tfae_have 5 β 3
Β· rintro β¨a, ha, C, hβ, Hβ©
rcases sign_cases_of_C_mul_pow_nonneg fun n β¦ (abs_nonneg _).trans (H n) with (rfl | β¨hCβ, haββ©)
Β· obtain rfl : f = 0 := by
ext n
simpa using H n
simp only [lt_irrefl, false_or_iff] at hβ
exact β¨0, β¨neg_lt_zero.2 hβ, hββ©, isBigO_zero _ _β©
exact β¨a, A β¨haβ, haβ©,
isBigO_of_le' _ fun n β¦ (H n).trans <| mul_le_mul_of_nonneg_left (le_abs_self _) hCβ.leβ©
-- Add 7 and 8 using 2 β 8 β 7 β 3
tfae_have 2 β 8
Β· rintro β¨a, ha, Hβ©
refine β¨a, ha, (H.def zero_lt_one).mono fun n hn β¦ ?_β©
rwa [Real.norm_eq_abs, Real.norm_eq_abs, one_mul, abs_pow, abs_of_pos ha.1] at hn
tfae_have 8 β 7
Β· exact fun β¨a, ha, Hβ© β¦ β¨a, ha.2, Hβ©
tfae_have 7 β 3
Β· rintro β¨a, ha, Hβ©
have : 0 β€ a := nonneg_of_eventually_pow_nonneg (H.mono fun n β¦ (abs_nonneg _).trans)
refine β¨a, A β¨this, haβ©, IsBigO.of_bound 1 ?_β©
simpa only [Real.norm_eq_abs, one_mul, abs_pow, abs_of_nonneg this]
-- Porting note: used to work without explicitly having 6 β 7
tfae_have 6 β 7
Β· exact fun h β¦ tfae_8_to_7 <| tfae_2_to_8 <| tfae_3_to_2 <| tfae_5_to_3 <| tfae_6_to_5 h
tfae_finish
| 1,760 |
import Mathlib.Analysis.Normed.Group.Hom
import Mathlib.Analysis.SpecificLimits.Normed
#align_import analysis.normed.group.controlled_closure from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Finset
open Topology
variable {G : Type*} [NormedAddCommGroup G] [CompleteSpace G]
variable {H : Type*} [NormedAddCommGroup H]
| Mathlib/Analysis/Normed/Group/ControlledClosure.lean | 32 | 106 | theorem controlled_closure_of_complete {f : NormedAddGroupHom G H} {K : AddSubgroup H} {C Ξ΅ : β}
(hC : 0 < C) (hΞ΅ : 0 < Ξ΅) (hyp : f.SurjectiveOnWith K C) :
f.SurjectiveOnWith K.topologicalClosure (C + Ξ΅) := by |
rintro (h : H) (h_in : h β K.topologicalClosure)
-- We first get rid of the easy case where `h = 0`.
by_cases hyp_h : h = 0
Β· rw [hyp_h]
use 0
simp
/- The desired preimage will be constructed as the sum of a series. Convergence of
the series will be guaranteed by completeness of `G`. We first write `h` as the sum
of a sequence `v` of elements of `K` which starts close to `h` and then quickly goes to zero.
The sequence `b` below quantifies this. -/
set b : β β β := fun i => (1 / 2) ^ i * (Ξ΅ * βhβ / 2) / C
have b_pos (i) : 0 < b i := by field_simp [b, hC, hyp_h]
obtain
β¨v : β β H, lim_v : Tendsto (fun n : β => β k β range (n + 1), v k) atTop (π h), v_in :
β n, v n β K, hvβ : βv 0 - hβ < b 0, hv : β n > 0, βv nβ < b nβ© :=
controlled_sum_of_mem_closure h_in b_pos
/- The controlled surjectivity assumption on `f` allows to build preimages `u n` for all
elements `v n` of the `v` sequence. -/
have : β n, β m' : G, f m' = v n β§ βm'β β€ C * βv nβ := fun n : β => hyp (v n) (v_in n)
choose u hu hnorm_u using this
/- The desired series `s` is then obtained by summing `u`. We then check our choice of
`b` ensures `s` is Cauchy. -/
set s : β β G := fun n => β k β range (n + 1), u k
have : CauchySeq s := by
apply NormedAddCommGroup.cauchy_series_of_le_geometric'' (by norm_num) one_half_lt_one
Β· rintro n (hn : n β₯ 1)
calc
βu nβ β€ C * βv nβ := hnorm_u n
_ β€ C * b n := by gcongr; exact (hv _ <| Nat.succ_le_iff.mp hn).le
_ = (1 / 2) ^ n * (Ξ΅ * βhβ / 2) := by simp [mul_div_cancelβ _ hC.ne.symm]
_ = Ξ΅ * βhβ / 2 * (1 / 2) ^ n := mul_comm _ _
-- We now show that the limit `g` of `s` is the desired preimage.
obtain β¨g : G, hgβ© := cauchySeq_tendsto_of_complete this
refine β¨g, ?_, ?_β©
Β· -- We indeed get a preimage. First note:
have : f β s = fun n => β k β range (n + 1), v k := by
ext n
simp [s, map_sum, hu]
/- In the above equality, the left-hand-side converges to `f g` by continuity of `f` and
definition of `g` while the right-hand-side converges to `h` by construction of `v` so
`g` is indeed a preimage of `h`. -/
rw [β this] at lim_v
exact tendsto_nhds_unique ((f.continuous.tendsto g).comp hg) lim_v
Β· -- Then we need to estimate the norm of `g`, using our careful choice of `b`.
suffices β n, βs nβ β€ (C + Ξ΅) * βhβ from
le_of_tendsto' (continuous_norm.continuousAt.tendsto.comp hg) this
intro n
have hnormβ : βu 0β β€ C * b 0 + C * βhβ := by
have :=
calc
βv 0β β€ βhβ + βv 0 - hβ := norm_le_insert' _ _
_ β€ βhβ + b 0 := by gcongr
calc
βu 0β β€ C * βv 0β := hnorm_u 0
_ β€ C * (βhβ + b 0) := by gcongr
_ = C * b 0 + C * βhβ := by rw [add_comm, mul_add]
have : (β k β range (n + 1), C * b k) β€ Ξ΅ * βhβ :=
calc (β k β range (n + 1), C * b k)
_ = (β k β range (n + 1), (1 / 2 : β) ^ k) * (Ξ΅ * βhβ / 2) := by
simp only [mul_div_cancelβ _ hC.ne.symm, β sum_mul]
_ β€ 2 * (Ξ΅ * βhβ / 2) := by gcongr; apply sum_geometric_two_le
_ = Ξ΅ * βhβ := mul_div_cancelβ _ two_ne_zero
calc
βs nβ β€ β k β range (n + 1), βu kβ := norm_sum_le _ _
_ = (β k β range n, βu (k + 1)β) + βu 0β := sum_range_succ' _ _
_ β€ (β k β range n, C * βv (k + 1)β) + βu 0β := by gcongr; apply hnorm_u
_ β€ (β k β range n, C * b (k + 1)) + (C * b 0 + C * βhβ) := by
gcongr with k; exact (hv _ k.succ_pos).le
_ = (β k β range (n + 1), C * b k) + C * βhβ := by rw [β add_assoc, sum_range_succ']
_ β€ (C + Ξ΅) * βhβ := by
rw [add_comm, add_mul]
apply add_le_add_left this
| 1,761 |
import Mathlib.Analysis.Normed.Group.Hom
import Mathlib.Analysis.SpecificLimits.Normed
#align_import analysis.normed.group.controlled_closure from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Finset
open Topology
variable {G : Type*} [NormedAddCommGroup G] [CompleteSpace G]
variable {H : Type*} [NormedAddCommGroup H]
theorem controlled_closure_of_complete {f : NormedAddGroupHom G H} {K : AddSubgroup H} {C Ξ΅ : β}
(hC : 0 < C) (hΞ΅ : 0 < Ξ΅) (hyp : f.SurjectiveOnWith K C) :
f.SurjectiveOnWith K.topologicalClosure (C + Ξ΅) := by
rintro (h : H) (h_in : h β K.topologicalClosure)
-- We first get rid of the easy case where `h = 0`.
by_cases hyp_h : h = 0
Β· rw [hyp_h]
use 0
simp
set b : β β β := fun i => (1 / 2) ^ i * (Ξ΅ * βhβ / 2) / C
have b_pos (i) : 0 < b i := by field_simp [b, hC, hyp_h]
obtain
β¨v : β β H, lim_v : Tendsto (fun n : β => β k β range (n + 1), v k) atTop (π h), v_in :
β n, v n β K, hvβ : βv 0 - hβ < b 0, hv : β n > 0, βv nβ < b nβ© :=
controlled_sum_of_mem_closure h_in b_pos
have : β n, β m' : G, f m' = v n β§ βm'β β€ C * βv nβ := fun n : β => hyp (v n) (v_in n)
choose u hu hnorm_u using this
set s : β β G := fun n => β k β range (n + 1), u k
have : CauchySeq s := by
apply NormedAddCommGroup.cauchy_series_of_le_geometric'' (by norm_num) one_half_lt_one
Β· rintro n (hn : n β₯ 1)
calc
βu nβ β€ C * βv nβ := hnorm_u n
_ β€ C * b n := by gcongr; exact (hv _ <| Nat.succ_le_iff.mp hn).le
_ = (1 / 2) ^ n * (Ξ΅ * βhβ / 2) := by simp [mul_div_cancelβ _ hC.ne.symm]
_ = Ξ΅ * βhβ / 2 * (1 / 2) ^ n := mul_comm _ _
-- We now show that the limit `g` of `s` is the desired preimage.
obtain β¨g : G, hgβ© := cauchySeq_tendsto_of_complete this
refine β¨g, ?_, ?_β©
Β· -- We indeed get a preimage. First note:
have : f β s = fun n => β k β range (n + 1), v k := by
ext n
simp [s, map_sum, hu]
rw [β this] at lim_v
exact tendsto_nhds_unique ((f.continuous.tendsto g).comp hg) lim_v
Β· -- Then we need to estimate the norm of `g`, using our careful choice of `b`.
suffices β n, βs nβ β€ (C + Ξ΅) * βhβ from
le_of_tendsto' (continuous_norm.continuousAt.tendsto.comp hg) this
intro n
have hnormβ : βu 0β β€ C * b 0 + C * βhβ := by
have :=
calc
βv 0β β€ βhβ + βv 0 - hβ := norm_le_insert' _ _
_ β€ βhβ + b 0 := by gcongr
calc
βu 0β β€ C * βv 0β := hnorm_u 0
_ β€ C * (βhβ + b 0) := by gcongr
_ = C * b 0 + C * βhβ := by rw [add_comm, mul_add]
have : (β k β range (n + 1), C * b k) β€ Ξ΅ * βhβ :=
calc (β k β range (n + 1), C * b k)
_ = (β k β range (n + 1), (1 / 2 : β) ^ k) * (Ξ΅ * βhβ / 2) := by
simp only [mul_div_cancelβ _ hC.ne.symm, β sum_mul]
_ β€ 2 * (Ξ΅ * βhβ / 2) := by gcongr; apply sum_geometric_two_le
_ = Ξ΅ * βhβ := mul_div_cancelβ _ two_ne_zero
calc
βs nβ β€ β k β range (n + 1), βu kβ := norm_sum_le _ _
_ = (β k β range n, βu (k + 1)β) + βu 0β := sum_range_succ' _ _
_ β€ (β k β range n, C * βv (k + 1)β) + βu 0β := by gcongr; apply hnorm_u
_ β€ (β k β range n, C * b (k + 1)) + (C * b 0 + C * βhβ) := by
gcongr with k; exact (hv _ k.succ_pos).le
_ = (β k β range (n + 1), C * b k) + C * βhβ := by rw [β add_assoc, sum_range_succ']
_ β€ (C + Ξ΅) * βhβ := by
rw [add_comm, add_mul]
apply add_le_add_left this
#align controlled_closure_of_complete controlled_closure_of_complete
| Mathlib/Analysis/Normed/Group/ControlledClosure.lean | 116 | 125 | theorem controlled_closure_range_of_complete {f : NormedAddGroupHom G H} {K : Type*}
[SeminormedAddCommGroup K] {j : NormedAddGroupHom K H} (hj : β x, βj xβ = βxβ) {C Ξ΅ : β}
(hC : 0 < C) (hΞ΅ : 0 < Ξ΅) (hyp : β k, β g, f g = j k β§ βgβ β€ C * βkβ) :
f.SurjectiveOnWith j.range.topologicalClosure (C + Ξ΅) := by |
replace hyp : β h β j.range, β g, f g = h β§ βgβ β€ C * βhβ := by
intro h h_in
rcases (j.mem_range _).mp h_in with β¨k, rflβ©
rw [hj]
exact hyp k
exact controlled_closure_of_complete hC hΞ΅ hyp
| 1,761 |
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
import Mathlib.Analysis.SpecificLimits.Normed
import Mathlib.Logic.Equiv.Fin
import Mathlib.Topology.Algebra.InfiniteSum.Module
#align_import analysis.analytic.basic from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
noncomputable section
variable {π E F G : Type*}
open scoped Classical
open Topology NNReal Filter ENNReal
open Set Filter Asymptotics
namespace FormalMultilinearSeries
variable [Ring π] [AddCommGroup E] [AddCommGroup F] [Module π E] [Module π F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [TopologicalAddGroup E] [TopologicalAddGroup F]
variable [ContinuousConstSMul π E] [ContinuousConstSMul π F]
protected def sum (p : FormalMultilinearSeries π E F) (x : E) : F :=
β' n : β, p n fun _ => x
#align formal_multilinear_series.sum FormalMultilinearSeries.sum
def partialSum (p : FormalMultilinearSeries π E F) (n : β) (x : E) : F :=
β k β Finset.range n, p k fun _ : Fin k => x
#align formal_multilinear_series.partial_sum FormalMultilinearSeries.partialSum
| Mathlib/Analysis/Analytic/Basic.lean | 102 | 105 | theorem partialSum_continuous (p : FormalMultilinearSeries π E F) (n : β) :
Continuous (p.partialSum n) := by |
unfold partialSum -- Porting note: added
continuity
| 1,762 |
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
import Mathlib.Analysis.SpecificLimits.Normed
import Mathlib.Logic.Equiv.Fin
import Mathlib.Topology.Algebra.InfiniteSum.Module
#align_import analysis.analytic.basic from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
noncomputable section
variable {π E F G : Type*}
open scoped Classical
open Topology NNReal Filter ENNReal
open Set Filter Asymptotics
variable [NontriviallyNormedField π] [NormedAddCommGroup E] [NormedSpace π E] [NormedAddCommGroup F]
[NormedSpace π F] [NormedAddCommGroup G] [NormedSpace π G]
namespace FormalMultilinearSeries
variable (p : FormalMultilinearSeries π E F) {r : ββ₯0}
def radius (p : FormalMultilinearSeries π E F) : ββ₯0β :=
β¨ (r : ββ₯0) (C : β) (_ : β n, βp nβ * (r : β) ^ n β€ C), (r : ββ₯0β)
#align formal_multilinear_series.radius FormalMultilinearSeries.radius
theorem le_radius_of_bound (C : β) {r : ββ₯0} (h : β n : β, βp nβ * (r : β) ^ n β€ C) :
(r : ββ₯0β) β€ p.radius :=
le_iSup_of_le r <| le_iSup_of_le C <| le_iSup (fun _ => (r : ββ₯0β)) h
#align formal_multilinear_series.le_radius_of_bound FormalMultilinearSeries.le_radius_of_bound
theorem le_radius_of_bound_nnreal (C : ββ₯0) {r : ββ₯0} (h : β n : β, βp nββ * r ^ n β€ C) :
(r : ββ₯0β) β€ p.radius :=
p.le_radius_of_bound C fun n => mod_cast h n
#align formal_multilinear_series.le_radius_of_bound_nnreal FormalMultilinearSeries.le_radius_of_bound_nnreal
theorem le_radius_of_isBigO (h : (fun n => βp nβ * (r : β) ^ n) =O[atTop] fun _ => (1 : β)) :
βr β€ p.radius :=
Exists.elim (isBigO_one_nat_atTop_iff.1 h) fun C hC =>
p.le_radius_of_bound C fun n => (le_abs_self _).trans (hC n)
set_option linter.uppercaseLean3 false in
#align formal_multilinear_series.le_radius_of_is_O FormalMultilinearSeries.le_radius_of_isBigO
theorem le_radius_of_eventually_le (C) (h : βαΆ n in atTop, βp nβ * (r : β) ^ n β€ C) :
βr β€ p.radius :=
p.le_radius_of_isBigO <| IsBigO.of_bound C <| h.mono fun n hn => by simpa
#align formal_multilinear_series.le_radius_of_eventually_le FormalMultilinearSeries.le_radius_of_eventually_le
theorem le_radius_of_summable_nnnorm (h : Summable fun n => βp nββ * r ^ n) : βr β€ p.radius :=
p.le_radius_of_bound_nnreal (β' n, βp nββ * r ^ n) fun _ => le_tsum' h _
#align formal_multilinear_series.le_radius_of_summable_nnnorm FormalMultilinearSeries.le_radius_of_summable_nnnorm
theorem le_radius_of_summable (h : Summable fun n => βp nβ * (r : β) ^ n) : βr β€ p.radius :=
p.le_radius_of_summable_nnnorm <| by
simp only [β coe_nnnorm] at h
exact mod_cast h
#align formal_multilinear_series.le_radius_of_summable FormalMultilinearSeries.le_radius_of_summable
theorem radius_eq_top_of_forall_nnreal_isBigO
(h : β r : ββ₯0, (fun n => βp nβ * (r : β) ^ n) =O[atTop] fun _ => (1 : β)) : p.radius = β :=
ENNReal.eq_top_of_forall_nnreal_le fun r => p.le_radius_of_isBigO (h r)
set_option linter.uppercaseLean3 false in
#align formal_multilinear_series.radius_eq_top_of_forall_nnreal_is_O FormalMultilinearSeries.radius_eq_top_of_forall_nnreal_isBigO
theorem radius_eq_top_of_eventually_eq_zero (h : βαΆ n in atTop, p n = 0) : p.radius = β :=
p.radius_eq_top_of_forall_nnreal_isBigO fun r =>
(isBigO_zero _ _).congr' (h.mono fun n hn => by simp [hn]) EventuallyEq.rfl
#align formal_multilinear_series.radius_eq_top_of_eventually_eq_zero FormalMultilinearSeries.radius_eq_top_of_eventually_eq_zero
theorem radius_eq_top_of_forall_image_add_eq_zero (n : β) (hn : β m, p (m + n) = 0) :
p.radius = β :=
p.radius_eq_top_of_eventually_eq_zero <|
mem_atTop_sets.2 β¨n, fun _ hk => tsub_add_cancel_of_le hk βΈ hn _β©
#align formal_multilinear_series.radius_eq_top_of_forall_image_add_eq_zero FormalMultilinearSeries.radius_eq_top_of_forall_image_add_eq_zero
@[simp]
theorem constFormalMultilinearSeries_radius {v : F} :
(constFormalMultilinearSeries π E v).radius = β€ :=
(constFormalMultilinearSeries π E v).radius_eq_top_of_forall_image_add_eq_zero 1
(by simp [constFormalMultilinearSeries])
#align formal_multilinear_series.const_formal_multilinear_series_radius FormalMultilinearSeries.constFormalMultilinearSeries_radius
| Mathlib/Analysis/Analytic/Basic.lean | 187 | 202 | theorem isLittleO_of_lt_radius (h : βr < p.radius) :
β a β Ioo (0 : β) 1, (fun n => βp nβ * (r : β) ^ n) =o[atTop] (a ^ Β·) := by |
have := (TFAE_exists_lt_isLittleO_pow (fun n => βp nβ * (r : β) ^ n) 1).out 1 4
rw [this]
-- Porting note: was
-- rw [(TFAE_exists_lt_isLittleO_pow (fun n => βp nβ * (r : β) ^ n) 1).out 1 4]
simp only [radius, lt_iSup_iff] at h
rcases h with β¨t, C, hC, rtβ©
rw [ENNReal.coe_lt_coe, β NNReal.coe_lt_coe] at rt
have : 0 < (t : β) := r.coe_nonneg.trans_lt rt
rw [β div_lt_one this] at rt
refine β¨_, rt, C, Or.inr zero_lt_one, fun n => ?_β©
calc
|βp nβ * (r : β) ^ n| = βp nβ * (t : β) ^ n * (r / t : β) ^ n := by
field_simp [mul_right_comm, abs_mul]
_ β€ C * (r / t : β) ^ n := by gcongr; apply hC
| 1,762 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.analytic.radius_liminf from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
open scoped Topology Classical NNReal ENNReal
open Filter Asymptotics
namespace FormalMultilinearSeries
variable (p : FormalMultilinearSeries π E F)
| Mathlib/Analysis/Analytic/RadiusLiminf.lean | 35 | 61 | theorem radius_eq_liminf :
p.radius = liminf (fun n => (1 / (βp nββ ^ (1 / (n : β)) : ββ₯0) : ββ₯0β)) atTop := by |
-- Porting note: added type ascription to make elaborated statement match Lean 3 version
have :
β (r : ββ₯0) {n : β},
0 < n β ((r : ββ₯0β) β€ 1 / β(βp nββ ^ (1 / (n : β))) β βp nββ * r ^ n β€ 1) := by
intro r n hn
have : 0 < (n : β) := Nat.cast_pos.2 hn
conv_lhs =>
rw [one_div, ENNReal.le_inv_iff_mul_le, β ENNReal.coe_mul, ENNReal.coe_le_one_iff, one_div, β
NNReal.rpow_one r, β mul_inv_cancel this.ne', NNReal.rpow_mul, β NNReal.mul_rpow, β
NNReal.one_rpow nβ»ΒΉ, NNReal.rpow_le_rpow_iff (inv_pos.2 this), mul_comm,
NNReal.rpow_natCast]
apply le_antisymm <;> refine ENNReal.le_of_forall_nnreal_lt fun r hr => ?_
Β· have := ((TFAE_exists_lt_isLittleO_pow (fun n => βp nβ * r ^ n) 1).out 1 7).1
(p.isLittleO_of_lt_radius hr)
obtain β¨a, ha, Hβ© := this
apply le_liminf_of_le
Β· infer_param
Β· rw [β eventually_map]
refine
H.mp ((eventually_gt_atTop 0).mono fun n hnβ hn => (this _ hnβ).2 (NNReal.coe_le_coe.1 ?_))
push_cast
exact (le_abs_self _).trans (hn.trans (pow_le_one _ ha.1.le ha.2.le))
Β· refine p.le_radius_of_isBigO (IsBigO.of_bound 1 ?_)
refine (eventually_lt_of_lt_liminf hr).mp ((eventually_gt_atTop 0).mono fun n hnβ hn => ?_)
simpa using NNReal.coe_le_coe.2 ((this _ hnβ).1 hn.le)
| 1,763 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topology Classical NNReal ENNReal
section Topological
variable [CommRing π] [AddCommGroup E] [AddCommGroup F] [AddCommGroup G]
variable [Module π E] [Module π F] [Module π G]
variable [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace G]
namespace FormalMultilinearSeries
variable [TopologicalAddGroup E] [ContinuousConstSMul π E]
variable [TopologicalAddGroup F] [ContinuousConstSMul π F]
variable [TopologicalAddGroup G] [ContinuousConstSMul π G]
def applyComposition (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n) :
(Fin n β E) β Fin c.length β F := fun v i => p (c.blocksFun i) (v β c.embedding i)
#align formal_multilinear_series.apply_composition FormalMultilinearSeries.applyComposition
| Mathlib/Analysis/Analytic/Composition.lean | 106 | 114 | theorem applyComposition_ones (p : FormalMultilinearSeries π E F) (n : β) :
p.applyComposition (Composition.ones n) = fun v i =>
p 1 fun _ => v (Fin.castLE (Composition.length_le _) i) := by |
funext v i
apply p.congr (Composition.ones_blocksFun _ _)
intro j hjn hj1
obtain rfl : j = 0 := by omega
refine congr_arg v ?_
rw [Fin.ext_iff, Fin.coe_castLE, Composition.ones_embedding, Fin.val_mk]
| 1,764 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topology Classical NNReal ENNReal
section Topological
variable [CommRing π] [AddCommGroup E] [AddCommGroup F] [AddCommGroup G]
variable [Module π E] [Module π F] [Module π G]
variable [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace G]
namespace FormalMultilinearSeries
variable [TopologicalAddGroup E] [ContinuousConstSMul π E]
variable [TopologicalAddGroup F] [ContinuousConstSMul π F]
variable [TopologicalAddGroup G] [ContinuousConstSMul π G]
def applyComposition (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n) :
(Fin n β E) β Fin c.length β F := fun v i => p (c.blocksFun i) (v β c.embedding i)
#align formal_multilinear_series.apply_composition FormalMultilinearSeries.applyComposition
theorem applyComposition_ones (p : FormalMultilinearSeries π E F) (n : β) :
p.applyComposition (Composition.ones n) = fun v i =>
p 1 fun _ => v (Fin.castLE (Composition.length_le _) i) := by
funext v i
apply p.congr (Composition.ones_blocksFun _ _)
intro j hjn hj1
obtain rfl : j = 0 := by omega
refine congr_arg v ?_
rw [Fin.ext_iff, Fin.coe_castLE, Composition.ones_embedding, Fin.val_mk]
#align formal_multilinear_series.apply_composition_ones FormalMultilinearSeries.applyComposition_ones
| Mathlib/Analysis/Analytic/Composition.lean | 117 | 127 | theorem applyComposition_single (p : FormalMultilinearSeries π E F) {n : β} (hn : 0 < n)
(v : Fin n β E) : p.applyComposition (Composition.single n hn) v = fun _j => p n v := by |
ext j
refine p.congr (by simp) fun i hi1 hi2 => ?_
dsimp
congr 1
convert Composition.single_embedding hn β¨i, hi2β© using 1
cases' j with j_val j_property
have : j_val = 0 := le_bot_iff.1 (Nat.lt_succ_iff.1 j_property)
congr!
simp
| 1,764 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topology Classical NNReal ENNReal
section Topological
variable [CommRing π] [AddCommGroup E] [AddCommGroup F] [AddCommGroup G]
variable [Module π E] [Module π F] [Module π G]
variable [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace G]
namespace FormalMultilinearSeries
variable [TopologicalAddGroup E] [ContinuousConstSMul π E]
variable [TopologicalAddGroup F] [ContinuousConstSMul π F]
variable [TopologicalAddGroup G] [ContinuousConstSMul π G]
def applyComposition (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n) :
(Fin n β E) β Fin c.length β F := fun v i => p (c.blocksFun i) (v β c.embedding i)
#align formal_multilinear_series.apply_composition FormalMultilinearSeries.applyComposition
theorem applyComposition_ones (p : FormalMultilinearSeries π E F) (n : β) :
p.applyComposition (Composition.ones n) = fun v i =>
p 1 fun _ => v (Fin.castLE (Composition.length_le _) i) := by
funext v i
apply p.congr (Composition.ones_blocksFun _ _)
intro j hjn hj1
obtain rfl : j = 0 := by omega
refine congr_arg v ?_
rw [Fin.ext_iff, Fin.coe_castLE, Composition.ones_embedding, Fin.val_mk]
#align formal_multilinear_series.apply_composition_ones FormalMultilinearSeries.applyComposition_ones
theorem applyComposition_single (p : FormalMultilinearSeries π E F) {n : β} (hn : 0 < n)
(v : Fin n β E) : p.applyComposition (Composition.single n hn) v = fun _j => p n v := by
ext j
refine p.congr (by simp) fun i hi1 hi2 => ?_
dsimp
congr 1
convert Composition.single_embedding hn β¨i, hi2β© using 1
cases' j with j_val j_property
have : j_val = 0 := le_bot_iff.1 (Nat.lt_succ_iff.1 j_property)
congr!
simp
#align formal_multilinear_series.apply_composition_single FormalMultilinearSeries.applyComposition_single
@[simp]
| Mathlib/Analysis/Analytic/Composition.lean | 131 | 134 | theorem removeZero_applyComposition (p : FormalMultilinearSeries π E F) {n : β}
(c : Composition n) : p.removeZero.applyComposition c = p.applyComposition c := by |
ext v i
simp [applyComposition, zero_lt_one.trans_le (c.one_le_blocksFun i), removeZero_of_pos]
| 1,764 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topology Classical NNReal ENNReal
section Topological
variable [CommRing π] [AddCommGroup E] [AddCommGroup F] [AddCommGroup G]
variable [Module π E] [Module π F] [Module π G]
variable [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace G]
namespace FormalMultilinearSeries
variable [TopologicalAddGroup E] [ContinuousConstSMul π E]
variable [TopologicalAddGroup F] [ContinuousConstSMul π F]
variable [TopologicalAddGroup G] [ContinuousConstSMul π G]
def applyComposition (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n) :
(Fin n β E) β Fin c.length β F := fun v i => p (c.blocksFun i) (v β c.embedding i)
#align formal_multilinear_series.apply_composition FormalMultilinearSeries.applyComposition
theorem applyComposition_ones (p : FormalMultilinearSeries π E F) (n : β) :
p.applyComposition (Composition.ones n) = fun v i =>
p 1 fun _ => v (Fin.castLE (Composition.length_le _) i) := by
funext v i
apply p.congr (Composition.ones_blocksFun _ _)
intro j hjn hj1
obtain rfl : j = 0 := by omega
refine congr_arg v ?_
rw [Fin.ext_iff, Fin.coe_castLE, Composition.ones_embedding, Fin.val_mk]
#align formal_multilinear_series.apply_composition_ones FormalMultilinearSeries.applyComposition_ones
theorem applyComposition_single (p : FormalMultilinearSeries π E F) {n : β} (hn : 0 < n)
(v : Fin n β E) : p.applyComposition (Composition.single n hn) v = fun _j => p n v := by
ext j
refine p.congr (by simp) fun i hi1 hi2 => ?_
dsimp
congr 1
convert Composition.single_embedding hn β¨i, hi2β© using 1
cases' j with j_val j_property
have : j_val = 0 := le_bot_iff.1 (Nat.lt_succ_iff.1 j_property)
congr!
simp
#align formal_multilinear_series.apply_composition_single FormalMultilinearSeries.applyComposition_single
@[simp]
theorem removeZero_applyComposition (p : FormalMultilinearSeries π E F) {n : β}
(c : Composition n) : p.removeZero.applyComposition c = p.applyComposition c := by
ext v i
simp [applyComposition, zero_lt_one.trans_le (c.one_le_blocksFun i), removeZero_of_pos]
#align formal_multilinear_series.remove_zero_apply_composition FormalMultilinearSeries.removeZero_applyComposition
| Mathlib/Analysis/Analytic/Composition.lean | 140 | 162 | theorem applyComposition_update (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n)
(j : Fin n) (v : Fin n β E) (z : E) :
p.applyComposition c (Function.update v j z) =
Function.update (p.applyComposition c v) (c.index j)
(p (c.blocksFun (c.index j))
(Function.update (v β c.embedding (c.index j)) (c.invEmbedding j) z)) := by |
ext k
by_cases h : k = c.index j
Β· rw [h]
let r : Fin (c.blocksFun (c.index j)) β Fin n := c.embedding (c.index j)
simp only [Function.update_same]
change p (c.blocksFun (c.index j)) (Function.update v j z β r) = _
let j' := c.invEmbedding j
suffices B : Function.update v j z β r = Function.update (v β r) j' z by rw [B]
suffices C : Function.update v (r j') z β r = Function.update (v β r) j' z by
convert C; exact (c.embedding_comp_inv j).symm
exact Function.update_comp_eq_of_injective _ (c.embedding _).injective _ _
Β· simp only [h, Function.update_eq_self, Function.update_noteq, Ne, not_false_iff]
let r : Fin (c.blocksFun k) β Fin n := c.embedding k
change p (c.blocksFun k) (Function.update v j z β r) = p (c.blocksFun k) (v β r)
suffices B : Function.update v j z β r = v β r by rw [B]
apply Function.update_comp_eq_of_not_mem_range
rwa [c.mem_range_embedding_iff']
| 1,764 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topology Classical NNReal ENNReal
section Topological
variable [CommRing π] [AddCommGroup E] [AddCommGroup F] [AddCommGroup G]
variable [Module π E] [Module π F] [Module π G]
variable [TopologicalSpace E] [TopologicalSpace F] [TopologicalSpace G]
namespace FormalMultilinearSeries
variable [TopologicalAddGroup E] [ContinuousConstSMul π E]
variable [TopologicalAddGroup F] [ContinuousConstSMul π F]
variable [TopologicalAddGroup G] [ContinuousConstSMul π G]
def applyComposition (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n) :
(Fin n β E) β Fin c.length β F := fun v i => p (c.blocksFun i) (v β c.embedding i)
#align formal_multilinear_series.apply_composition FormalMultilinearSeries.applyComposition
theorem applyComposition_ones (p : FormalMultilinearSeries π E F) (n : β) :
p.applyComposition (Composition.ones n) = fun v i =>
p 1 fun _ => v (Fin.castLE (Composition.length_le _) i) := by
funext v i
apply p.congr (Composition.ones_blocksFun _ _)
intro j hjn hj1
obtain rfl : j = 0 := by omega
refine congr_arg v ?_
rw [Fin.ext_iff, Fin.coe_castLE, Composition.ones_embedding, Fin.val_mk]
#align formal_multilinear_series.apply_composition_ones FormalMultilinearSeries.applyComposition_ones
theorem applyComposition_single (p : FormalMultilinearSeries π E F) {n : β} (hn : 0 < n)
(v : Fin n β E) : p.applyComposition (Composition.single n hn) v = fun _j => p n v := by
ext j
refine p.congr (by simp) fun i hi1 hi2 => ?_
dsimp
congr 1
convert Composition.single_embedding hn β¨i, hi2β© using 1
cases' j with j_val j_property
have : j_val = 0 := le_bot_iff.1 (Nat.lt_succ_iff.1 j_property)
congr!
simp
#align formal_multilinear_series.apply_composition_single FormalMultilinearSeries.applyComposition_single
@[simp]
theorem removeZero_applyComposition (p : FormalMultilinearSeries π E F) {n : β}
(c : Composition n) : p.removeZero.applyComposition c = p.applyComposition c := by
ext v i
simp [applyComposition, zero_lt_one.trans_le (c.one_le_blocksFun i), removeZero_of_pos]
#align formal_multilinear_series.remove_zero_apply_composition FormalMultilinearSeries.removeZero_applyComposition
theorem applyComposition_update (p : FormalMultilinearSeries π E F) {n : β} (c : Composition n)
(j : Fin n) (v : Fin n β E) (z : E) :
p.applyComposition c (Function.update v j z) =
Function.update (p.applyComposition c v) (c.index j)
(p (c.blocksFun (c.index j))
(Function.update (v β c.embedding (c.index j)) (c.invEmbedding j) z)) := by
ext k
by_cases h : k = c.index j
Β· rw [h]
let r : Fin (c.blocksFun (c.index j)) β Fin n := c.embedding (c.index j)
simp only [Function.update_same]
change p (c.blocksFun (c.index j)) (Function.update v j z β r) = _
let j' := c.invEmbedding j
suffices B : Function.update v j z β r = Function.update (v β r) j' z by rw [B]
suffices C : Function.update v (r j') z β r = Function.update (v β r) j' z by
convert C; exact (c.embedding_comp_inv j).symm
exact Function.update_comp_eq_of_injective _ (c.embedding _).injective _ _
Β· simp only [h, Function.update_eq_self, Function.update_noteq, Ne, not_false_iff]
let r : Fin (c.blocksFun k) β Fin n := c.embedding k
change p (c.blocksFun k) (Function.update v j z β r) = p (c.blocksFun k) (v β r)
suffices B : Function.update v j z β r = v β r by rw [B]
apply Function.update_comp_eq_of_not_mem_range
rwa [c.mem_range_embedding_iff']
#align formal_multilinear_series.apply_composition_update FormalMultilinearSeries.applyComposition_update
@[simp]
| Mathlib/Analysis/Analytic/Composition.lean | 166 | 169 | theorem compContinuousLinearMap_applyComposition {n : β} (p : FormalMultilinearSeries π F G)
(f : E βL[π] F) (c : Composition n) (v : Fin n β E) :
(p.compContinuousLinearMap f).applyComposition c v = p.applyComposition c (f β v) := by |
simp (config := {unfoldPartialApp := true}) [applyComposition]; rfl
| 1,764 |
import Mathlib.Analysis.Analytic.Linear
import Mathlib.Analysis.Analytic.Composition
import Mathlib.Analysis.NormedSpace.Completion
#align_import analysis.analytic.uniqueness from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
open Set
open scoped Topology ENNReal
namespace AnalyticOn
| Mathlib/Analysis/Analytic/Uniqueness.lean | 32 | 70 | theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux [CompleteSpace F] {f : E β F} {U : Set E}
(hf : AnalyticOn π f U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfzβ : f =αΆ [π zβ] 0) :
EqOn f 0 U := by |
/- Let `u` be the set of points around which `f` vanishes. It is clearly open. We have to show
that its limit points in `U` still belong to it, from which the inclusion `U β u` will follow
by connectedness. -/
let u := {x | f =αΆ [π x] 0}
suffices main : closure u β© U β u by
have Uu : U β u :=
hU.subset_of_closure_inter_subset isOpen_setOf_eventually_nhds β¨zβ, hβ, hfzββ© main
intro z hz
simpa using mem_of_mem_nhds (Uu hz)
/- Take a limit point `x`, then a ball `B (x, r)` on which it has a power series expansion, and
then `y β B (x, r/2) β© u`. Then `f` has a power series expansion on `B (y, r/2)` as it is
contained in `B (x, r)`. All the coefficients in this series expansion vanish, as `f` is zero
on a neighborhood of `y`. Therefore, `f` is zero on `B (y, r/2)`. As this ball contains `x`,
it follows that `f` vanishes on a neighborhood of `x`, proving the claim. -/
rintro x β¨xu, xUβ©
rcases hf x xU with β¨p, r, hpβ©
obtain β¨y, yu, hxyβ© : β y β u, edist x y < r / 2 :=
EMetric.mem_closure_iff.1 xu (r / 2) (ENNReal.half_pos hp.r_pos.ne')
let q := p.changeOrigin (y - x)
have has_series : HasFPowerSeriesOnBall f q y (r / 2) := by
have A : (βy - xββ : ββ₯0β) < r / 2 := by rwa [edist_comm, edist_eq_coe_nnnorm_sub] at hxy
have := hp.changeOrigin (A.trans_le ENNReal.half_le_self)
simp only [add_sub_cancel] at this
apply this.mono (ENNReal.half_pos hp.r_pos.ne')
apply ENNReal.le_sub_of_add_le_left ENNReal.coe_ne_top
apply (add_le_add A.le (le_refl (r / 2))).trans (le_of_eq _)
exact ENNReal.add_halves _
have M : EMetric.ball y (r / 2) β π x := EMetric.isOpen_ball.mem_nhds hxy
filter_upwards [M] with z hz
have A : HasSum (fun n : β => q n fun _ : Fin n => z - y) (f z) := has_series.hasSum_sub hz
have B : HasSum (fun n : β => q n fun _ : Fin n => z - y) 0 := by
have : HasFPowerSeriesAt 0 q y := has_series.hasFPowerSeriesAt.congr yu
convert hasSum_zero (Ξ± := F) using 2
ext n
exact this.apply_eq_zero n _
exact HasSum.unique A B
| 1,765 |
import Mathlib.Analysis.Analytic.Linear
import Mathlib.Analysis.Analytic.Composition
import Mathlib.Analysis.NormedSpace.Completion
#align_import analysis.analytic.uniqueness from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
open Set
open scoped Topology ENNReal
namespace AnalyticOn
theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux [CompleteSpace F] {f : E β F} {U : Set E}
(hf : AnalyticOn π f U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfzβ : f =αΆ [π zβ] 0) :
EqOn f 0 U := by
let u := {x | f =αΆ [π x] 0}
suffices main : closure u β© U β u by
have Uu : U β u :=
hU.subset_of_closure_inter_subset isOpen_setOf_eventually_nhds β¨zβ, hβ, hfzββ© main
intro z hz
simpa using mem_of_mem_nhds (Uu hz)
rintro x β¨xu, xUβ©
rcases hf x xU with β¨p, r, hpβ©
obtain β¨y, yu, hxyβ© : β y β u, edist x y < r / 2 :=
EMetric.mem_closure_iff.1 xu (r / 2) (ENNReal.half_pos hp.r_pos.ne')
let q := p.changeOrigin (y - x)
have has_series : HasFPowerSeriesOnBall f q y (r / 2) := by
have A : (βy - xββ : ββ₯0β) < r / 2 := by rwa [edist_comm, edist_eq_coe_nnnorm_sub] at hxy
have := hp.changeOrigin (A.trans_le ENNReal.half_le_self)
simp only [add_sub_cancel] at this
apply this.mono (ENNReal.half_pos hp.r_pos.ne')
apply ENNReal.le_sub_of_add_le_left ENNReal.coe_ne_top
apply (add_le_add A.le (le_refl (r / 2))).trans (le_of_eq _)
exact ENNReal.add_halves _
have M : EMetric.ball y (r / 2) β π x := EMetric.isOpen_ball.mem_nhds hxy
filter_upwards [M] with z hz
have A : HasSum (fun n : β => q n fun _ : Fin n => z - y) (f z) := has_series.hasSum_sub hz
have B : HasSum (fun n : β => q n fun _ : Fin n => z - y) 0 := by
have : HasFPowerSeriesAt 0 q y := has_series.hasFPowerSeriesAt.congr yu
convert hasSum_zero (Ξ± := F) using 2
ext n
exact this.apply_eq_zero n _
exact HasSum.unique A B
#align analytic_on.eq_on_zero_of_preconnected_of_eventually_eq_zero_aux AnalyticOn.eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux
| Mathlib/Analysis/Analytic/Uniqueness.lean | 77 | 89 | theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero {f : E β F} {U : Set E}
(hf : AnalyticOn π f U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfzβ : f =αΆ [π zβ] 0) :
EqOn f 0 U := by |
let F' := UniformSpace.Completion F
set e : F βL[π] F' := UniformSpace.Completion.toComplL
have : AnalyticOn π (e β f) U := fun x hx => (e.analyticAt _).comp (hf x hx)
have A : EqOn (e β f) 0 U := by
apply eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux this hU hβ
filter_upwards [hfzβ] with x hx
simp only [hx, Function.comp_apply, Pi.zero_apply, map_zero]
intro z hz
have : e (f z) = e 0 := by simpa only using A hz
exact UniformSpace.Completion.coe_injective F this
| 1,765 |
import Mathlib.Analysis.Analytic.Linear
import Mathlib.Analysis.Analytic.Composition
import Mathlib.Analysis.NormedSpace.Completion
#align_import analysis.analytic.uniqueness from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
open Set
open scoped Topology ENNReal
namespace AnalyticOn
theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux [CompleteSpace F] {f : E β F} {U : Set E}
(hf : AnalyticOn π f U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfzβ : f =αΆ [π zβ] 0) :
EqOn f 0 U := by
let u := {x | f =αΆ [π x] 0}
suffices main : closure u β© U β u by
have Uu : U β u :=
hU.subset_of_closure_inter_subset isOpen_setOf_eventually_nhds β¨zβ, hβ, hfzββ© main
intro z hz
simpa using mem_of_mem_nhds (Uu hz)
rintro x β¨xu, xUβ©
rcases hf x xU with β¨p, r, hpβ©
obtain β¨y, yu, hxyβ© : β y β u, edist x y < r / 2 :=
EMetric.mem_closure_iff.1 xu (r / 2) (ENNReal.half_pos hp.r_pos.ne')
let q := p.changeOrigin (y - x)
have has_series : HasFPowerSeriesOnBall f q y (r / 2) := by
have A : (βy - xββ : ββ₯0β) < r / 2 := by rwa [edist_comm, edist_eq_coe_nnnorm_sub] at hxy
have := hp.changeOrigin (A.trans_le ENNReal.half_le_self)
simp only [add_sub_cancel] at this
apply this.mono (ENNReal.half_pos hp.r_pos.ne')
apply ENNReal.le_sub_of_add_le_left ENNReal.coe_ne_top
apply (add_le_add A.le (le_refl (r / 2))).trans (le_of_eq _)
exact ENNReal.add_halves _
have M : EMetric.ball y (r / 2) β π x := EMetric.isOpen_ball.mem_nhds hxy
filter_upwards [M] with z hz
have A : HasSum (fun n : β => q n fun _ : Fin n => z - y) (f z) := has_series.hasSum_sub hz
have B : HasSum (fun n : β => q n fun _ : Fin n => z - y) 0 := by
have : HasFPowerSeriesAt 0 q y := has_series.hasFPowerSeriesAt.congr yu
convert hasSum_zero (Ξ± := F) using 2
ext n
exact this.apply_eq_zero n _
exact HasSum.unique A B
#align analytic_on.eq_on_zero_of_preconnected_of_eventually_eq_zero_aux AnalyticOn.eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux
theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero {f : E β F} {U : Set E}
(hf : AnalyticOn π f U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfzβ : f =αΆ [π zβ] 0) :
EqOn f 0 U := by
let F' := UniformSpace.Completion F
set e : F βL[π] F' := UniformSpace.Completion.toComplL
have : AnalyticOn π (e β f) U := fun x hx => (e.analyticAt _).comp (hf x hx)
have A : EqOn (e β f) 0 U := by
apply eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux this hU hβ
filter_upwards [hfzβ] with x hx
simp only [hx, Function.comp_apply, Pi.zero_apply, map_zero]
intro z hz
have : e (f z) = e 0 := by simpa only using A hz
exact UniformSpace.Completion.coe_injective F this
#align analytic_on.eq_on_zero_of_preconnected_of_eventually_eq_zero AnalyticOn.eqOn_zero_of_preconnected_of_eventuallyEq_zero
| Mathlib/Analysis/Analytic/Uniqueness.lean | 96 | 101 | theorem eqOn_of_preconnected_of_eventuallyEq {f g : E β F} {U : Set E} (hf : AnalyticOn π f U)
(hg : AnalyticOn π g U) (hU : IsPreconnected U) {zβ : E} (hβ : zβ β U) (hfg : f =αΆ [π zβ] g) :
EqOn f g U := by |
have hfg' : f - g =αΆ [π zβ] 0 := hfg.mono fun z h => by simp [h]
simpa [sub_eq_zero] using fun z hz =>
(hf.sub hg).eqOn_zero_of_preconnected_of_eventuallyEq_zero hU hβ hfg' hz
| 1,765 |
import Mathlib.Analysis.Analytic.Composition
#align_import analysis.analytic.inverse from "leanprover-community/mathlib"@"284fdd2962e67d2932fa3a79ce19fcf92d38e228"
open scoped Classical Topology
open Finset Filter
namespace FormalMultilinearSeries
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
noncomputable def leftInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
-β c : { c : Composition (n + 2) // c.length < n + 2 },
(leftInv p i (c : Composition (n + 2)).length).compAlongComposition
(p.compContinuousLinearMap i.symm) c
#align formal_multilinear_series.left_inv FormalMultilinearSeries.leftInv
@[simp]
| Mathlib/Analysis/Analytic/Inverse.lean | 68 | 69 | theorem leftInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 0 = 0 := by | rw [leftInv]
| 1,766 |
import Mathlib.Analysis.Analytic.Composition
#align_import analysis.analytic.inverse from "leanprover-community/mathlib"@"284fdd2962e67d2932fa3a79ce19fcf92d38e228"
open scoped Classical Topology
open Finset Filter
namespace FormalMultilinearSeries
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
noncomputable def leftInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
-β c : { c : Composition (n + 2) // c.length < n + 2 },
(leftInv p i (c : Composition (n + 2)).length).compAlongComposition
(p.compContinuousLinearMap i.symm) c
#align formal_multilinear_series.left_inv FormalMultilinearSeries.leftInv
@[simp]
theorem leftInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 0 = 0 := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_zero FormalMultilinearSeries.leftInv_coeff_zero
@[simp]
| Mathlib/Analysis/Analytic/Inverse.lean | 73 | 74 | theorem leftInv_coeff_one (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 1 = (continuousMultilinearCurryFin1 π F E).symm i.symm := by | rw [leftInv]
| 1,766 |
import Mathlib.Analysis.Analytic.Composition
#align_import analysis.analytic.inverse from "leanprover-community/mathlib"@"284fdd2962e67d2932fa3a79ce19fcf92d38e228"
open scoped Classical Topology
open Finset Filter
namespace FormalMultilinearSeries
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
noncomputable def leftInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
-β c : { c : Composition (n + 2) // c.length < n + 2 },
(leftInv p i (c : Composition (n + 2)).length).compAlongComposition
(p.compContinuousLinearMap i.symm) c
#align formal_multilinear_series.left_inv FormalMultilinearSeries.leftInv
@[simp]
theorem leftInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 0 = 0 := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_zero FormalMultilinearSeries.leftInv_coeff_zero
@[simp]
theorem leftInv_coeff_one (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 1 = (continuousMultilinearCurryFin1 π F E).symm i.symm := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_one FormalMultilinearSeries.leftInv_coeff_one
| Mathlib/Analysis/Analytic/Inverse.lean | 79 | 92 | theorem leftInv_removeZero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.removeZero.leftInv i = p.leftInv i := by |
ext1 n
induction' n using Nat.strongRec' with n IH
match n with
| 0 => simp -- if one replaces `simp` with `refl`, the proof times out in the kernel.
| 1 => simp -- TODO: why?
| n + 2 =>
simp only [leftInv, neg_inj]
refine Finset.sum_congr rfl fun c cuniv => ?_
rcases c with β¨c, hcβ©
ext v
dsimp
simp [IH _ hc]
| 1,766 |
import Mathlib.Analysis.Analytic.Composition
#align_import analysis.analytic.inverse from "leanprover-community/mathlib"@"284fdd2962e67d2932fa3a79ce19fcf92d38e228"
open scoped Classical Topology
open Finset Filter
namespace FormalMultilinearSeries
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
noncomputable def leftInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
-β c : { c : Composition (n + 2) // c.length < n + 2 },
(leftInv p i (c : Composition (n + 2)).length).compAlongComposition
(p.compContinuousLinearMap i.symm) c
#align formal_multilinear_series.left_inv FormalMultilinearSeries.leftInv
@[simp]
theorem leftInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 0 = 0 := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_zero FormalMultilinearSeries.leftInv_coeff_zero
@[simp]
theorem leftInv_coeff_one (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 1 = (continuousMultilinearCurryFin1 π F E).symm i.symm := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_one FormalMultilinearSeries.leftInv_coeff_one
theorem leftInv_removeZero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.removeZero.leftInv i = p.leftInv i := by
ext1 n
induction' n using Nat.strongRec' with n IH
match n with
| 0 => simp -- if one replaces `simp` with `refl`, the proof times out in the kernel.
| 1 => simp -- TODO: why?
| n + 2 =>
simp only [leftInv, neg_inj]
refine Finset.sum_congr rfl fun c cuniv => ?_
rcases c with β¨c, hcβ©
ext v
dsimp
simp [IH _ hc]
#align formal_multilinear_series.left_inv_remove_zero FormalMultilinearSeries.leftInv_removeZero
| Mathlib/Analysis/Analytic/Inverse.lean | 97 | 148 | theorem leftInv_comp (p : FormalMultilinearSeries π E F) (i : E βL[π] F)
(h : p 1 = (continuousMultilinearCurryFin1 π E F).symm i) : (leftInv p i).comp p = id π E := by |
ext (n v)
match n with
| 0 =>
simp only [leftInv_coeff_zero, ContinuousMultilinearMap.zero_apply, id_apply_ne_one, Ne,
not_false_iff, zero_ne_one, comp_coeff_zero']
| 1 =>
simp only [leftInv_coeff_one, comp_coeff_one, h, id_apply_one, ContinuousLinearEquiv.coe_apply,
ContinuousLinearEquiv.symm_apply_apply, continuousMultilinearCurryFin1_symm_apply]
| n + 2 =>
have A :
(Finset.univ : Finset (Composition (n + 2))) =
{c | Composition.length c < n + 2}.toFinset βͺ {Composition.ones (n + 2)} := by
refine Subset.antisymm (fun c _ => ?_) (subset_univ _)
by_cases h : c.length < n + 2
Β· simp [h, Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
Β· simp [Composition.eq_ones_iff_le_length.2 (not_lt.1 h)]
have B :
Disjoint ({c | Composition.length c < n + 2} : Set (Composition (n + 2))).toFinset
{Composition.ones (n + 2)} := by
simp [Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
have C :
((p.leftInv i (Composition.ones (n + 2)).length)
fun j : Fin (Composition.ones n.succ.succ).length =>
p 1 fun _ => v ((Fin.castLE (Composition.length_le _)) j)) =
p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j := by
apply FormalMultilinearSeries.congr _ (Composition.ones_length _) fun j hj1 hj2 => ?_
exact FormalMultilinearSeries.congr _ rfl fun k _ _ => by congr
have D :
(p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j) =
-β c β {c : Composition (n + 2) | c.length < n + 2}.toFinset,
(p.leftInv i c.length) (p.applyComposition c v) := by
simp only [leftInv, ContinuousMultilinearMap.neg_apply, neg_inj,
ContinuousMultilinearMap.sum_apply]
convert
(sum_toFinset_eq_subtype
(fun c : Composition (n + 2) => c.length < n + 2)
(fun c : Composition (n + 2) =>
(ContinuousMultilinearMap.compAlongComposition
(p.compContinuousLinearMap (i.symm : F βL[π] E)) c (p.leftInv i c.length))
fun j : Fin (n + 2) => p 1 fun _ : Fin 1 => v j)).symm.trans
_
simp only [compContinuousLinearMap_applyComposition,
ContinuousMultilinearMap.compAlongComposition_apply]
congr
ext c
congr
ext k
simp [h, Function.comp]
simp [FormalMultilinearSeries.comp, show n + 2 β 1 by omega, A, Finset.sum_union B,
applyComposition_ones, C, D, -Set.toFinset_setOf]
| 1,766 |
import Mathlib.Analysis.Analytic.Composition
#align_import analysis.analytic.inverse from "leanprover-community/mathlib"@"284fdd2962e67d2932fa3a79ce19fcf92d38e228"
open scoped Classical Topology
open Finset Filter
namespace FormalMultilinearSeries
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {F : Type*} [NormedAddCommGroup F] [NormedSpace π F]
noncomputable def leftInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
-β c : { c : Composition (n + 2) // c.length < n + 2 },
(leftInv p i (c : Composition (n + 2)).length).compAlongComposition
(p.compContinuousLinearMap i.symm) c
#align formal_multilinear_series.left_inv FormalMultilinearSeries.leftInv
@[simp]
theorem leftInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 0 = 0 := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_zero FormalMultilinearSeries.leftInv_coeff_zero
@[simp]
theorem leftInv_coeff_one (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.leftInv i 1 = (continuousMultilinearCurryFin1 π F E).symm i.symm := by rw [leftInv]
#align formal_multilinear_series.left_inv_coeff_one FormalMultilinearSeries.leftInv_coeff_one
theorem leftInv_removeZero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.removeZero.leftInv i = p.leftInv i := by
ext1 n
induction' n using Nat.strongRec' with n IH
match n with
| 0 => simp -- if one replaces `simp` with `refl`, the proof times out in the kernel.
| 1 => simp -- TODO: why?
| n + 2 =>
simp only [leftInv, neg_inj]
refine Finset.sum_congr rfl fun c cuniv => ?_
rcases c with β¨c, hcβ©
ext v
dsimp
simp [IH _ hc]
#align formal_multilinear_series.left_inv_remove_zero FormalMultilinearSeries.leftInv_removeZero
theorem leftInv_comp (p : FormalMultilinearSeries π E F) (i : E βL[π] F)
(h : p 1 = (continuousMultilinearCurryFin1 π E F).symm i) : (leftInv p i).comp p = id π E := by
ext (n v)
match n with
| 0 =>
simp only [leftInv_coeff_zero, ContinuousMultilinearMap.zero_apply, id_apply_ne_one, Ne,
not_false_iff, zero_ne_one, comp_coeff_zero']
| 1 =>
simp only [leftInv_coeff_one, comp_coeff_one, h, id_apply_one, ContinuousLinearEquiv.coe_apply,
ContinuousLinearEquiv.symm_apply_apply, continuousMultilinearCurryFin1_symm_apply]
| n + 2 =>
have A :
(Finset.univ : Finset (Composition (n + 2))) =
{c | Composition.length c < n + 2}.toFinset βͺ {Composition.ones (n + 2)} := by
refine Subset.antisymm (fun c _ => ?_) (subset_univ _)
by_cases h : c.length < n + 2
Β· simp [h, Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
Β· simp [Composition.eq_ones_iff_le_length.2 (not_lt.1 h)]
have B :
Disjoint ({c | Composition.length c < n + 2} : Set (Composition (n + 2))).toFinset
{Composition.ones (n + 2)} := by
simp [Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
have C :
((p.leftInv i (Composition.ones (n + 2)).length)
fun j : Fin (Composition.ones n.succ.succ).length =>
p 1 fun _ => v ((Fin.castLE (Composition.length_le _)) j)) =
p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j := by
apply FormalMultilinearSeries.congr _ (Composition.ones_length _) fun j hj1 hj2 => ?_
exact FormalMultilinearSeries.congr _ rfl fun k _ _ => by congr
have D :
(p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j) =
-β c β {c : Composition (n + 2) | c.length < n + 2}.toFinset,
(p.leftInv i c.length) (p.applyComposition c v) := by
simp only [leftInv, ContinuousMultilinearMap.neg_apply, neg_inj,
ContinuousMultilinearMap.sum_apply]
convert
(sum_toFinset_eq_subtype
(fun c : Composition (n + 2) => c.length < n + 2)
(fun c : Composition (n + 2) =>
(ContinuousMultilinearMap.compAlongComposition
(p.compContinuousLinearMap (i.symm : F βL[π] E)) c (p.leftInv i c.length))
fun j : Fin (n + 2) => p 1 fun _ : Fin 1 => v j)).symm.trans
_
simp only [compContinuousLinearMap_applyComposition,
ContinuousMultilinearMap.compAlongComposition_apply]
congr
ext c
congr
ext k
simp [h, Function.comp]
simp [FormalMultilinearSeries.comp, show n + 2 β 1 by omega, A, Finset.sum_union B,
applyComposition_ones, C, D, -Set.toFinset_setOf]
#align formal_multilinear_series.left_inv_comp FormalMultilinearSeries.leftInv_comp
noncomputable def rightInv (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
FormalMultilinearSeries π F E
| 0 => 0
| 1 => (continuousMultilinearCurryFin1 π F E).symm i.symm
| n + 2 =>
let q : FormalMultilinearSeries π F E := fun k => if k < n + 2 then rightInv p i k else 0;
-(i.symm : F βL[π] E).compContinuousMultilinearMap ((p.comp q) (n + 2))
#align formal_multilinear_series.right_inv FormalMultilinearSeries.rightInv
@[simp]
| Mathlib/Analysis/Analytic/Inverse.lean | 177 | 178 | theorem rightInv_coeff_zero (p : FormalMultilinearSeries π E F) (i : E βL[π] F) :
p.rightInv i 0 = 0 := by | rw [rightInv]
| 1,766 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
section fderiv
variable {p : FormalMultilinearSeries π E F} {r : ββ₯0β}
variable {f : E β F} {x : E} {s : Set E}
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 39 | 44 | theorem HasFPowerSeriesAt.hasStrictFDerivAt (h : HasFPowerSeriesAt f p x) :
HasStrictFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x := by |
refine h.isBigO_image_sub_norm_mul_norm_sub.trans_isLittleO (IsLittleO.of_norm_right ?_)
refine isLittleO_iff_exists_eq_mul.2 β¨fun y => βy - (x, x)β, ?_, EventuallyEq.rflβ©
refine (continuous_id.sub continuous_const).norm.tendsto' _ _ ?_
rw [_root_.id, sub_self, norm_zero]
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
section fderiv
variable {p : FormalMultilinearSeries π E F} {r : ββ₯0β}
variable {f : E β F} {x : E} {s : Set E}
theorem HasFPowerSeriesAt.hasStrictFDerivAt (h : HasFPowerSeriesAt f p x) :
HasStrictFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x := by
refine h.isBigO_image_sub_norm_mul_norm_sub.trans_isLittleO (IsLittleO.of_norm_right ?_)
refine isLittleO_iff_exists_eq_mul.2 β¨fun y => βy - (x, x)β, ?_, EventuallyEq.rflβ©
refine (continuous_id.sub continuous_const).norm.tendsto' _ _ ?_
rw [_root_.id, sub_self, norm_zero]
#align has_fpower_series_at.has_strict_fderiv_at HasFPowerSeriesAt.hasStrictFDerivAt
theorem HasFPowerSeriesAt.hasFDerivAt (h : HasFPowerSeriesAt f p x) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x :=
h.hasStrictFDerivAt.hasFDerivAt
#align has_fpower_series_at.has_fderiv_at HasFPowerSeriesAt.hasFDerivAt
theorem HasFPowerSeriesAt.differentiableAt (h : HasFPowerSeriesAt f p x) : DifferentiableAt π f x :=
h.hasFDerivAt.differentiableAt
#align has_fpower_series_at.differentiable_at HasFPowerSeriesAt.differentiableAt
theorem AnalyticAt.differentiableAt : AnalyticAt π f x β DifferentiableAt π f x
| β¨_, hpβ© => hp.differentiableAt
#align analytic_at.differentiable_at AnalyticAt.differentiableAt
theorem AnalyticAt.differentiableWithinAt (h : AnalyticAt π f x) : DifferentiableWithinAt π f s x :=
h.differentiableAt.differentiableWithinAt
#align analytic_at.differentiable_within_at AnalyticAt.differentiableWithinAt
theorem HasFPowerSeriesAt.fderiv_eq (h : HasFPowerSeriesAt f p x) :
fderiv π f x = continuousMultilinearCurryFin1 π E F (p 1) :=
h.hasFDerivAt.fderiv
#align has_fpower_series_at.fderiv_eq HasFPowerSeriesAt.fderiv_eq
theorem HasFPowerSeriesOnBall.differentiableOn [CompleteSpace F]
(h : HasFPowerSeriesOnBall f p x r) : DifferentiableOn π f (EMetric.ball x r) := fun _ hy =>
(h.analyticAt_of_mem hy).differentiableWithinAt
#align has_fpower_series_on_ball.differentiable_on HasFPowerSeriesOnBall.differentiableOn
theorem AnalyticOn.differentiableOn (h : AnalyticOn π f s) : DifferentiableOn π f s := fun y hy =>
(h y hy).differentiableWithinAt
#align analytic_on.differentiable_on AnalyticOn.differentiableOn
theorem HasFPowerSeriesOnBall.hasFDerivAt [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1)) (x + y) :=
(h.changeOrigin hy).hasFPowerSeriesAt.hasFDerivAt
#align has_fpower_series_on_ball.has_fderiv_at HasFPowerSeriesOnBall.hasFDerivAt
theorem HasFPowerSeriesOnBall.fderiv_eq [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
fderiv π f (x + y) = continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1) :=
(h.hasFDerivAt hy).fderiv
#align has_fpower_series_on_ball.fderiv_eq HasFPowerSeriesOnBall.fderiv_eq
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 91 | 101 | theorem HasFPowerSeriesOnBall.fderiv [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r) :
HasFPowerSeriesOnBall (fderiv π f) p.derivSeries x r := by |
refine .congr (f := fun z β¦ continuousMultilinearCurryFin1 π E F (p.changeOrigin (z - x) 1)) ?_
fun z hz β¦ ?_
Β· refine continuousMultilinearCurryFin1 π E F
|>.toContinuousLinearEquiv.toContinuousLinearMap.comp_hasFPowerSeriesOnBall ?_
simpa using ((p.hasFPowerSeriesOnBall_changeOrigin 1
(h.r_pos.trans_le h.r_le)).mono h.r_pos h.r_le).comp_sub x
dsimp only
rw [β h.fderiv_eq, add_sub_cancel]
simpa only [edist_eq_coe_nnnorm_sub, EMetric.mem_ball] using hz
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
section fderiv
variable {p : FormalMultilinearSeries π E F} {r : ββ₯0β}
variable {f : E β F} {x : E} {s : Set E}
theorem HasFPowerSeriesAt.hasStrictFDerivAt (h : HasFPowerSeriesAt f p x) :
HasStrictFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x := by
refine h.isBigO_image_sub_norm_mul_norm_sub.trans_isLittleO (IsLittleO.of_norm_right ?_)
refine isLittleO_iff_exists_eq_mul.2 β¨fun y => βy - (x, x)β, ?_, EventuallyEq.rflβ©
refine (continuous_id.sub continuous_const).norm.tendsto' _ _ ?_
rw [_root_.id, sub_self, norm_zero]
#align has_fpower_series_at.has_strict_fderiv_at HasFPowerSeriesAt.hasStrictFDerivAt
theorem HasFPowerSeriesAt.hasFDerivAt (h : HasFPowerSeriesAt f p x) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x :=
h.hasStrictFDerivAt.hasFDerivAt
#align has_fpower_series_at.has_fderiv_at HasFPowerSeriesAt.hasFDerivAt
theorem HasFPowerSeriesAt.differentiableAt (h : HasFPowerSeriesAt f p x) : DifferentiableAt π f x :=
h.hasFDerivAt.differentiableAt
#align has_fpower_series_at.differentiable_at HasFPowerSeriesAt.differentiableAt
theorem AnalyticAt.differentiableAt : AnalyticAt π f x β DifferentiableAt π f x
| β¨_, hpβ© => hp.differentiableAt
#align analytic_at.differentiable_at AnalyticAt.differentiableAt
theorem AnalyticAt.differentiableWithinAt (h : AnalyticAt π f x) : DifferentiableWithinAt π f s x :=
h.differentiableAt.differentiableWithinAt
#align analytic_at.differentiable_within_at AnalyticAt.differentiableWithinAt
theorem HasFPowerSeriesAt.fderiv_eq (h : HasFPowerSeriesAt f p x) :
fderiv π f x = continuousMultilinearCurryFin1 π E F (p 1) :=
h.hasFDerivAt.fderiv
#align has_fpower_series_at.fderiv_eq HasFPowerSeriesAt.fderiv_eq
theorem HasFPowerSeriesOnBall.differentiableOn [CompleteSpace F]
(h : HasFPowerSeriesOnBall f p x r) : DifferentiableOn π f (EMetric.ball x r) := fun _ hy =>
(h.analyticAt_of_mem hy).differentiableWithinAt
#align has_fpower_series_on_ball.differentiable_on HasFPowerSeriesOnBall.differentiableOn
theorem AnalyticOn.differentiableOn (h : AnalyticOn π f s) : DifferentiableOn π f s := fun y hy =>
(h y hy).differentiableWithinAt
#align analytic_on.differentiable_on AnalyticOn.differentiableOn
theorem HasFPowerSeriesOnBall.hasFDerivAt [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1)) (x + y) :=
(h.changeOrigin hy).hasFPowerSeriesAt.hasFDerivAt
#align has_fpower_series_on_ball.has_fderiv_at HasFPowerSeriesOnBall.hasFDerivAt
theorem HasFPowerSeriesOnBall.fderiv_eq [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
fderiv π f (x + y) = continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1) :=
(h.hasFDerivAt hy).fderiv
#align has_fpower_series_on_ball.fderiv_eq HasFPowerSeriesOnBall.fderiv_eq
theorem HasFPowerSeriesOnBall.fderiv [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r) :
HasFPowerSeriesOnBall (fderiv π f) p.derivSeries x r := by
refine .congr (f := fun z β¦ continuousMultilinearCurryFin1 π E F (p.changeOrigin (z - x) 1)) ?_
fun z hz β¦ ?_
Β· refine continuousMultilinearCurryFin1 π E F
|>.toContinuousLinearEquiv.toContinuousLinearMap.comp_hasFPowerSeriesOnBall ?_
simpa using ((p.hasFPowerSeriesOnBall_changeOrigin 1
(h.r_pos.trans_le h.r_le)).mono h.r_pos h.r_le).comp_sub x
dsimp only
rw [β h.fderiv_eq, add_sub_cancel]
simpa only [edist_eq_coe_nnnorm_sub, EMetric.mem_ball] using hz
#align has_fpower_series_on_ball.fderiv HasFPowerSeriesOnBall.fderiv
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 105 | 109 | theorem AnalyticOn.fderiv [CompleteSpace F] (h : AnalyticOn π f s) :
AnalyticOn π (fderiv π f) s := by |
intro y hy
rcases h y hy with β¨p, r, hpβ©
exact hp.fderiv.analyticAt
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
section fderiv
variable {p : FormalMultilinearSeries π E F} {r : ββ₯0β}
variable {f : E β F} {x : E} {s : Set E}
theorem HasFPowerSeriesAt.hasStrictFDerivAt (h : HasFPowerSeriesAt f p x) :
HasStrictFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x := by
refine h.isBigO_image_sub_norm_mul_norm_sub.trans_isLittleO (IsLittleO.of_norm_right ?_)
refine isLittleO_iff_exists_eq_mul.2 β¨fun y => βy - (x, x)β, ?_, EventuallyEq.rflβ©
refine (continuous_id.sub continuous_const).norm.tendsto' _ _ ?_
rw [_root_.id, sub_self, norm_zero]
#align has_fpower_series_at.has_strict_fderiv_at HasFPowerSeriesAt.hasStrictFDerivAt
theorem HasFPowerSeriesAt.hasFDerivAt (h : HasFPowerSeriesAt f p x) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p 1)) x :=
h.hasStrictFDerivAt.hasFDerivAt
#align has_fpower_series_at.has_fderiv_at HasFPowerSeriesAt.hasFDerivAt
theorem HasFPowerSeriesAt.differentiableAt (h : HasFPowerSeriesAt f p x) : DifferentiableAt π f x :=
h.hasFDerivAt.differentiableAt
#align has_fpower_series_at.differentiable_at HasFPowerSeriesAt.differentiableAt
theorem AnalyticAt.differentiableAt : AnalyticAt π f x β DifferentiableAt π f x
| β¨_, hpβ© => hp.differentiableAt
#align analytic_at.differentiable_at AnalyticAt.differentiableAt
theorem AnalyticAt.differentiableWithinAt (h : AnalyticAt π f x) : DifferentiableWithinAt π f s x :=
h.differentiableAt.differentiableWithinAt
#align analytic_at.differentiable_within_at AnalyticAt.differentiableWithinAt
theorem HasFPowerSeriesAt.fderiv_eq (h : HasFPowerSeriesAt f p x) :
fderiv π f x = continuousMultilinearCurryFin1 π E F (p 1) :=
h.hasFDerivAt.fderiv
#align has_fpower_series_at.fderiv_eq HasFPowerSeriesAt.fderiv_eq
theorem HasFPowerSeriesOnBall.differentiableOn [CompleteSpace F]
(h : HasFPowerSeriesOnBall f p x r) : DifferentiableOn π f (EMetric.ball x r) := fun _ hy =>
(h.analyticAt_of_mem hy).differentiableWithinAt
#align has_fpower_series_on_ball.differentiable_on HasFPowerSeriesOnBall.differentiableOn
theorem AnalyticOn.differentiableOn (h : AnalyticOn π f s) : DifferentiableOn π f s := fun y hy =>
(h y hy).differentiableWithinAt
#align analytic_on.differentiable_on AnalyticOn.differentiableOn
theorem HasFPowerSeriesOnBall.hasFDerivAt [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
HasFDerivAt f (continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1)) (x + y) :=
(h.changeOrigin hy).hasFPowerSeriesAt.hasFDerivAt
#align has_fpower_series_on_ball.has_fderiv_at HasFPowerSeriesOnBall.hasFDerivAt
theorem HasFPowerSeriesOnBall.fderiv_eq [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r)
{y : E} (hy : (βyββ : ββ₯0β) < r) :
fderiv π f (x + y) = continuousMultilinearCurryFin1 π E F (p.changeOrigin y 1) :=
(h.hasFDerivAt hy).fderiv
#align has_fpower_series_on_ball.fderiv_eq HasFPowerSeriesOnBall.fderiv_eq
theorem HasFPowerSeriesOnBall.fderiv [CompleteSpace F] (h : HasFPowerSeriesOnBall f p x r) :
HasFPowerSeriesOnBall (fderiv π f) p.derivSeries x r := by
refine .congr (f := fun z β¦ continuousMultilinearCurryFin1 π E F (p.changeOrigin (z - x) 1)) ?_
fun z hz β¦ ?_
Β· refine continuousMultilinearCurryFin1 π E F
|>.toContinuousLinearEquiv.toContinuousLinearMap.comp_hasFPowerSeriesOnBall ?_
simpa using ((p.hasFPowerSeriesOnBall_changeOrigin 1
(h.r_pos.trans_le h.r_le)).mono h.r_pos h.r_le).comp_sub x
dsimp only
rw [β h.fderiv_eq, add_sub_cancel]
simpa only [edist_eq_coe_nnnorm_sub, EMetric.mem_ball] using hz
#align has_fpower_series_on_ball.fderiv HasFPowerSeriesOnBall.fderiv
theorem AnalyticOn.fderiv [CompleteSpace F] (h : AnalyticOn π f s) :
AnalyticOn π (fderiv π f) s := by
intro y hy
rcases h y hy with β¨p, r, hpβ©
exact hp.fderiv.analyticAt
#align analytic_on.fderiv AnalyticOn.fderiv
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 113 | 122 | theorem AnalyticOn.iteratedFDeriv [CompleteSpace F] (h : AnalyticOn π f s) (n : β) :
AnalyticOn π (iteratedFDeriv π n f) s := by |
induction' n with n IH
Β· rw [iteratedFDeriv_zero_eq_comp]
exact ((continuousMultilinearCurryFin0 π E F).symm : F βL[π] E[Γ0]βL[π] F).comp_analyticOn h
Β· rw [iteratedFDeriv_succ_eq_comp_left]
-- Porting note: for reasons that I do not understand at all, `?g` cannot be inlined.
convert ContinuousLinearMap.comp_analyticOn ?g IH.fderiv
case g => exact β(continuousMultilinearCurryLeftEquiv π (fun _ : Fin (n + 1) β¦ E) F)
simp
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
namespace ContinuousMultilinearMap
variable {ΞΉ : Type*} {E : ΞΉ β Type*} [β i, NormedAddCommGroup (E i)] [β i, NormedSpace π (E i)]
[Fintype ΞΉ] (f : ContinuousMultilinearMap π E F)
open FormalMultilinearSeries
protected theorem hasFiniteFPowerSeriesOnBall :
HasFiniteFPowerSeriesOnBall f f.toFormalMultilinearSeries 0 (Fintype.card ΞΉ + 1) β€ :=
.mk' (fun m hm β¦ dif_neg (Nat.succ_le_iff.mp hm).ne) ENNReal.zero_lt_top fun y _ β¦ by
rw [Finset.sum_eq_single_of_mem _ (Finset.self_mem_range_succ _), zero_add]
Β· rw [toFormalMultilinearSeries, dif_pos rfl]; rfl
Β· intro m _ ne; rw [toFormalMultilinearSeries, dif_neg ne.symm]; rfl
theorem changeOriginSeries_support {k l : β} (h : k + l β Fintype.card ΞΉ) :
f.toFormalMultilinearSeries.changeOriginSeries k l = 0 :=
Finset.sum_eq_zero fun _ _ β¦ by
simp_rw [FormalMultilinearSeries.changeOriginSeriesTerm,
toFormalMultilinearSeries, dif_neg h.symm, LinearIsometryEquiv.map_zero]
variable {n : ββ} (x : β i, E i)
open Finset in
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 314 | 346 | theorem changeOrigin_toFormalMultilinearSeries [DecidableEq ΞΉ] :
continuousMultilinearCurryFin1 π (β i, E i) F (f.toFormalMultilinearSeries.changeOrigin x 1) =
f.linearDeriv x := by |
ext y
rw [continuousMultilinearCurryFin1_apply, linearDeriv_apply,
changeOrigin, FormalMultilinearSeries.sum]
cases isEmpty_or_nonempty ΞΉ
Β· have (l) : 1 + l β Fintype.card ΞΉ := by
rw [add_comm, Fintype.card_eq_zero]; exact Nat.succ_ne_zero _
simp_rw [Fintype.sum_empty, changeOriginSeries_support _ (this _), zero_apply _, tsum_zero]; rfl
rw [tsum_eq_single (Fintype.card ΞΉ - 1), changeOriginSeries]; swap
Β· intro m hm
rw [Ne, eq_tsub_iff_add_eq_of_le (by exact Fintype.card_pos), add_comm] at hm
rw [f.changeOriginSeries_support hm, zero_apply]
rw [sum_apply, ContinuousMultilinearMap.sum_apply, Fin.snoc_zero]
simp_rw [changeOriginSeriesTerm_apply]
refine (Fintype.sum_bijective (?_ β Fintype.equivFinOfCardEq (Nat.add_sub_of_le
Fintype.card_pos).symm) (.comp ?_ <| Equiv.bijective _) _ _ fun i β¦ ?_).symm
Β· exact (β¨{Β·}αΆ, by
rw [card_compl, Fintype.card_fin, card_singleton, Nat.add_sub_cancel_left]β©)
Β· use fun _ _ β¦ (singleton_injective <| compl_injective <| Subtype.ext_iff.mp Β·)
intro β¨s, hsβ©
have h : sαΆ.card = 1 := by rw [card_compl, hs, Fintype.card_fin, Nat.add_sub_cancel]
obtain β¨a, haβ© := card_eq_one.mp h
exact β¨a, Subtype.ext (compl_eq_comm.mp ha)β©
rw [Function.comp_apply, Subtype.coe_mk, compl_singleton, piecewise_erase_univ,
toFormalMultilinearSeries, dif_pos (Nat.add_sub_of_le Fintype.card_pos).symm]
simp_rw [domDomCongr_apply, compContinuousLinearMap_apply, ContinuousLinearMap.proj_apply,
Function.update_apply, (Equiv.injective _).eq_iff, ite_apply]
congr; ext j
obtain rfl | hj := eq_or_ne j i
Β· rw [Function.update_same, if_pos rfl]
Β· rw [Function.update_noteq hj, if_neg hj]
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
namespace FormalMultilinearSeries
variable (p : FormalMultilinearSeries π E F)
open Fintype ContinuousLinearMap in
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 449 | 458 | theorem derivSeries_apply_diag (n : β) (x : E) :
derivSeries p n (fun _ β¦ x) x = (n + 1) β’ p (n + 1) fun _ β¦ x := by |
simp only [derivSeries, compFormalMultilinearSeries_apply, changeOriginSeries,
compContinuousMultilinearMap_coe, ContinuousLinearEquiv.coe_coe, LinearIsometryEquiv.coe_coe,
Function.comp_apply, ContinuousMultilinearMap.sum_apply, map_sum, coe_sum', Finset.sum_apply,
continuousMultilinearCurryFin1_apply, Matrix.zero_empty]
convert Finset.sum_const _
Β· rw [Fin.snoc_zero, changeOriginSeriesTerm_apply, Finset.piecewise_same, add_comm]
Β· rw [β card, card_subtype, β Finset.powerset_univ, β Finset.powersetCard_eq_filter,
Finset.card_powersetCard, β card, card_fin, eq_comm, add_comm, Nat.choose_succ_self_right]
| 1,767 |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
open Filter Asymptotics
open scoped ENNReal
universe u v
variable {π : Type*} [NontriviallyNormedField π]
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace π E]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace π F]
namespace HasFPowerSeriesOnBall
open FormalMultilinearSeries ENNReal Nat
variable {p : FormalMultilinearSeries π E F} {f : E β F} {x : E} {r : ββ₯0β}
(h : HasFPowerSeriesOnBall f p x r) (y : E)
| Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 469 | 474 | theorem iteratedFDeriv_zero_apply_diag : iteratedFDeriv π 0 f x = p 0 := by |
ext
convert (h.hasSum <| EMetric.mem_ball_self h.r_pos).tsum_eq.symm
Β· rw [iteratedFDeriv_zero_apply, add_zero]
Β· rw [tsum_eq_single 0 fun n hn β¦ by haveI := NeZero.mk hn; exact (p n).map_zero]
exact congr(p 0 $(Subsingleton.elim _ _))
| 1,767 |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open scoped Classical
open Filter Function Nat FormalMultilinearSeries EMetric Set
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {s : E} {p q : FormalMultilinearSeries π π E} {f g : π β E} {n : β} {z zβ : π}
namespace HasSum
variable {a : β β E}
| Mathlib/Analysis/Analytic/IsolatedZeros.lean | 44 | 45 | theorem hasSum_at_zero (a : β β E) : HasSum (fun n => (0 : π) ^ n β’ a n) (a 0) := by |
convert hasSum_single (Ξ± := E) 0 fun b h β¦ _ <;> simp [*]
| 1,768 |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open scoped Classical
open Filter Function Nat FormalMultilinearSeries EMetric Set
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {s : E} {p q : FormalMultilinearSeries π π E} {f g : π β E} {n : β} {z zβ : π}
namespace HasSum
variable {a : β β E}
theorem hasSum_at_zero (a : β β E) : HasSum (fun n => (0 : π) ^ n β’ a n) (a 0) := by
convert hasSum_single (Ξ± := E) 0 fun b h β¦ _ <;> simp [*]
#align has_sum.has_sum_at_zero HasSum.hasSum_at_zero
| Mathlib/Analysis/Analytic/IsolatedZeros.lean | 48 | 62 | theorem exists_hasSum_smul_of_apply_eq_zero (hs : HasSum (fun m => z ^ m β’ a m) s)
(ha : β k < n, a k = 0) : β t : E, z ^ n β’ t = s β§ HasSum (fun m => z ^ m β’ a (m + n)) t := by |
obtain rfl | hn := n.eq_zero_or_pos
Β· simpa
by_cases h : z = 0
Β· have : s = 0 := hs.unique (by simpa [ha 0 hn, h] using hasSum_at_zero a)
exact β¨a n, by simp [h, hn.ne', this], by simpa [h] using hasSum_at_zero fun m => a (m + n)β©
Β· refine β¨(z ^ n)β»ΒΉ β’ s, by field_simp [smul_smul], ?_β©
have h1 : β i β Finset.range n, z ^ i β’ a i = 0 :=
Finset.sum_eq_zero fun k hk => by simp [ha k (Finset.mem_range.mp hk)]
have h2 : HasSum (fun m => z ^ (m + n) β’ a (m + n)) s := by
simpa [h1] using (hasSum_nat_add_iff' n).mpr hs
convert h2.const_smul (zβ»ΒΉ ^ n) using 1
Β· field_simp [pow_add, smul_smul]
Β· simp only [inv_pow]
| 1,768 |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open scoped Classical
open Filter Function Nat FormalMultilinearSeries EMetric Set
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {s : E} {p q : FormalMultilinearSeries π π E} {f g : π β E} {n : β} {z zβ : π}
namespace HasFPowerSeriesAt
| Mathlib/Analysis/Analytic/IsolatedZeros.lean | 69 | 80 | theorem has_fpower_series_dslope_fslope (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt (dslope f zβ) p.fslope zβ := by |
have hpd : deriv f zβ = p.coeff 1 := hp.deriv
have hp0 : p.coeff 0 = f zβ := hp.coeff_zero 1
simp only [hasFPowerSeriesAt_iff, apply_eq_pow_smul_coeff, coeff_fslope] at hp β’
refine hp.mono fun x hx => ?_
by_cases h : x = 0
Β· convert hasSum_single (Ξ± := E) 0 _ <;> intros <;> simp [*]
Β· have hxx : β n : β, xβ»ΒΉ * x ^ (n + 1) = x ^ n := fun n => by field_simp [h, _root_.pow_succ]
suffices HasSum (fun n => xβ»ΒΉ β’ x ^ (n + 1) β’ p.coeff (n + 1)) (xβ»ΒΉ β’ (f (zβ + x) - f zβ)) by
simpa [dslope, slope, h, smul_smul, hxx] using this
simpa [hp0] using ((hasSum_nat_add_iff' 1).mpr hx).const_smul xβ»ΒΉ
| 1,768 |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open scoped Classical
open Filter Function Nat FormalMultilinearSeries EMetric Set
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {s : E} {p q : FormalMultilinearSeries π π E} {f g : π β E} {n : β} {z zβ : π}
namespace HasFPowerSeriesAt
theorem has_fpower_series_dslope_fslope (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt (dslope f zβ) p.fslope zβ := by
have hpd : deriv f zβ = p.coeff 1 := hp.deriv
have hp0 : p.coeff 0 = f zβ := hp.coeff_zero 1
simp only [hasFPowerSeriesAt_iff, apply_eq_pow_smul_coeff, coeff_fslope] at hp β’
refine hp.mono fun x hx => ?_
by_cases h : x = 0
Β· convert hasSum_single (Ξ± := E) 0 _ <;> intros <;> simp [*]
Β· have hxx : β n : β, xβ»ΒΉ * x ^ (n + 1) = x ^ n := fun n => by field_simp [h, _root_.pow_succ]
suffices HasSum (fun n => xβ»ΒΉ β’ x ^ (n + 1) β’ p.coeff (n + 1)) (xβ»ΒΉ β’ (f (zβ + x) - f zβ)) by
simpa [dslope, slope, h, smul_smul, hxx] using this
simpa [hp0] using ((hasSum_nat_add_iff' 1).mpr hx).const_smul xβ»ΒΉ
#align has_fpower_series_at.has_fpower_series_dslope_fslope HasFPowerSeriesAt.has_fpower_series_dslope_fslope
| Mathlib/Analysis/Analytic/IsolatedZeros.lean | 83 | 87 | theorem has_fpower_series_iterate_dslope_fslope (n : β) (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt ((swap dslope zβ)^[n] f) (fslope^[n] p) zβ := by |
induction' n with n ih generalizing f p
Β· exact hp
Β· simpa using ih (has_fpower_series_dslope_fslope hp)
| 1,768 |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open scoped Classical
open Filter Function Nat FormalMultilinearSeries EMetric Set
open scoped Topology
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {s : E} {p q : FormalMultilinearSeries π π E} {f g : π β E} {n : β} {z zβ : π}
namespace HasFPowerSeriesAt
theorem has_fpower_series_dslope_fslope (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt (dslope f zβ) p.fslope zβ := by
have hpd : deriv f zβ = p.coeff 1 := hp.deriv
have hp0 : p.coeff 0 = f zβ := hp.coeff_zero 1
simp only [hasFPowerSeriesAt_iff, apply_eq_pow_smul_coeff, coeff_fslope] at hp β’
refine hp.mono fun x hx => ?_
by_cases h : x = 0
Β· convert hasSum_single (Ξ± := E) 0 _ <;> intros <;> simp [*]
Β· have hxx : β n : β, xβ»ΒΉ * x ^ (n + 1) = x ^ n := fun n => by field_simp [h, _root_.pow_succ]
suffices HasSum (fun n => xβ»ΒΉ β’ x ^ (n + 1) β’ p.coeff (n + 1)) (xβ»ΒΉ β’ (f (zβ + x) - f zβ)) by
simpa [dslope, slope, h, smul_smul, hxx] using this
simpa [hp0] using ((hasSum_nat_add_iff' 1).mpr hx).const_smul xβ»ΒΉ
#align has_fpower_series_at.has_fpower_series_dslope_fslope HasFPowerSeriesAt.has_fpower_series_dslope_fslope
theorem has_fpower_series_iterate_dslope_fslope (n : β) (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt ((swap dslope zβ)^[n] f) (fslope^[n] p) zβ := by
induction' n with n ih generalizing f p
Β· exact hp
Β· simpa using ih (has_fpower_series_dslope_fslope hp)
#align has_fpower_series_at.has_fpower_series_iterate_dslope_fslope HasFPowerSeriesAt.has_fpower_series_iterate_dslope_fslope
| Mathlib/Analysis/Analytic/IsolatedZeros.lean | 90 | 93 | theorem iterate_dslope_fslope_ne_zero (hp : HasFPowerSeriesAt f p zβ) (h : p β 0) :
(swap dslope zβ)^[p.order] f zβ β 0 := by |
rw [β coeff_zero (has_fpower_series_iterate_dslope_fslope p.order hp) 1]
simpa [coeff_eq_zero] using apply_order_ne_zero h
| 1,768 |
import Mathlib.Analysis.BoxIntegral.Box.Basic
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.box_integral.box.subbox_induction from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Finset Function Filter Metric Classical Topology Filter ENNReal
noncomputable section
namespace BoxIntegral
namespace Box
variable {ΞΉ : Type*} {I J : Box ΞΉ}
def splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) : Box ΞΉ where
lower := s.piecewise (fun i β¦ (I.lower i + I.upper i) / 2) I.lower
upper := s.piecewise I.upper fun i β¦ (I.lower i + I.upper i) / 2
lower_lt_upper i := by
dsimp only [Set.piecewise]
split_ifs <;> simp only [left_lt_add_div_two, add_div_two_lt_right, I.lower_lt_upper]
#align box_integral.box.split_center_box BoxIntegral.Box.splitCenterBox
| Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean | 53 | 62 | theorem mem_splitCenterBox {s : Set ΞΉ} {y : ΞΉ β β} :
y β I.splitCenterBox s β y β I β§ β i, (I.lower i + I.upper i) / 2 < y i β i β s := by |
simp only [splitCenterBox, mem_def, β forall_and]
refine forall_congr' fun i β¦ ?_
dsimp only [Set.piecewise]
split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
exacts [β¨fun H β¦ β¨β¨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2β©, H.1β©,
fun H β¦ β¨H.2, H.1.2β©β©,
β¨fun H β¦ β¨β¨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).leβ©, H.2β©,
fun H β¦ β¨H.1.1, H.2β©β©]
| 1,769 |
import Mathlib.Analysis.BoxIntegral.Box.Basic
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.box_integral.box.subbox_induction from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Finset Function Filter Metric Classical Topology Filter ENNReal
noncomputable section
namespace BoxIntegral
namespace Box
variable {ΞΉ : Type*} {I J : Box ΞΉ}
def splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) : Box ΞΉ where
lower := s.piecewise (fun i β¦ (I.lower i + I.upper i) / 2) I.lower
upper := s.piecewise I.upper fun i β¦ (I.lower i + I.upper i) / 2
lower_lt_upper i := by
dsimp only [Set.piecewise]
split_ifs <;> simp only [left_lt_add_div_two, add_div_two_lt_right, I.lower_lt_upper]
#align box_integral.box.split_center_box BoxIntegral.Box.splitCenterBox
theorem mem_splitCenterBox {s : Set ΞΉ} {y : ΞΉ β β} :
y β I.splitCenterBox s β y β I β§ β i, (I.lower i + I.upper i) / 2 < y i β i β s := by
simp only [splitCenterBox, mem_def, β forall_and]
refine forall_congr' fun i β¦ ?_
dsimp only [Set.piecewise]
split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
exacts [β¨fun H β¦ β¨β¨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2β©, H.1β©,
fun H β¦ β¨H.2, H.1.2β©β©,
β¨fun H β¦ β¨β¨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).leβ©, H.2β©,
fun H β¦ β¨H.1.1, H.2β©β©]
#align box_integral.box.mem_split_center_box BoxIntegral.Box.mem_splitCenterBox
theorem splitCenterBox_le (I : Box ΞΉ) (s : Set ΞΉ) : I.splitCenterBox s β€ I :=
fun _ hx β¦ (mem_splitCenterBox.1 hx).1
#align box_integral.box.split_center_box_le BoxIntegral.Box.splitCenterBox_le
| Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean | 69 | 75 | theorem disjoint_splitCenterBox (I : Box ΞΉ) {s t : Set ΞΉ} (h : s β t) :
Disjoint (I.splitCenterBox s : Set (ΞΉ β β)) (I.splitCenterBox t) := by |
rw [disjoint_iff_inf_le]
rintro y β¨hs, htβ©; apply h
ext i
rw [mem_coe, mem_splitCenterBox] at hs ht
rw [β hs.2, β ht.2]
| 1,769 |
import Mathlib.Analysis.BoxIntegral.Box.Basic
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.box_integral.box.subbox_induction from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Finset Function Filter Metric Classical Topology Filter ENNReal
noncomputable section
namespace BoxIntegral
namespace Box
variable {ΞΉ : Type*} {I J : Box ΞΉ}
def splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) : Box ΞΉ where
lower := s.piecewise (fun i β¦ (I.lower i + I.upper i) / 2) I.lower
upper := s.piecewise I.upper fun i β¦ (I.lower i + I.upper i) / 2
lower_lt_upper i := by
dsimp only [Set.piecewise]
split_ifs <;> simp only [left_lt_add_div_two, add_div_two_lt_right, I.lower_lt_upper]
#align box_integral.box.split_center_box BoxIntegral.Box.splitCenterBox
theorem mem_splitCenterBox {s : Set ΞΉ} {y : ΞΉ β β} :
y β I.splitCenterBox s β y β I β§ β i, (I.lower i + I.upper i) / 2 < y i β i β s := by
simp only [splitCenterBox, mem_def, β forall_and]
refine forall_congr' fun i β¦ ?_
dsimp only [Set.piecewise]
split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
exacts [β¨fun H β¦ β¨β¨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2β©, H.1β©,
fun H β¦ β¨H.2, H.1.2β©β©,
β¨fun H β¦ β¨β¨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).leβ©, H.2β©,
fun H β¦ β¨H.1.1, H.2β©β©]
#align box_integral.box.mem_split_center_box BoxIntegral.Box.mem_splitCenterBox
theorem splitCenterBox_le (I : Box ΞΉ) (s : Set ΞΉ) : I.splitCenterBox s β€ I :=
fun _ hx β¦ (mem_splitCenterBox.1 hx).1
#align box_integral.box.split_center_box_le BoxIntegral.Box.splitCenterBox_le
theorem disjoint_splitCenterBox (I : Box ΞΉ) {s t : Set ΞΉ} (h : s β t) :
Disjoint (I.splitCenterBox s : Set (ΞΉ β β)) (I.splitCenterBox t) := by
rw [disjoint_iff_inf_le]
rintro y β¨hs, htβ©; apply h
ext i
rw [mem_coe, mem_splitCenterBox] at hs ht
rw [β hs.2, β ht.2]
#align box_integral.box.disjoint_split_center_box BoxIntegral.Box.disjoint_splitCenterBox
theorem injective_splitCenterBox (I : Box ΞΉ) : Injective I.splitCenterBox := fun _ _ H β¦
by_contra fun Hne β¦ (I.disjoint_splitCenterBox Hne).ne (nonempty_coe _).ne_empty (H βΈ rfl)
#align box_integral.box.injective_split_center_box BoxIntegral.Box.injective_splitCenterBox
@[simp]
theorem exists_mem_splitCenterBox {I : Box ΞΉ} {x : ΞΉ β β} : (β s, x β I.splitCenterBox s) β x β I :=
β¨fun β¨s, hsβ© β¦ I.splitCenterBox_le s hs, fun hx β¦
β¨{ i | (I.lower i + I.upper i) / 2 < x i }, mem_splitCenterBox.2 β¨hx, fun _ β¦ Iff.rflβ©β©β©
#align box_integral.box.exists_mem_split_center_box BoxIntegral.Box.exists_mem_splitCenterBox
@[simps]
def splitCenterBoxEmb (I : Box ΞΉ) : Set ΞΉ βͺ Box ΞΉ :=
β¨splitCenterBox I, injective_splitCenterBox Iβ©
#align box_integral.box.split_center_box_emb BoxIntegral.Box.splitCenterBoxEmb
@[simp]
| Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean | 95 | 97 | theorem iUnion_coe_splitCenterBox (I : Box ΞΉ) : β s, (I.splitCenterBox s : Set (ΞΉ β β)) = I := by |
ext x
simp
| 1,769 |
import Mathlib.Analysis.BoxIntegral.Box.Basic
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.box_integral.box.subbox_induction from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Finset Function Filter Metric Classical Topology Filter ENNReal
noncomputable section
namespace BoxIntegral
namespace Box
variable {ΞΉ : Type*} {I J : Box ΞΉ}
def splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) : Box ΞΉ where
lower := s.piecewise (fun i β¦ (I.lower i + I.upper i) / 2) I.lower
upper := s.piecewise I.upper fun i β¦ (I.lower i + I.upper i) / 2
lower_lt_upper i := by
dsimp only [Set.piecewise]
split_ifs <;> simp only [left_lt_add_div_two, add_div_two_lt_right, I.lower_lt_upper]
#align box_integral.box.split_center_box BoxIntegral.Box.splitCenterBox
theorem mem_splitCenterBox {s : Set ΞΉ} {y : ΞΉ β β} :
y β I.splitCenterBox s β y β I β§ β i, (I.lower i + I.upper i) / 2 < y i β i β s := by
simp only [splitCenterBox, mem_def, β forall_and]
refine forall_congr' fun i β¦ ?_
dsimp only [Set.piecewise]
split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
exacts [β¨fun H β¦ β¨β¨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2β©, H.1β©,
fun H β¦ β¨H.2, H.1.2β©β©,
β¨fun H β¦ β¨β¨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).leβ©, H.2β©,
fun H β¦ β¨H.1.1, H.2β©β©]
#align box_integral.box.mem_split_center_box BoxIntegral.Box.mem_splitCenterBox
theorem splitCenterBox_le (I : Box ΞΉ) (s : Set ΞΉ) : I.splitCenterBox s β€ I :=
fun _ hx β¦ (mem_splitCenterBox.1 hx).1
#align box_integral.box.split_center_box_le BoxIntegral.Box.splitCenterBox_le
theorem disjoint_splitCenterBox (I : Box ΞΉ) {s t : Set ΞΉ} (h : s β t) :
Disjoint (I.splitCenterBox s : Set (ΞΉ β β)) (I.splitCenterBox t) := by
rw [disjoint_iff_inf_le]
rintro y β¨hs, htβ©; apply h
ext i
rw [mem_coe, mem_splitCenterBox] at hs ht
rw [β hs.2, β ht.2]
#align box_integral.box.disjoint_split_center_box BoxIntegral.Box.disjoint_splitCenterBox
theorem injective_splitCenterBox (I : Box ΞΉ) : Injective I.splitCenterBox := fun _ _ H β¦
by_contra fun Hne β¦ (I.disjoint_splitCenterBox Hne).ne (nonempty_coe _).ne_empty (H βΈ rfl)
#align box_integral.box.injective_split_center_box BoxIntegral.Box.injective_splitCenterBox
@[simp]
theorem exists_mem_splitCenterBox {I : Box ΞΉ} {x : ΞΉ β β} : (β s, x β I.splitCenterBox s) β x β I :=
β¨fun β¨s, hsβ© β¦ I.splitCenterBox_le s hs, fun hx β¦
β¨{ i | (I.lower i + I.upper i) / 2 < x i }, mem_splitCenterBox.2 β¨hx, fun _ β¦ Iff.rflβ©β©β©
#align box_integral.box.exists_mem_split_center_box BoxIntegral.Box.exists_mem_splitCenterBox
@[simps]
def splitCenterBoxEmb (I : Box ΞΉ) : Set ΞΉ βͺ Box ΞΉ :=
β¨splitCenterBox I, injective_splitCenterBox Iβ©
#align box_integral.box.split_center_box_emb BoxIntegral.Box.splitCenterBoxEmb
@[simp]
theorem iUnion_coe_splitCenterBox (I : Box ΞΉ) : β s, (I.splitCenterBox s : Set (ΞΉ β β)) = I := by
ext x
simp
#align box_integral.box.Union_coe_split_center_box BoxIntegral.Box.iUnion_coe_splitCenterBox
@[simp]
| Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean | 101 | 103 | theorem upper_sub_lower_splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) (i : ΞΉ) :
(I.splitCenterBox s).upper i - (I.splitCenterBox s).lower i = (I.upper i - I.lower i) / 2 := by |
by_cases i β s <;> field_simp [splitCenterBox] <;> field_simp [mul_two, two_mul]
| 1,769 |
import Mathlib.Analysis.BoxIntegral.Box.Basic
import Mathlib.Analysis.SpecificLimits.Basic
#align_import analysis.box_integral.box.subbox_induction from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Finset Function Filter Metric Classical Topology Filter ENNReal
noncomputable section
namespace BoxIntegral
namespace Box
variable {ΞΉ : Type*} {I J : Box ΞΉ}
def splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) : Box ΞΉ where
lower := s.piecewise (fun i β¦ (I.lower i + I.upper i) / 2) I.lower
upper := s.piecewise I.upper fun i β¦ (I.lower i + I.upper i) / 2
lower_lt_upper i := by
dsimp only [Set.piecewise]
split_ifs <;> simp only [left_lt_add_div_two, add_div_two_lt_right, I.lower_lt_upper]
#align box_integral.box.split_center_box BoxIntegral.Box.splitCenterBox
theorem mem_splitCenterBox {s : Set ΞΉ} {y : ΞΉ β β} :
y β I.splitCenterBox s β y β I β§ β i, (I.lower i + I.upper i) / 2 < y i β i β s := by
simp only [splitCenterBox, mem_def, β forall_and]
refine forall_congr' fun i β¦ ?_
dsimp only [Set.piecewise]
split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
exacts [β¨fun H β¦ β¨β¨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2β©, H.1β©,
fun H β¦ β¨H.2, H.1.2β©β©,
β¨fun H β¦ β¨β¨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).leβ©, H.2β©,
fun H β¦ β¨H.1.1, H.2β©β©]
#align box_integral.box.mem_split_center_box BoxIntegral.Box.mem_splitCenterBox
theorem splitCenterBox_le (I : Box ΞΉ) (s : Set ΞΉ) : I.splitCenterBox s β€ I :=
fun _ hx β¦ (mem_splitCenterBox.1 hx).1
#align box_integral.box.split_center_box_le BoxIntegral.Box.splitCenterBox_le
theorem disjoint_splitCenterBox (I : Box ΞΉ) {s t : Set ΞΉ} (h : s β t) :
Disjoint (I.splitCenterBox s : Set (ΞΉ β β)) (I.splitCenterBox t) := by
rw [disjoint_iff_inf_le]
rintro y β¨hs, htβ©; apply h
ext i
rw [mem_coe, mem_splitCenterBox] at hs ht
rw [β hs.2, β ht.2]
#align box_integral.box.disjoint_split_center_box BoxIntegral.Box.disjoint_splitCenterBox
theorem injective_splitCenterBox (I : Box ΞΉ) : Injective I.splitCenterBox := fun _ _ H β¦
by_contra fun Hne β¦ (I.disjoint_splitCenterBox Hne).ne (nonempty_coe _).ne_empty (H βΈ rfl)
#align box_integral.box.injective_split_center_box BoxIntegral.Box.injective_splitCenterBox
@[simp]
theorem exists_mem_splitCenterBox {I : Box ΞΉ} {x : ΞΉ β β} : (β s, x β I.splitCenterBox s) β x β I :=
β¨fun β¨s, hsβ© β¦ I.splitCenterBox_le s hs, fun hx β¦
β¨{ i | (I.lower i + I.upper i) / 2 < x i }, mem_splitCenterBox.2 β¨hx, fun _ β¦ Iff.rflβ©β©β©
#align box_integral.box.exists_mem_split_center_box BoxIntegral.Box.exists_mem_splitCenterBox
@[simps]
def splitCenterBoxEmb (I : Box ΞΉ) : Set ΞΉ βͺ Box ΞΉ :=
β¨splitCenterBox I, injective_splitCenterBox Iβ©
#align box_integral.box.split_center_box_emb BoxIntegral.Box.splitCenterBoxEmb
@[simp]
theorem iUnion_coe_splitCenterBox (I : Box ΞΉ) : β s, (I.splitCenterBox s : Set (ΞΉ β β)) = I := by
ext x
simp
#align box_integral.box.Union_coe_split_center_box BoxIntegral.Box.iUnion_coe_splitCenterBox
@[simp]
theorem upper_sub_lower_splitCenterBox (I : Box ΞΉ) (s : Set ΞΉ) (i : ΞΉ) :
(I.splitCenterBox s).upper i - (I.splitCenterBox s).lower i = (I.upper i - I.lower i) / 2 := by
by_cases i β s <;> field_simp [splitCenterBox] <;> field_simp [mul_two, two_mul]
#align box_integral.box.upper_sub_lower_split_center_box BoxIntegral.Box.upper_sub_lower_splitCenterBox
@[elab_as_elim]
| Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean | 122 | 170 | theorem subbox_induction_on' {p : Box ΞΉ β Prop} (I : Box ΞΉ)
(H_ind : β J β€ I, (β s, p (splitCenterBox J s)) β p J)
(H_nhds : β z β Box.Icc I, β U β π[Box.Icc I] z, β J β€ I, β (m : β), z β Box.Icc J β
Box.Icc J β U β (β i, J.upper i - J.lower i = (I.upper i - I.lower i) / 2 ^ m) β p J) :
p I := by |
by_contra hpI
-- First we use `H_ind` to construct a decreasing sequence of boxes such that `β m, Β¬p (J m)`.
replace H_ind := fun J hJ β¦ not_imp_not.2 (H_ind J hJ)
simp only [exists_imp, not_forall] at H_ind
choose! s hs using H_ind
set J : β β Box ΞΉ := fun m β¦ (fun J β¦ splitCenterBox J (s J))^[m] I
have J_succ : β m, J (m + 1) = splitCenterBox (J m) (s <| J m) :=
fun m β¦ iterate_succ_apply' _ _ _
-- Now we prove some properties of `J`
have hJmono : Antitone J :=
antitone_nat_of_succ_le fun n β¦ by simpa [J_succ] using splitCenterBox_le _ _
have hJle : β m, J m β€ I := fun m β¦ hJmono (zero_le m)
have hJp : β m, Β¬p (J m) :=
fun m β¦ Nat.recOn m hpI fun m β¦ by simpa only [J_succ] using hs (J m) (hJle m)
have hJsub : β m i, (J m).upper i - (J m).lower i = (I.upper i - I.lower i) / 2 ^ m := by
intro m i
induction' m with m ihm
Β· simp [J, Nat.zero_eq]
simp only [pow_succ, J_succ, upper_sub_lower_splitCenterBox, ihm, div_div]
have h0 : J 0 = I := rfl
clear_value J
clear hpI hs J_succ s
-- Let `z` be the unique common point of all `(J m).Icc`. Then `H_nhds` proves `p (J m)` for
-- sufficiently large `m`. This contradicts `hJp`.
set z : ΞΉ β β := β¨ m, (J m).lower
have hzJ : β m, z β Box.Icc (J m) :=
mem_iInter.1 (ciSup_mem_iInter_Icc_of_antitone_Icc
((@Box.Icc ΞΉ).monotone.comp_antitone hJmono) fun m β¦ (J m).lower_le_upper)
have hJl_mem : β m, (J m).lower β Box.Icc I := fun m β¦ le_iff_Icc.1 (hJle m) (J m).lower_mem_Icc
have hJu_mem : β m, (J m).upper β Box.Icc I := fun m β¦ le_iff_Icc.1 (hJle m) (J m).upper_mem_Icc
have hJlz : Tendsto (fun m β¦ (J m).lower) atTop (π z) :=
tendsto_atTop_ciSup (antitone_lower.comp hJmono) β¨I.upper, fun x β¨m, hmβ© β¦ hm βΈ (hJl_mem m).2β©
have hJuz : Tendsto (fun m β¦ (J m).upper) atTop (π z) := by
suffices Tendsto (fun m β¦ (J m).upper - (J m).lower) atTop (π 0) by simpa using hJlz.add this
refine tendsto_pi_nhds.2 fun i β¦ ?_
simpa [hJsub] using
tendsto_const_nhds.div_atTop (tendsto_pow_atTop_atTop_of_one_lt _root_.one_lt_two)
replace hJlz : Tendsto (fun m β¦ (J m).lower) atTop (π[Icc I.lower I.upper] z) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ hJlz (eventually_of_forall hJl_mem)
replace hJuz : Tendsto (fun m β¦ (J m).upper) atTop (π[Icc I.lower I.upper] z) :=
tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ hJuz (eventually_of_forall hJu_mem)
rcases H_nhds z (h0 βΈ hzJ 0) with β¨U, hUz, hUβ©
rcases (tendsto_lift'.1 (hJlz.Icc hJuz) U hUz).exists with β¨m, hUmβ©
exact hJp m (hU (J m) (hJle m) m (hzJ m) hUm (hJsub m))
| 1,769 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Interval.Set.IsoIoo
import Mathlib.Topology.Order.MonotoneContinuity
import Mathlib.Topology.UrysohnsBounded
#align_import topology.tietze_extension from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
section TietzeExtensionClass
universe u uβ uβ v w
-- TODO: define *absolute retracts* and then prove they satisfy Tietze extension.
-- Then make instances of that instead and remove this class.
class TietzeExtension (Y : Type v) [TopologicalSpace Y] : Prop where
exists_restrict_eq' {X : Type u} [TopologicalSpace X] [NormalSpace X] (s : Set X)
(hs : IsClosed s) (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f
variable {Xβ : Type uβ} [TopologicalSpace Xβ]
variable {X : Type u} [TopologicalSpace X] [NormalSpace X] {s : Set X} (hs : IsClosed s)
variable {e : Xβ β X} (he : ClosedEmbedding e)
variable {Y : Type v} [TopologicalSpace Y] [TietzeExtension.{u, v} Y]
theorem ContinuousMap.exists_restrict_eq (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f :=
TietzeExtension.exists_restrict_eq' s hs f
#align continuous_map.exists_restrict_eq_of_closed ContinuousMap.exists_restrict_eq
| Mathlib/Topology/TietzeExtension.lean | 73 | 77 | theorem ContinuousMap.exists_extension (f : C(Xβ, Y)) :
β (g : C(X, Y)), g.comp β¨e, he.continuousβ© = f := by |
let e' : Xβ ββ Set.range e := Homeomorph.ofEmbedding _ he.toEmbedding
obtain β¨g, hgβ© := (f.comp e'.symm).exists_restrict_eq he.isClosed_range
exact β¨g, by ext x; simpa using congr($(hg) β¨e' x, x, rflβ©)β©
| 1,770 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Interval.Set.IsoIoo
import Mathlib.Topology.Order.MonotoneContinuity
import Mathlib.Topology.UrysohnsBounded
#align_import topology.tietze_extension from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
section TietzeExtensionClass
universe u uβ uβ v w
-- TODO: define *absolute retracts* and then prove they satisfy Tietze extension.
-- Then make instances of that instead and remove this class.
class TietzeExtension (Y : Type v) [TopologicalSpace Y] : Prop where
exists_restrict_eq' {X : Type u} [TopologicalSpace X] [NormalSpace X] (s : Set X)
(hs : IsClosed s) (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f
variable {Xβ : Type uβ} [TopologicalSpace Xβ]
variable {X : Type u} [TopologicalSpace X] [NormalSpace X] {s : Set X} (hs : IsClosed s)
variable {e : Xβ β X} (he : ClosedEmbedding e)
variable {Y : Type v} [TopologicalSpace Y] [TietzeExtension.{u, v} Y]
theorem ContinuousMap.exists_restrict_eq (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f :=
TietzeExtension.exists_restrict_eq' s hs f
#align continuous_map.exists_restrict_eq_of_closed ContinuousMap.exists_restrict_eq
theorem ContinuousMap.exists_extension (f : C(Xβ, Y)) :
β (g : C(X, Y)), g.comp β¨e, he.continuousβ© = f := by
let e' : Xβ ββ Set.range e := Homeomorph.ofEmbedding _ he.toEmbedding
obtain β¨g, hgβ© := (f.comp e'.symm).exists_restrict_eq he.isClosed_range
exact β¨g, by ext x; simpa using congr($(hg) β¨e' x, x, rflβ©)β©
theorem ContinuousMap.exists_extension' (f : C(Xβ, Y)) : β (g : C(X, Y)), g β e = f :=
f.exists_extension he |>.imp fun g hg β¦ by ext x; congrm($(hg) x)
#align continuous_map.exists_extension_of_closed_embedding ContinuousMap.exists_extension'
| Mathlib/Topology/TietzeExtension.lean | 96 | 100 | theorem ContinuousMap.exists_forall_mem_restrict_eq {Y : Type v} [TopologicalSpace Y] (f : C(s, Y))
{t : Set Y} (hf : β x, f x β t) [ht : TietzeExtension.{u, v} t] :
β (g : C(X, Y)), (β x, g x β t) β§ g.restrict s = f := by |
obtain β¨g, hgβ© := mk _ (map_continuous f |>.codRestrict hf) |>.exists_restrict_eq hs
exact β¨comp β¨Subtype.val, by continuityβ© g, by simp, by ext x; congrm(($(hg) x : Y))β©
| 1,770 |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Order.Interval.Set.IsoIoo
import Mathlib.Topology.Order.MonotoneContinuity
import Mathlib.Topology.UrysohnsBounded
#align_import topology.tietze_extension from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
section TietzeExtensionClass
universe u uβ uβ v w
-- TODO: define *absolute retracts* and then prove they satisfy Tietze extension.
-- Then make instances of that instead and remove this class.
class TietzeExtension (Y : Type v) [TopologicalSpace Y] : Prop where
exists_restrict_eq' {X : Type u} [TopologicalSpace X] [NormalSpace X] (s : Set X)
(hs : IsClosed s) (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f
variable {Xβ : Type uβ} [TopologicalSpace Xβ]
variable {X : Type u} [TopologicalSpace X] [NormalSpace X] {s : Set X} (hs : IsClosed s)
variable {e : Xβ β X} (he : ClosedEmbedding e)
variable {Y : Type v} [TopologicalSpace Y] [TietzeExtension.{u, v} Y]
theorem ContinuousMap.exists_restrict_eq (f : C(s, Y)) : β (g : C(X, Y)), g.restrict s = f :=
TietzeExtension.exists_restrict_eq' s hs f
#align continuous_map.exists_restrict_eq_of_closed ContinuousMap.exists_restrict_eq
theorem ContinuousMap.exists_extension (f : C(Xβ, Y)) :
β (g : C(X, Y)), g.comp β¨e, he.continuousβ© = f := by
let e' : Xβ ββ Set.range e := Homeomorph.ofEmbedding _ he.toEmbedding
obtain β¨g, hgβ© := (f.comp e'.symm).exists_restrict_eq he.isClosed_range
exact β¨g, by ext x; simpa using congr($(hg) β¨e' x, x, rflβ©)β©
theorem ContinuousMap.exists_extension' (f : C(Xβ, Y)) : β (g : C(X, Y)), g β e = f :=
f.exists_extension he |>.imp fun g hg β¦ by ext x; congrm($(hg) x)
#align continuous_map.exists_extension_of_closed_embedding ContinuousMap.exists_extension'
theorem ContinuousMap.exists_forall_mem_restrict_eq {Y : Type v} [TopologicalSpace Y] (f : C(s, Y))
{t : Set Y} (hf : β x, f x β t) [ht : TietzeExtension.{u, v} t] :
β (g : C(X, Y)), (β x, g x β t) β§ g.restrict s = f := by
obtain β¨g, hgβ© := mk _ (map_continuous f |>.codRestrict hf) |>.exists_restrict_eq hs
exact β¨comp β¨Subtype.val, by continuityβ© g, by simp, by ext x; congrm(($(hg) x : Y))β©
| Mathlib/Topology/TietzeExtension.lean | 108 | 112 | theorem ContinuousMap.exists_extension_forall_mem {Y : Type v} [TopologicalSpace Y] (f : C(Xβ, Y))
{t : Set Y} (hf : β x, f x β t) [ht : TietzeExtension.{u, v} t] :
β (g : C(X, Y)), (β x, g x β t) β§ g.comp β¨e, he.continuousβ© = f := by |
obtain β¨g, hgβ© := mk _ (map_continuous f |>.codRestrict hf) |>.exists_extension he
exact β¨comp β¨Subtype.val, by continuityβ© g, by simp, by ext x; congrm(($(hg) x : Y))β©
| 1,770 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.