fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
continuousWithinAt_hom_bundle {M : Type*} [TopologicalSpace M]
(f : M → TotalSpace (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) {s : Set M} {x₀ : M} :
ContinuousWithinAt f s x₀ ↔
ContinuousWithinAt (fun x ↦ (f x).1) s x₀ ∧
ContinuousWithinAt
(fun x ↦ inCoordinates F₁ E₁ F₂ E₂ (f x₀).1 (f x).1 (f x₀).1 (f x).1 (f x).2) s x₀ :=
FiberBundle.continuousWithinAt_totalSpace .. | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousWithinAt_hom_bundle | null |
continuousAt_hom_bundle {M : Type*} [TopologicalSpace M]
(f : M → TotalSpace (F₁ →SL[σ] F₂) (fun x ↦ E₁ x →SL[σ] E₂ x)) {x₀ : M} :
ContinuousAt f x₀ ↔
ContinuousAt (fun x ↦ (f x).1) x₀ ∧
ContinuousAt
(fun x ↦ inCoordinates F₁ E₁ F₂ E₂ (f x₀).1 (f x).1 (f x₀).1 (f x).1 (f x).2) x₀ :=
FiberBundle.continuousAt_totalSpace .. | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | continuousAt_hom_bundle | null |
ContinuousWithinAt.clm_apply_of_inCoordinates
(hϕ : ContinuousWithinAt
(fun m ↦ inCoordinates F₁ E₁ F₂ E₂ (b₁ m₀) (b₁ m) (b₂ m₀) (b₂ m) (ϕ m)) s m₀)
(hv : ContinuousWithinAt (fun m ↦ (v m : TotalSpace F₁ E₁)) s m₀)
(hb₂ : ContinuousWithinAt b₂ s m₀) :
ContinuousWithinAt (fun m ↦ (ϕ m (v m) : TotalSpace F₂ E₂)) s m₀ := by
rw [← continuousWithinAt_insert_self] at hϕ hv hb₂ ⊢
rw [FiberBundle.continuousWithinAt_totalSpace] at hv ⊢
refine ⟨hb₂, ?_⟩
apply (ContinuousWithinAt.clm_apply hϕ hv.2).congr_of_eventuallyEq_of_mem ?_ (mem_insert m₀ s)
have A : ∀ᶠ m in 𝓝[insert m₀ s] m₀, b₁ m ∈ (trivializationAt F₁ E₁ (b₁ m₀)).baseSet := by
apply hv.1
apply (trivializationAt F₁ E₁ (b₁ m₀)).open_baseSet.mem_nhds
exact FiberBundle.mem_baseSet_trivializationAt' (b₁ m₀)
have A' : ∀ᶠ m in 𝓝[insert m₀ s] m₀, b₂ m ∈ (trivializationAt F₂ E₂ (b₂ m₀)).baseSet := by
apply hb₂
apply (trivializationAt F₂ E₂ (b₂ m₀)).open_baseSet.mem_nhds
exact FiberBundle.mem_baseSet_trivializationAt' (b₂ m₀)
filter_upwards [A, A'] with m hm h'm
simp [inCoordinates_eq hm h'm,
Trivialization.symm_apply_apply_mk (trivializationAt F₁ E₁ (b₁ m₀)) hm (v m)] | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousWithinAt.clm_apply_of_inCoordinates | Consider a continuous map `v : M → E₁` to a vector bundle, over a base map `b₁ : M → B₁`, and
another basemap `b₂ : M → B₂`. Given linear maps `ϕ m : E₁ (b₁ m) → E₂ (b₂ m)` depending
continuously on `m`, one can apply `ϕ m` to `g m`, and the resulting map is continuous.
Note that the continuity of `ϕ` cannot be always be stated as continuity of a map into a bundle,
as the pullback bundles `b₁ *ᵖ E₁` and `b₂ *ᵖ E₂` only have a nice topology when `b₁` and `b₂` are
globally continuous, but we want to apply this lemma with only local information. Therefore, we
formulate it using continuity of `ϕ` read in coordinates.
Version for `ContinuousWithinAt`. We also give a version for `ContinuousAt`, but no version for
`ContinuousOn` or `Continuous` as our assumption, written in coordinates, only makes sense around
a point.
For a version with `B₁ = B₂` and `b₁ = b₂`, in which continuity can be expressed without
`inCoordinates`, see `ContinuousWithinAt.clm_bundle_apply` |
ContinuousAt.clm_apply_of_inCoordinates
(hϕ : ContinuousAt
(fun m ↦ inCoordinates F₁ E₁ F₂ E₂ (b₁ m₀) (b₁ m) (b₂ m₀) (b₂ m) (ϕ m)) m₀)
(hv : ContinuousAt (fun m ↦ (v m : TotalSpace F₁ E₁)) m₀)
(hb₂ : ContinuousAt b₂ m₀) :
ContinuousAt (fun m ↦ (ϕ m (v m) : TotalSpace F₂ E₂)) m₀ := by
rw [← continuousWithinAt_univ] at hϕ hv hb₂ ⊢
exact hϕ.clm_apply_of_inCoordinates hv hb₂ | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousAt.clm_apply_of_inCoordinates | Consider a continuous map `v : M → E₁` to a vector bundle, over a base map `b₁ : M → B₁`, and
another basemap `b₂ : M → B₂`. Given linear maps `ϕ m : E₁ (b₁ m) → E₂ (b₂ m)` depending
continuously on `m`, one can apply `ϕ m` to `g m`, and the resulting map is continuous.
Note that the continuity of `ϕ` cannot be always be stated as continuity of a map into a bundle,
as the pullback bundles `b₁ *ᵖ E₁` and `b₂ *ᵖ E₂` only have a nice topology when `b₁` and `b₂` are
globally continuous, but we want to apply this lemma with only local information. Therefore, we
formulate it using continuity of `ϕ` read in coordinates.
Version for `ContinuousAt`. We also give a version for `ContinuousWithinAt`, but no version for
`ContinuousOn` or `Continuous` as our assumption, written in coordinates, only makes sense around
a point.
For a version with `B₁ = B₂` and `b₁ = b₂`, in which continuity can be expressed without
`inCoordinates`, see `ContinuousWithinAt.clm_bundle_apply` |
ContinuousWithinAt.clm_bundle_apply
(hϕ : ContinuousWithinAt
(fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂) (E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x)) (b m) (ϕ m))
s x)
(hv : ContinuousWithinAt (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) s x) :
ContinuousWithinAt
(fun m ↦ TotalSpace.mk' F₂ (b m) (ϕ m (v m))) s x := by
simp only [continuousWithinAt_hom_bundle] at hϕ
exact hϕ.2.clm_apply_of_inCoordinates hv hϕ.1 | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousWithinAt.clm_bundle_apply | Consider a `C^n` map `v : M → E₁` to a vector bundle, over a basemap `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is `C^n`. |
ContinuousAt.clm_bundle_apply
(hϕ : ContinuousAt
(fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂) (E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x)) (b m) (ϕ m)) x)
(hv : ContinuousAt (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) x) :
ContinuousAt (fun m ↦ TotalSpace.mk' F₂ (b m) (ϕ m (v m))) x := by
simp only [← continuousWithinAt_univ] at hϕ hv ⊢
exact hϕ.clm_bundle_apply hv | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousAt.clm_bundle_apply | Consider a `C^n` map `v : M → E₁` to a vector bundle, over a basemap `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is `C^n`. |
ContinuousOn.clm_bundle_apply
(hϕ : ContinuousOn
(fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂) (E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x)) (b m) (ϕ m)) s)
(hv : ContinuousOn (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) s) :
ContinuousOn (fun m ↦ TotalSpace.mk' F₂ (b m) (ϕ m (v m))) s :=
fun x hx ↦ (hϕ x hx).clm_bundle_apply (hv x hx) | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousOn.clm_bundle_apply | Consider a `C^n` map `v : M → E₁` to a vector bundle, over a basemap `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is `C^n`. |
Continuous.clm_bundle_apply
(hϕ : Continuous
(fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂) (E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x)) (b m) (ϕ m)))
(hv : Continuous (fun m ↦ TotalSpace.mk' F₁ (b m) (v m))) :
Continuous (fun m ↦ TotalSpace.mk' F₂ (b m) (ϕ m (v m))) := by
simp only [← continuousOn_univ] at hϕ hv ⊢
exact hϕ.clm_bundle_apply hv | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Continuous.clm_bundle_apply | Consider a `C^n` map `v : M → E₁` to a vector bundle, over a basemap `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is `C^n`. |
ContinuousWithinAt.clm_bundle_apply₂
(hψ : ContinuousWithinAt (fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂ →L[𝕜] F₃)
(E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x →L[𝕜] E₃ x)) (b m) (ψ m)) s x)
(hv : ContinuousWithinAt (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) s x)
(hw : ContinuousWithinAt (fun m ↦ TotalSpace.mk' F₂ (b m) (w m)) s x) :
ContinuousWithinAt (fun m ↦ TotalSpace.mk' F₃ (b m) (ψ m (v m) (w m))) s x :=
(hψ.clm_bundle_apply hv).clm_bundle_apply hw | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousWithinAt.clm_bundle_apply₂ | Consider `C^n` maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a basemap
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is `C^n`. |
ContinuousAt.clm_bundle_apply₂
(hψ : ContinuousAt (fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂ →L[𝕜] F₃)
(E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x →L[𝕜] E₃ x)) (b m) (ψ m)) x)
(hv : ContinuousAt (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) x)
(hw : ContinuousAt (fun m ↦ TotalSpace.mk' F₂ (b m) (w m)) x) :
ContinuousAt (fun m ↦ TotalSpace.mk' F₃ (b m) (ψ m (v m) (w m))) x :=
(hψ.clm_bundle_apply hv).clm_bundle_apply hw | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousAt.clm_bundle_apply₂ | Consider `C^n` maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a basemap
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is `C^n`. |
ContinuousOn.clm_bundle_apply₂
(hψ : ContinuousOn
(fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂ →L[𝕜] F₃)
(E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x →L[𝕜] E₃ x)) (b m) (ψ m)) s)
(hv : ContinuousOn (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)) s)
(hw : ContinuousOn (fun m ↦ TotalSpace.mk' F₂ (b m) (w m)) s) :
ContinuousOn (fun m ↦ TotalSpace.mk' F₃ (b m) (ψ m (v m) (w m))) s :=
fun x hx ↦ (hψ x hx).clm_bundle_apply₂ (hv x hx) (hw x hx) | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | ContinuousOn.clm_bundle_apply₂ | Consider `C^n` maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a basemap
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is `C^n`. |
Continuous.clm_bundle_apply₂
(hψ : Continuous (fun m ↦ TotalSpace.mk' (F₁ →L[𝕜] F₂ →L[𝕜] F₃)
(E := fun (x : B) ↦ (E₁ x →L[𝕜] E₂ x →L[𝕜] E₃ x)) (b m) (ψ m)))
(hv : Continuous (fun m ↦ TotalSpace.mk' F₁ (b m) (v m)))
(hw : Continuous (fun m ↦ TotalSpace.mk' F₂ (b m) (w m))) :
Continuous (fun m ↦ TotalSpace.mk' F₃ (b m) (ψ m (v m) (w m))) := by
simp only [← continuousOn_univ] at hψ hv hw ⊢
exact hψ.clm_bundle_apply₂ hv hw | lemma | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | Continuous.clm_bundle_apply₂ | Consider `C^n` maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a basemap
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is `C^n`. |
inCoordinates_apply_eq₂
{x₀ x : B} {ϕ : E₁ x →L[𝕜] E₂ x →L[𝕜] E₃ x} {v : F₁} {w : F₂}
(h₁x : x ∈ (trivializationAt F₁ E₁ x₀).baseSet)
(h₂x : x ∈ (trivializationAt F₂ E₂ x₀).baseSet)
(h₃x : x ∈ (trivializationAt F₃ E₃ x₀).baseSet) :
inCoordinates F₁ E₁ (F₂ →L[𝕜] F₃) (fun x ↦ E₂ x →L[𝕜] E₃ x) x₀ x x₀ x ϕ v w =
(trivializationAt F₃ E₃ x₀).linearMapAt 𝕜 x
(ϕ ((trivializationAt F₁ E₁ x₀).symm x v) ((trivializationAt F₂ E₂ x₀).symm x w)) := by
rw [inCoordinates_eq h₁x (by simp [h₂x, h₃x])]
simp [hom_trivializationAt, Trivialization.continuousLinearMap_apply] | theorem | Topology | [
"Mathlib.Topology.VectorBundle.Basic"
] | Mathlib/Topology/VectorBundle/Hom.lean | inCoordinates_apply_eq₂ | Rewrite `ContinuousLinearMap.inCoordinates` using continuous linear equivalences, in the
bundle of bilinear maps. |
IsContinuousRiemannianBundle : Prop where
/-- There exists a bilinear form, depending continuously on the basepoint and defining the
inner product in the fibers. This is expressed as an existence statement so that it is Prop-valued
in terms of existing data, the inner product on the fibers and the fiber bundle structure. -/
exists_continuous : ∃ g : (Π x, E x →L[ℝ] E x →L[ℝ] ℝ),
Continuous (fun (x : B) ↦ TotalSpace.mk' (F →L[ℝ] F →L[ℝ] ℝ) x (g x))
∧ ∀ (x : B) (v w : E x), ⟪v, w⟫ = g x v w | class | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | IsContinuousRiemannianBundle | Consider a real vector bundle in which each fiber is endowed with an inner product.
We say that the bundle is *Riemannian* if the inner product depends continuously on the base point.
This assumption is spelled `IsContinuousRiemannianBundle F E` where `F` is the model fiber,
and `E : B → Type*` is the bundle. |
ContinuousWithinAt.inner_bundle
(hv : ContinuousWithinAt (fun m ↦ (v m : TotalSpace F E)) s x)
(hw : ContinuousWithinAt (fun m ↦ (w m : TotalSpace F E)) s x) :
ContinuousWithinAt (fun m ↦ ⟪v m, w m⟫) s x := by
rcases h.exists_continuous with ⟨g, g_cont, hg⟩
have hf : ContinuousWithinAt b s x := by
simp only [FiberBundle.continuousWithinAt_totalSpace] at hv
exact hv.1
simp only [hg]
have : ContinuousWithinAt
(fun m ↦ TotalSpace.mk' ℝ (E := Bundle.Trivial B ℝ) (b m) (g (b m) (v m) (w m))) s x :=
(g_cont.continuousAt.comp_continuousWithinAt hf).clm_bundle_apply₂ (F₁ := F) (F₂ := F) hv hw
simp only [FiberBundle.continuousWithinAt_totalSpace] at this
exact this.2 | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | ContinuousWithinAt.inner_bundle | A trivial vector bundle, in which the model fiber has a inner product,
is a Riemannian bundle. -/
instance : IsContinuousRiemannianBundle F₁ (Bundle.Trivial B F₁) := by
refine ⟨fun x ↦ innerSL ℝ, ?_, fun x v w ↦ rfl⟩
rw [continuous_iff_continuousAt]
intro x
rw [FiberBundle.continuousAt_totalSpace]
refine ⟨continuousAt_id, ?_⟩
convert continuousAt_const (y := innerSL ℝ)
ext v w
simp [hom_trivializationAt_apply, inCoordinates, Trivialization.linearMapAt_apply]
end Trivial
section Continuous
variable
{M : Type*} [TopologicalSpace M] [h : IsContinuousRiemannianBundle F E]
{b : M → B} {v w : ∀ x, E (b x)} {s : Set M} {x : M}
/-- Given two continuous maps into the same fibers of a continuous Riemannian bundle,
their inner product is continuous. Version with `ContinuousWithinAt`. |
ContinuousAt.inner_bundle
(hv : ContinuousAt (fun m ↦ (v m : TotalSpace F E)) x)
(hw : ContinuousAt (fun m ↦ (w m : TotalSpace F E)) x) :
ContinuousAt (fun b ↦ ⟪v b, w b⟫) x := by
simp only [← continuousWithinAt_univ] at hv hw ⊢
exact ContinuousWithinAt.inner_bundle hv hw | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | ContinuousAt.inner_bundle | Given two continuous maps into the same fibers of a continuous Riemannian bundle,
their inner product is continuous. Version with `ContinuousAt`. |
ContinuousOn.inner_bundle
(hv : ContinuousOn (fun m ↦ (v m : TotalSpace F E)) s)
(hw : ContinuousOn (fun m ↦ (w m : TotalSpace F E)) s) :
ContinuousOn (fun b ↦ ⟪v b, w b⟫) s :=
fun x hx ↦ (hv x hx).inner_bundle (hw x hx) | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | ContinuousOn.inner_bundle | Given two continuous maps into the same fibers of a continuous Riemannian bundle,
their inner product is continuous. Version with `ContinuousOn`. |
Continuous.inner_bundle
(hv : Continuous (fun m ↦ (v m : TotalSpace F E)))
(hw : Continuous (fun m ↦ (w m : TotalSpace F E))) :
Continuous (fun b ↦ ⟪v b, w b⟫) := by
simp only [continuous_iff_continuousAt] at hv hw ⊢
exact fun x ↦ (hv x).inner_bundle (hw x)
variable (F E) | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | Continuous.inner_bundle | Given two continuous maps into the same fibers of a continuous Riemannian bundle,
their inner product is continuous. |
eventually_norm_symmL_trivializationAt_self_comp_lt (x : B) {r : ℝ} (hr : 1 < r) :
∀ᶠ y in 𝓝 x, ‖((trivializationAt F E x).symmL ℝ x)
∘L ((trivializationAt F E x).continuousLinearMapAt ℝ y)‖ < r := by
/- We will expand the definition of continuity of the inner product structure, in the chart.
Denote `g' x` the metric in the fiber of `x`, read in the chart. For `y` close to `x`, then
`g' y` and `g' x` are close. The inequality we have to prove reduces to comparing
`g' y w w` and `g' x w w`, where `w` is the image in the chart of a tangent vector `v` at `y`.
Their difference is controlled by `δ ‖w‖ ^ 2` for any small `δ > 0`. To conclude, we argue that
`‖w‖` is comparable to the norm inside the fiber over `x`, i.e., `g' x w w`, because there
is a continuous linear equivalence between these two spaces by definition of vector bundles. -/
obtain ⟨r', hr', r'r⟩ : ∃ r', 1 < r' ∧ r' < r := exists_between hr
have h'x : x ∈ (trivializationAt F E x).baseSet := FiberBundle.mem_baseSet_trivializationAt' x
let G := (trivializationAt F E x).continuousLinearEquivAt ℝ x h'x
let C := (‖(G : E x →L[ℝ] F)‖) ^ 2
obtain ⟨δ, δpos, hδ⟩ : ∃ δ, 0 < δ ∧ (r' ^ 2) ⁻¹ < 1 - δ * C := by
have A : ∀ᶠ δ in 𝓝[>] (0 : ℝ), 0 < δ := self_mem_nhdsWithin
have B : Tendsto (fun δ ↦ 1 - δ * C) (𝓝[>] 0) (𝓝 (1 - 0 * C)) := by
apply tendsto_inf_left
exact tendsto_const_nhds.sub (tendsto_id.mul tendsto_const_nhds)
have B' : ∀ᶠ δ in 𝓝[>] 0, (r' ^ 2) ⁻¹ < 1 - δ * C := by
apply (tendsto_order.1 B).1
simpa using inv_lt_one_of_one_lt₀ (by nlinarith)
exact (A.and B').exists
rcases h.exists_continuous with ⟨g, g_cont, hg⟩
let g' : B → F →L[ℝ] F →L[ℝ] ℝ := fun y ↦
inCoordinates F E (F →L[ℝ] ℝ) (fun x ↦ E x →L[ℝ] ℝ) x y x y (g y)
have hg' : ContinuousAt g' x := by
have W := g_cont.continuousAt (x := x)
simp only [continuousAt_hom_bundle] at W
exact W.2
have : ∀ᶠ y in 𝓝 x, dist (g' y) (g' x) < δ := by
rw [Metric.continuousAt_iff'] at hg'
apply hg' _ δpos
filter_upwards [this, (trivializationAt F E x).open_baseSet.mem_nhds h'x] with y hy h'y
have : ‖g' x - g' y‖ ≤ δ := by rw [← dist_eq_norm']; exact hy.le
apply (opNorm_le_bound _ (by linarith) (fun v ↦ ?_)).trans_lt r'r
let w := (trivializationAt F E x).continuousLinearMapAt ℝ y v
suffices ‖((trivializationAt F E x).symmL ℝ x) w‖ ^ 2 ≤ r' ^ 2 * ‖v‖ ^ 2 from
le_of_sq_le_sq (by simpa [mul_pow]) (by positivity)
simp only [Trivialization.symmL_apply, ← real_inner_self_eq_norm_sq, hg]
have hgy : g y v v = g' y w w := by
rw [inCoordinates_apply_eq₂ h'y h'y (Set.mem_univ _)]
have A : ((trivializationAt F E x).symm y)
((trivializationAt F E x).linearMapAt ℝ y v) = v := by
convert ((trivializationAt F E x).continuousLinearEquivAt ℝ _ h'y).symm_apply_apply v
rw [Trivialization.coe_continuousLinearEquivAt_eq _ h'y]
rfl
simp [A, w]
have hgx : g x ((trivializationAt F E x).symm x w) ((trivializationAt F E x).symm x w) =
g' x w w := by
rw [inCoordinates_apply_eq₂ h'x h'x (Set.mem_univ _)]
... | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | eventually_norm_symmL_trivializationAt_self_comp_lt | In a continuous Riemannian bundle, local changes of coordinates given by the trivialization at
a point distort the norm by a factor arbitrarily close to 1. |
eventually_norm_trivializationAt_lt (x : B) :
∃ C > 0, ∀ᶠ y in 𝓝 x, ‖(trivializationAt F E x).continuousLinearMapAt ℝ y‖ < C := by
refine ⟨(1 + ‖(trivializationAt F E x).continuousLinearMapAt ℝ x‖) * 2, by positivity, ?_⟩
filter_upwards [eventually_norm_symmL_trivializationAt_self_comp_lt F E x one_lt_two] with y hy
have A : ((trivializationAt F E x).continuousLinearMapAt ℝ x) ∘L
((trivializationAt F E x).symmL ℝ x) = ContinuousLinearMap.id _ _ := by
ext v
have h'x : x ∈ (trivializationAt F E x).baseSet := FiberBundle.mem_baseSet_trivializationAt' x
simp only [coe_comp', Trivialization.continuousLinearMapAt_apply, Trivialization.symmL_apply,
Function.comp_apply, coe_id', id_eq]
convert ((trivializationAt F E x).continuousLinearEquivAt ℝ _ h'x).apply_symm_apply v
rw [Trivialization.coe_continuousLinearEquivAt_eq _ h'x]
rfl
have : (trivializationAt F E x).continuousLinearMapAt ℝ y =
(ContinuousLinearMap.id _ _) ∘L ((trivializationAt F E x).continuousLinearMapAt ℝ y) := by simp
grw [this, ← A, comp_assoc, opNorm_comp_le]
gcongr
linarith | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | eventually_norm_trivializationAt_lt | In a continuous Riemannian bundle, the trivialization at a point is locally bounded in norm. |
eventually_norm_symmL_trivializationAt_comp_self_lt (x : B) {r : ℝ} (hr : 1 < r) :
∀ᶠ y in 𝓝 x, ‖((trivializationAt F E x).symmL ℝ y)
∘L ((trivializationAt F E x).continuousLinearMapAt ℝ x)‖ < r := by
/- We will expand the definition of continuity of the inner product structure, in the chart.
Denote `g' x` the metric in the fiber of `x`, read in the chart. For `y` close to `x`, then
`g' y` and `g' x` are close. The inequality we have to prove reduces to comparing
`g' y w w` and `g' x w w`, where `w` is the image in the chart of a tangent vector `v` at `x`.
Their difference is controlled by `δ ‖w‖ ^ 2` for any small `δ > 0`. To conclude, we argue that
`‖w‖` is comparable to the norm inside the fiber over `x`, i.e., `g' x w w`, because there
is a continuous linear equivalence between these two spaces by definition of vector bundles. -/
obtain ⟨r', hr', r'r⟩ : ∃ r', 1 < r' ∧ r' < r := exists_between hr
have h'x : x ∈ (trivializationAt F E x).baseSet := FiberBundle.mem_baseSet_trivializationAt' x
let G := (trivializationAt F E x).continuousLinearEquivAt ℝ x h'x
let C := (‖(G : E x →L[ℝ] F)‖) ^ 2
obtain ⟨δ, δpos, h'δ⟩ : ∃ δ, 0 < δ ∧ (1 + δ * C) < r' ^ 2 := by
have A : ∀ᶠ δ in 𝓝[>] (0 : ℝ), 0 < δ := self_mem_nhdsWithin
have B : Tendsto (fun δ ↦ 1 + δ * C) (𝓝[>] 0) (𝓝 (1 + 0 * C)) := by
apply tendsto_inf_left
exact tendsto_const_nhds.add (tendsto_id.mul tendsto_const_nhds)
have B' : ∀ᶠ δ in 𝓝[>] 0, 1 + δ * C < r' ^ 2 := by
apply (tendsto_order.1 B).2
simpa using hr'.trans_le (le_abs_self _)
exact (A.and B').exists
rcases h.exists_continuous with ⟨g, g_cont, hg⟩
let g' : B → F →L[ℝ] F →L[ℝ] ℝ := fun y ↦
inCoordinates F E (F →L[ℝ] ℝ) (fun x ↦ E x →L[ℝ] ℝ) x y x y (g y)
have hg' : ContinuousAt g' x := by
have W := g_cont.continuousAt (x := x)
simp only [continuousAt_hom_bundle] at W
exact W.2
have : ∀ᶠ y in 𝓝 x, dist (g' y) (g' x) < δ := by
rw [Metric.continuousAt_iff'] at hg'
apply hg' _ δpos
filter_upwards [this, (trivializationAt F E x).open_baseSet.mem_nhds h'x] with y hy h'y
have : ‖g' y - g' x‖ ≤ δ := by rw [← dist_eq_norm]; exact hy.le
apply (opNorm_le_bound _ (by linarith) (fun v ↦ ?_)).trans_lt r'r
let w := (trivializationAt F E x).continuousLinearMapAt ℝ x v
suffices ‖((trivializationAt F E x).symmL ℝ y) w‖ ^ 2 ≤ r' ^ 2 * ‖v‖ ^ 2 from
le_of_sq_le_sq (by simpa [mul_pow]) (by positivity)
simp only [Trivialization.symmL_apply, ← real_inner_self_eq_norm_sq, hg]
have hgx : g x v v = g' x w w := by
rw [inCoordinates_apply_eq₂ h'x h'x (Set.mem_univ _)]
have A : ((trivializationAt F E x).symm x)
((trivializationAt F E x).linearMapAt ℝ x v) = v := by
convert ((trivializationAt F E x).continuousLinearEquivAt ℝ _ h'x).symm_apply_apply v
rw [Trivialization.coe_continuousLinearEquivAt_eq _ h'x]
rfl
simp [A, w]
have hgy : g y ((trivializationAt F E x).symm y w) ((trivializationAt F E x).symm y w)
= g' y w w := by
rw [inCoordinates_apply_eq₂ h'y h'y (Set.mem_univ _)]
... | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | eventually_norm_symmL_trivializationAt_comp_self_lt | In a continuous Riemannian bundle, local changes of coordinates given by the trivialization at
a point distort the norm by a factor arbitrarily close to 1. |
eventually_norm_symmL_trivializationAt_lt (x : B) :
∃ C > 0, ∀ᶠ y in 𝓝 x, ‖(trivializationAt F E x).symmL ℝ y‖ < C := by
refine ⟨2 * (1 + ‖(trivializationAt F E x).symmL ℝ x‖), by positivity, ?_⟩
filter_upwards [eventually_norm_symmL_trivializationAt_comp_self_lt F E x one_lt_two] with y hy
have A : ((trivializationAt F E x).continuousLinearMapAt ℝ x) ∘L
((trivializationAt F E x).symmL ℝ x) = ContinuousLinearMap.id _ _ := by
ext v
have h'x : x ∈ (trivializationAt F E x).baseSet := FiberBundle.mem_baseSet_trivializationAt' x
simp only [coe_comp', Trivialization.continuousLinearMapAt_apply, Trivialization.symmL_apply,
Function.comp_apply, coe_id', id_eq]
convert ((trivializationAt F E x).continuousLinearEquivAt ℝ _ h'x).apply_symm_apply v
rw [Trivialization.coe_continuousLinearEquivAt_eq _ h'x]
rfl
have : (trivializationAt F E x).symmL ℝ y =
((trivializationAt F E x).symmL ℝ y) ∘L (ContinuousLinearMap.id _ _) := by simp
grw [this, ← A, ← comp_assoc, opNorm_comp_le]
gcongr
linarith | lemma | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | eventually_norm_symmL_trivializationAt_lt | In a continuous Riemannian bundle, the inverse of the trivialization at a point is locally
bounded in norm. |
RiemannianMetric where
/-- The inner product along the fibers of the bundle. -/
inner (b : B) : E b →L[ℝ] E b →L[ℝ] ℝ
symm (b : B) (v w : E b) : inner b v w = inner b w v
pos (b : B) (v : E b) (hv : v ≠ 0) : 0 < inner b v v
/-- The continuity at `0` is automatic when `E b` is isomorphic to a normed space, but since
we are not making this assumption here we have to include it. -/
continuousAt (b : B) : ContinuousAt (fun (v : E b) ↦ inner b v v) 0
isVonNBounded (b : B) : IsVonNBounded ℝ {v : E b | inner b v v < 1} | structure | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | RiemannianMetric | A family of inner product space structures on the fibers of a fiber bundle, defining the same
topology as the already existing one. This family is not assumed to be continuous or smooth: to
guarantee continuity, resp. smoothness, of the inner product as a function of the base point,
use `ContinuousRiemannianMetric` or `ContMDiffRiemannianMetric`.
This structure is used through `RiemannianBundle` for typeclass inference, to register the inner
product space structure on the fibers without creating diamonds. |
@[reducible] noncomputable RiemannianMetric.toCore (g : RiemannianMetric E) (b : B) :
InnerProductSpace.Core ℝ (E b) where
inner v w := g.inner b v w
conj_inner_symm v w := g.symm b w v
re_inner_nonneg v := by
rcases eq_or_ne v 0 with rfl | hv
· simp
· simpa using (g.pos b v hv).le
add_left v w x := by simp
smul_left c v := by simp
definite v h := by contrapose! h; exact (g.pos b v h).ne'
variable (E) in | def | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | RiemannianMetric.toCore | `Core structure associated to a family of inner products on the fibers of a fiber bundle. This
is an auxiliary construction to endow the fibers with an inner product space structure without
creating diamonds.
Warning: Do not use this `Core` structure if the space you are interested in already has a norm
instance defined on it, otherwise this will create a second non-defeq norm instance! |
RiemannianBundle where
/-- The family of inner products on the fibers -/
g : RiemannianMetric E | class | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | RiemannianBundle | Class used to create an inner product structure space on the fibers of a fiber bundle, without
creating diamonds. Use as follows:
* `instance : RiemannianBundle E := ⟨g⟩` where `g : RiemannianMetric E` registers the inner product
space on the fibers;
* `instance : RiemannianBundle E := ⟨g.toRiemannianMetric⟩` where
`g : ContinuousRiemannianMetric F E` registers the inner product space on the fibers, and the fact
that it varies continuously (i.e., a `[IsContinuousRiemannianBundle]` instance).
* `instance : RiemannianBundle E := ⟨g.toRiemannianMetric⟩` where
`g : ContMDiffRiemannianMetric IB n F E` registers the inner product space on the fibers, and the
fact that it varies smoothly (and continuously), i.e., `[IsContMDiffRiemannianBundle]` and
`[IsContinuousRiemannianBundle]` instances. |
ContinuousRiemannianMetric where
/-- The inner product along the fibers of the bundle. -/
inner (b : B) : E b →L[ℝ] E b →L[ℝ] ℝ
symm (b : B) (v w : E b) : inner b v w = inner b w v
pos (b : B) (v : E b) (hv : v ≠ 0) : 0 < inner b v v
isVonNBounded (b : B) : IsVonNBounded ℝ {v : E b | inner b v v < 1}
continuous : Continuous (fun (b : B) ↦ TotalSpace.mk' (F →L[ℝ] F →L[ℝ] ℝ) b (inner b)) | structure | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | ContinuousRiemannianMetric | A fiber in a bundle satisfying the `[RiemannianBundle E]` typeclass inherits
a `NormedAddCommGroup` structure.
The normal priority for an instance which always applies like this one should be 100.
We use 80 as this is rather specialized, so we want other paths to be tried first typically.
As this instance is quite specific and very costly because of higher-order unification, we
also scope it to the `Bundle` namespace. -/
noncomputable scoped instance (priority := 80) [h : RiemannianBundle E] (b : B) :
NormedAddCommGroup (E b) :=
(h.g.toCore b).toNormedAddCommGroupOfTopology (h.g.continuousAt b) (h.g.isVonNBounded b)
/-- A fiber in a bundle satisfying the `[RiemannianBundle E]` typeclass inherits
an `InnerProductSpace ℝ` structure.
The normal priority for an instance which always applies like this one should be 100.
We use 80 as this is rather specialized, so we want other paths to be tried first typically.
As this instance is quite specific and very costly because of higher-order unification, we
also scope it to the `Bundle` namespace. -/
noncomputable scoped instance (priority := 80) [h : RiemannianBundle E] (b : B) :
InnerProductSpace ℝ (E b) :=
.ofCoreOfTopology (h.g.toCore b) (h.g.continuousAt b) (h.g.isVonNBounded b)
variable (F E) in
/-- A family of inner product space structures on the fibers of a fiber bundle, defining the same
topology as the already existing one, and varying continuously with the base point. See also
`ContMDiffRiemannianMetric` for a smooth version.
This structure is used through `RiemannianBundle` for typeclass inference, to register the inner
product space structure on the fibers without creating diamonds. |
ContinuousRiemannianMetric.toRiemannianMetric (g : ContinuousRiemannianMetric F E) :
RiemannianMetric E where
inner := g.inner
symm := g.symm
pos := g.pos
isVonNBounded := g.isVonNBounded
continuousAt b := by
let e : E b ≃L[ℝ] F := Trivialization.continuousLinearEquivAt ℝ (trivializationAt F E b) _
(FiberBundle.mem_baseSet_trivializationAt' b)
let m : (E b →L[ℝ] E b →L[ℝ] ℝ) ≃L[ℝ] (F →L[ℝ] F →L[ℝ] ℝ) :=
e.arrowCongr (e.arrowCongr (ContinuousLinearEquiv.refl ℝ ℝ ))
have A (v : E b) : g.inner b v v = ((fun w ↦ m (g.inner b) w w) ∘ e) v := by simp [m]
simp only [A]
fun_prop | def | Topology | [
"Mathlib.Analysis.InnerProductSpace.LinearMap",
"Mathlib.Topology.VectorBundle.Constructions",
"Mathlib.Topology.VectorBundle.Hom"
] | Mathlib/Topology/VectorBundle/Riemannian.lean | ContinuousRiemannianMetric.toRiemannianMetric | A continuous Riemannian metric is in particular a Riemannian metric. |
ContinuousAlgEquiv (R A B : Type*) [CommSemiring R]
[Semiring A] [TopologicalSpace A] [Semiring B] [TopologicalSpace B] [Algebra R A]
[Algebra R B] extends A ≃ₐ[R] B, A ≃ₜ B
@[inherit_doc]
notation:50 A " ≃A[" R "] " B => ContinuousAlgEquiv R A B
attribute [nolint docBlame] ContinuousAlgEquiv.toHomeomorph | structure | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | ContinuousAlgEquiv | `ContinuousAlgEquiv R A B`, with notation `A ≃A[R] B`, is the type of bijections
between the topological `R`-algebras `A` and `B` which are both homeomorphisms
and `R`-algebra isomorphisms. |
ContinuousAlgEquivClass (F : Type*) (R A B : outParam Type*) [CommSemiring R]
[Semiring A] [TopologicalSpace A] [Semiring B] [TopologicalSpace B]
[Algebra R A] [Algebra R B] [EquivLike F A B] : Prop
extends AlgEquivClass F R A B, HomeomorphClass F A B | class | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | ContinuousAlgEquivClass | `ContinuousAlgEquivClass F R A B` states that `F` is a type of topological algebra
structure-preserving equivalences. You should extend this class when you
extend `ContinuousAlgEquiv`. |
@[coe]
toContinuousAlgHom (e : A ≃A[R] B) : A →A[R] B where
__ := e.toAlgHom
cont := e.continuous_toFun | def | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | toContinuousAlgHom | The natural coercion from a continuous algebra isomorphism to a continuous
algebra morphism. |
coe : Coe (A ≃A[R] B) (A →A[R] B) := ⟨toContinuousAlgHom⟩ | instance | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe | null |
equivLike : EquivLike (A ≃A[R] B) A B where
coe f := f.toFun
inv f := f.invFun
coe_injective' f g h₁ h₂ := by
obtain ⟨f', _⟩ := f
obtain ⟨g', _⟩ := g
rcases f' with ⟨⟨_, _⟩, _⟩
rcases g' with ⟨⟨_, _⟩, _⟩
congr
left_inv f := f.left_inv
right_inv f := f.right_inv | instance | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | equivLike | null |
continuousAlgEquivClass : ContinuousAlgEquivClass (A ≃A[R] B) R A B where
map_add f := f.map_add'
map_mul f := f.map_mul'
commutes f := f.commutes'
map_continuous := continuous_toFun
inv_continuous := continuous_invFun | instance | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | continuousAlgEquivClass | null |
coe_apply (e : A ≃A[R] B) (a : A) : (e : A →A[R] B) a = e a := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_apply | null |
coe_coe (e : A ≃A[R] B) : ⇑(e : A →A[R] B) = e := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_coe | null |
toAlgEquiv_injective : Function.Injective (toAlgEquiv : (A ≃A[R] B) → A ≃ₐ[R] B) := by
rintro ⟨e, _, _⟩ ⟨e', _, _⟩ rfl
rfl
@[ext] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | toAlgEquiv_injective | null |
ext {f g : A ≃A[R] B} (h : ⇑f = ⇑g) : f = g :=
toAlgEquiv_injective <| AlgEquiv.ext <| congr_fun h | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | ext | null |
coe_injective : Function.Injective ((↑) : (A ≃A[R] B) → A →A[R] B) :=
fun _ _ h => ext <| funext <| ContinuousAlgHom.ext_iff.1 h
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_injective | null |
coe_inj {f g : A ≃A[R] B} : (f : A →A[R] B) = g ↔ f = g :=
coe_injective.eq_iff
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_inj | null |
coe_toAlgEquiv (e : A ≃A[R] B) : ⇑e.toAlgEquiv = e := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_toAlgEquiv | null |
isOpenMap (e : A ≃A[R] B) : IsOpenMap e :=
e.toHomeomorph.isOpenMap | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | isOpenMap | null |
image_closure (e : A ≃A[R] B) (S : Set A) : e '' closure S = closure (e '' S) :=
e.toHomeomorph.image_closure S | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | image_closure | null |
preimage_closure (e : A ≃A[R] B) (S : Set B) : e ⁻¹' closure S = closure (e ⁻¹' S) :=
e.toHomeomorph.preimage_closure S
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | preimage_closure | null |
isClosed_image (e : A ≃A[R] B) {S : Set A} : IsClosed (e '' S) ↔ IsClosed S :=
e.toHomeomorph.isClosed_image | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | isClosed_image | null |
map_nhds_eq (e : A ≃A[R] B) (a : A) : Filter.map e (𝓝 a) = 𝓝 (e a) :=
e.toHomeomorph.map_nhds_eq a | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | map_nhds_eq | null |
map_eq_zero_iff (e : A ≃A[R] B) {a : A} : e a = 0 ↔ a = 0 :=
e.toAlgEquiv.toLinearEquiv.map_eq_zero_iff
attribute [continuity]
ContinuousAlgEquiv.continuous_invFun ContinuousAlgEquiv.continuous_toFun
@[fun_prop] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | map_eq_zero_iff | null |
continuous (e : A ≃A[R] B) : Continuous e := e.continuous_toFun | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | continuous | null |
continuousOn (e : A ≃A[R] B) {S : Set A} : ContinuousOn e S :=
e.continuous.continuousOn | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | continuousOn | null |
continuousAt (e : A ≃A[R] B) {a : A} : ContinuousAt e a :=
e.continuous.continuousAt | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | continuousAt | null |
continuousWithinAt (e : A ≃A[R] B) {S : Set A} {a : A} :
ContinuousWithinAt e S a :=
e.continuous.continuousWithinAt | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | continuousWithinAt | null |
comp_continuous_iff {α : Type*} [TopologicalSpace α] (e : A ≃A[R] B) {f : α → A} :
Continuous (e ∘ f) ↔ Continuous f :=
e.toHomeomorph.comp_continuous_iff | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | comp_continuous_iff | null |
comp_continuous_iff' {β : Type*} [TopologicalSpace β] (e : A ≃A[R] B) {g : B → β} :
Continuous (g ∘ e) ↔ Continuous g :=
e.toHomeomorph.comp_continuous_iff'
variable (R A) | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | comp_continuous_iff' | null |
@[refl]
refl : A ≃A[R] A where
__ := AlgEquiv.refl
continuous_toFun := continuous_id
continuous_invFun := continuous_id
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | refl | The identity isomorphism as a continuous `R`-algebra equivalence. |
refl_apply (a : A) : refl R A a = a := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | refl_apply | null |
coe_refl : refl R A = ContinuousAlgHom.id R A := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_refl | null |
coe_refl' : ⇑(refl R A) = id := rfl
variable {R A} | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_refl' | null |
@[symm]
symm (e : A ≃A[R] B) : B ≃A[R] A where
__ := e.toAlgEquiv.symm
continuous_toFun := e.continuous_invFun
continuous_invFun := e.continuous_toFun
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm | The inverse of a continuous algebra equivalence. |
apply_symm_apply (e : A ≃A[R] B) (b : B) : e (e.symm b) = b :=
e.1.right_inv b
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | apply_symm_apply | null |
symm_apply_apply (e : A ≃A[R] B) (a : A) : e.symm (e a) = a :=
e.1.left_inv a
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_apply_apply | null |
symm_image_image (e : A ≃A[R] B) (S : Set A) : e.symm '' (e '' S) = S :=
e.toEquiv.symm_image_image S
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_image_image | null |
image_symm_image (e : A ≃A[R] B) (S : Set B) : e '' (e.symm '' S) = S :=
e.symm.symm_image_image S
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | image_symm_image | null |
symm_toAlgEquiv (e : A ≃A[R] B) : e.symm.toAlgEquiv = e.toAlgEquiv.symm := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_toAlgEquiv | null |
symm_toHomeomorph (e : A ≃A[R] B) : e.symm.toHomeomorph = e.toHomeomorph.symm := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_toHomeomorph | null |
symm_map_nhds_eq (e : A ≃A[R] B) (a : A) : Filter.map e.symm (𝓝 (e a)) = 𝓝 a :=
e.toHomeomorph.symm_map_nhds_eq a | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_map_nhds_eq | null |
@[trans]
trans (e₁ : A ≃A[R] B) (e₂ : B ≃A[R] C) : A ≃A[R] C where
__ := e₁.toAlgEquiv.trans e₂.toAlgEquiv
continuous_toFun := e₂.continuous_toFun.comp e₁.continuous_toFun
continuous_invFun := e₁.continuous_invFun.comp e₂.continuous_invFun
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | trans | The composition of two continuous algebra equivalences. |
trans_toAlgEquiv (e₁ : A ≃A[R] B) (e₂ : B ≃A[R] C) :
(e₁.trans e₂).toAlgEquiv = e₁.toAlgEquiv.trans e₂.toAlgEquiv :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | trans_toAlgEquiv | null |
trans_apply (e₁ : A ≃A[R] B) (e₂ : B ≃A[R] C) (a : A) :
(e₁.trans e₂) a = e₂ (e₁ a) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | trans_apply | null |
symm_trans_apply (e₁ : B ≃A[R] A) (e₂ : C ≃A[R] B) (a : A) :
(e₂.trans e₁).symm a = e₂.symm (e₁.symm a) :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_trans_apply | null |
comp_coe (e₁ : A ≃A[R] B) (e₂ : B ≃A[R] C) :
e₂.toAlgHom.comp e₁.toAlgHom = e₁.trans e₂ := by
rfl
@[simp high] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | comp_coe | null |
coe_comp_coe_symm (e : A ≃A[R] B) :
e.toContinuousAlgHom.comp e.symm = ContinuousAlgHom.id R B :=
ContinuousAlgHom.ext e.apply_symm_apply
@[simp high] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_comp_coe_symm | null |
coe_symm_comp_coe (e : A ≃A[R] B) :
e.symm.toContinuousAlgHom.comp e = ContinuousAlgHom.id R A :=
ContinuousAlgHom.ext e.symm_apply_apply
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | coe_symm_comp_coe | null |
symm_comp_self (e : A ≃A[R] B) : (e.symm : B → A) ∘ e = id := by
exact funext <| e.symm_apply_apply
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_comp_self | null |
self_comp_symm (e : A ≃A[R] B) : (e : A → B) ∘ e.symm = id :=
funext <| e.apply_symm_apply
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | self_comp_symm | null |
symm_symm (e : A ≃A[R] B) : e.symm.symm = e := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_symm | null |
symm_bijective : Function.Bijective (symm : (A ≃A[R] B) → _) :=
Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_bijective | null |
refl_symm : (refl R A).symm = refl R A := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | refl_symm | null |
symm_symm_apply (e : A ≃A[R] B) (a : A) : e.symm.symm a = e a := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_symm_apply | null |
symm_apply_eq (e : A ≃A[R] B) {a : A} {b : B} : e.symm b = a ↔ b = e a :=
e.toEquiv.symm_apply_eq | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_apply_eq | null |
eq_symm_apply (e : A ≃A[R] B) {a : A} {b : B} : a = e.symm b ↔ e a = b :=
e.toEquiv.eq_symm_apply | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | eq_symm_apply | null |
image_eq_preimage (e : A ≃A[R] B) (S : Set A) : e '' S = e.symm ⁻¹' S :=
e.toEquiv.image_eq_preimage S | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | image_eq_preimage | null |
image_symm_eq_preimage (e : A ≃A[R] B) (S : Set B) : e.symm '' S = e ⁻¹' S := by
rw [e.symm.image_eq_preimage, e.symm_symm]
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | image_symm_eq_preimage | null |
symm_preimage_preimage (e : A ≃A[R] B) (S : Set B) : e.symm ⁻¹' (e ⁻¹' S) = S :=
e.toEquiv.symm_preimage_preimage S
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | symm_preimage_preimage | null |
preimage_symm_preimage (e : A ≃A[R] B) (S : Set A) : e ⁻¹' (e.symm ⁻¹' S) = S :=
e.symm.symm_preimage_preimage S | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | preimage_symm_preimage | null |
isUniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂] [Ring E₁]
[IsUniformAddGroup E₁] [Algebra R E₁] [Ring E₂] [IsUniformAddGroup E₂] [Algebra R E₂]
(e : E₁ ≃A[R] E₂) : IsUniformEmbedding e :=
e.toAlgEquiv.isUniformEmbedding e.toContinuousAlgHom.uniformContinuous
e.symm.toContinuousAlgHom.uniformContinuous | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | isUniformEmbedding | null |
_root_.AlgEquiv.isUniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂]
[Ring E₁] [IsUniformAddGroup E₁] [Algebra R E₁] [Ring E₂] [IsUniformAddGroup E₂] [Algebra R E₂]
(e : E₁ ≃ₐ[R] E₂) (h₁ : Continuous e) (h₂ : Continuous e.symm) :
IsUniformEmbedding e :=
ContinuousAlgEquiv.isUniformEmbedding { e with continuous_toFun := h₁ } | theorem | Topology | [
"Mathlib.Topology.Algebra.Algebra"
] | Mathlib/Topology/Algebra/Algebra/Equiv.lean | _root_.AlgEquiv.isUniformEmbedding | null |
DivisionRing.continuousConstSMul_rat {A} [DivisionRing A] [TopologicalSpace A]
[ContinuousMul A] [CharZero A] : ContinuousConstSMul ℚ A :=
⟨fun r => by simpa only [Algebra.smul_def] using continuous_const.mul continuous_id⟩ | instance | Topology | [
"Mathlib.Algebra.Algebra.Rat",
"Mathlib.Topology.Algebra.ConstMulAction",
"Mathlib.Topology.Algebra.Monoid.Defs"
] | Mathlib/Topology/Algebra/Algebra/Rat.lean | DivisionRing.continuousConstSMul_rat | The action induced by `DivisionRing.toRatAlgebra` is continuous. |
@[to_additive /-- Put the same topological space structure on `Mᵈᵃᵃ` as on the original space. -/]
instTopologicalSpace : TopologicalSpace Mᵈᵐᵃ := .induced mk.symm ‹_›
@[to_additive (attr := continuity, fun_prop)] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instTopologicalSpace | Put the same topological space structure on `Mᵈᵐᵃ` as on the original space. |
continuous_mk : Continuous (@mk M) := continuous_induced_rng.2 continuous_id
@[to_additive (attr := continuity, fun_prop)] | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | continuous_mk | null |
continuous_mk_symm : Continuous (@mk M).symm := continuous_induced_dom | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | continuous_mk_symm | null |
@[to_additive (attr := simps toEquiv) /-- `DomAddAct.mk` as a homeomorphism. -/]
mkHomeomorph : M ≃ₜ Mᵈᵐᵃ where
toEquiv := mk
@[to_additive (attr := simp)] theorem coe_mkHomeomorph : ⇑(mkHomeomorph : M ≃ₜ Mᵈᵐᵃ) = mk := rfl
@[to_additive (attr := simp)] | def | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | mkHomeomorph | `DomMulAct.mk` as a homeomorphism. |
coe_mkHomeomorph_symm : ⇑(mkHomeomorph : M ≃ₜ Mᵈᵐᵃ).symm = mk.symm := rfl
@[to_additive] theorem isInducing_mk : IsInducing (@mk M) := mkHomeomorph.isInducing
@[to_additive] theorem isEmbedding_mk : IsEmbedding (@mk M) := mkHomeomorph.isEmbedding
@[to_additive] theorem isOpenEmbedding_mk : IsOpenEmbedding (@mk M) := mkHomeomorph.isOpenEmbedding
@[to_additive] theorem isClosedEmbedding_mk : IsClosedEmbedding (@mk M) :=
mkHomeomorph.isClosedEmbedding
@[to_additive] theorem isQuotientMap_mk : IsQuotientMap (@mk M) := mkHomeomorph.isQuotientMap
@[to_additive] theorem isInducing_mk_symm : IsInducing (@mk M).symm := mkHomeomorph.symm.isInducing
@[to_additive] theorem isEmbedding_mk_symm : IsEmbedding (@mk M).symm :=
mkHomeomorph.symm.isEmbedding
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | coe_mkHomeomorph_symm | null |
isOpenEmbedding_mk_symm : IsOpenEmbedding (@mk M).symm := mkHomeomorph.symm.isOpenEmbedding
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | isOpenEmbedding_mk_symm | null |
isClosedEmbedding_mk_symm : IsClosedEmbedding (@mk M).symm :=
mkHomeomorph.symm.isClosedEmbedding
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | isClosedEmbedding_mk_symm | null |
isQuotientMap_mk_symm : IsQuotientMap (@mk M).symm := mkHomeomorph.symm.isQuotientMap
@[to_additive] instance instT0Space [T0Space M] : T0Space Mᵈᵐᵃ := mkHomeomorph.t0Space
@[to_additive] instance instT1Space [T1Space M] : T1Space Mᵈᵐᵃ := mkHomeomorph.t1Space
@[to_additive] instance instT2Space [T2Space M] : T2Space Mᵈᵐᵃ := mkHomeomorph.t2Space
@[to_additive] instance instT25Space [T25Space M] : T25Space Mᵈᵐᵃ := mkHomeomorph.t25Space
@[to_additive] instance instT3Space [T3Space M] : T3Space Mᵈᵐᵃ := mkHomeomorph.t3Space
@[to_additive] instance instT4Space [T4Space M] : T4Space Mᵈᵐᵃ := mkHomeomorph.t4Space
@[to_additive] instance instT5Space [T5Space M] : T5Space Mᵈᵐᵃ := mkHomeomorph.t5Space
@[to_additive] instance instR0Space [R0Space M] : R0Space Mᵈᵐᵃ := isEmbedding_mk_symm.r0Space
@[to_additive] instance instR1Space [R1Space M] : R1Space Mᵈᵐᵃ := isEmbedding_mk_symm.r1Space
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | isQuotientMap_mk_symm | null |
instRegularSpace [RegularSpace M] : RegularSpace Mᵈᵐᵃ := isEmbedding_mk_symm.regularSpace
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instRegularSpace | null |
instNormalSpace [NormalSpace M] : NormalSpace Mᵈᵐᵃ := mkHomeomorph.normalSpace
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instNormalSpace | null |
instCompletelyNormalSpace [CompletelyNormalSpace M] : CompletelyNormalSpace Mᵈᵐᵃ :=
isEmbedding_mk_symm.completelyNormalSpace
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instCompletelyNormalSpace | null |
instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mᵈᵐᵃ :=
isEmbedding_mk_symm.discreteTopology
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instDiscreteTopology | null |
instSeparableSpace [SeparableSpace M] : SeparableSpace Mᵈᵐᵃ :=
isQuotientMap_mk.separableSpace
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instSeparableSpace | null |
instFirstCountableTopology [FirstCountableTopology M] : FirstCountableTopology Mᵈᵐᵃ :=
isInducing_mk_symm.firstCountableTopology
@[to_additive] | instance | Topology | [
"Mathlib.Topology.Homeomorph.Lemmas",
"Mathlib.GroupTheory.GroupAction.DomAct.Basic"
] | Mathlib/Topology/Algebra/Constructions/DomMulAct.lean | instFirstCountableTopology | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.