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 ⌀ |
|---|---|---|---|---|---|---|
mem_localTrivAsPartialEquiv_source (p : Z.TotalSpace) :
p ∈ (Z.localTrivAsPartialEquiv i).source ↔ p.1 ∈ Z.baseSet i :=
Iff.rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTrivAsPartialEquiv_source | null |
mem_localTrivAsPartialEquiv_target (p : B × F) :
p ∈ (Z.localTrivAsPartialEquiv i).target ↔ p.1 ∈ Z.baseSet i := by
rw [localTrivAsPartialEquiv, mem_prod]
simp only [and_true, mem_univ] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTrivAsPartialEquiv_target | null |
localTrivAsPartialEquiv_apply (p : Z.TotalSpace) :
(Z.localTrivAsPartialEquiv i) p = ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩ :=
rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_apply | null |
localTrivAsPartialEquiv_trans (i j : ι) :
(Z.localTrivAsPartialEquiv i).symm.trans (Z.localTrivAsPartialEquiv j) ≈
(Z.trivChange i j).toPartialEquiv := by
constructor
· ext x
simp only [mem_localTrivAsPartialEquiv_target, mfld_simps]
rfl
· rintro ⟨x, v⟩ hx
simp only [trivChange, localTrivAsP... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_trans | The composition of two local trivializations is the trivialization change Z.triv_change i j. |
toTopologicalSpace : TopologicalSpace (Bundle.TotalSpace F Z.Fiber) :=
TopologicalSpace.generateFrom <| ⋃ (i : ι) (s : Set (B × F)) (_ : IsOpen s),
{(Z.localTrivAsPartialEquiv i).source ∩ Z.localTrivAsPartialEquiv i ⁻¹' s}
variable (b : B) (a : F) | instance | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | toTopologicalSpace | Topological structure on the total space of a fiber bundle created from core, designed so
that all the local trivialization are continuous. |
open_source' (i : ι) : IsOpen (Z.localTrivAsPartialEquiv i).source := by
apply TopologicalSpace.GenerateOpen.basic
simp only [exists_prop, mem_iUnion, mem_singleton_iff]
refine ⟨i, Z.baseSet i ×ˢ univ, (Z.isOpen_baseSet i).prod isOpen_univ, ?_⟩
ext p
simp only [localTrivAsPartialEquiv_apply, prodMk_mem_set_pr... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | open_source' | null |
localTriv (i : ι) : Trivialization F Z.proj where
baseSet := Z.baseSet i
open_baseSet := Z.isOpen_baseSet i
source_eq := rfl
target_eq := rfl
proj_toFun p _ := by
simp only [mfld_simps]
rfl
open_source := Z.open_source' i
open_target := (Z.isOpen_baseSet i).prod isOpen_univ
continuousOn_toFun :=... | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTriv | Extended version of the local trivialization of a fiber bundle constructed from core,
registering additionally in its type that it is a local bundle trivialization. |
localTrivAt (b : B) : Trivialization F (π F Z.Fiber) :=
Z.localTriv (Z.indexAt b)
@[simp, mfld_simps] | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAt | Preferred local trivialization of a fiber bundle constructed from core, at a given point, as
a bundle trivialization |
localTrivAt_def (b : B) : Z.localTriv (Z.indexAt b) = Z.localTrivAt b :=
rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAt_def | null |
localTrivAt_snd (b : B) (p) :
(Z.localTrivAt b p).2 = Z.coordChange (Z.indexAt p.1) (Z.indexAt b) p.1 p.2 :=
rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAt_snd | null |
continuous_const_section (v : F)
(h : ∀ i j, ∀ x ∈ Z.baseSet i ∩ Z.baseSet j, Z.coordChange i j x v = v) :
Continuous (show B → Z.TotalSpace from fun x => ⟨x, v⟩) := by
refine continuous_iff_continuousAt.2 fun x => ?_
have A : Z.baseSet (Z.indexAt x) ∈ 𝓝 x :=
IsOpen.mem_nhds (Z.isOpen_baseSet (Z.indexA... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_const_section | If an element of `F` is invariant under all coordinate changes, then one can define a
corresponding section of the fiber bundle, which is continuous. This applies in particular to the
zero section of a vector bundle. Another example (not yet defined) would be the identity
section of the endomorphism bundle of a vector ... |
localTrivAsPartialEquiv_coe : ⇑(Z.localTrivAsPartialEquiv i) = Z.localTriv i :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_coe | null |
localTrivAsPartialEquiv_source :
(Z.localTrivAsPartialEquiv i).source = (Z.localTriv i).source :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_source | null |
localTrivAsPartialEquiv_target :
(Z.localTrivAsPartialEquiv i).target = (Z.localTriv i).target :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_target | null |
localTrivAsPartialEquiv_symm :
(Z.localTrivAsPartialEquiv i).symm = (Z.localTriv i).toPartialEquiv.symm :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAsPartialEquiv_symm | null |
baseSet_at : Z.baseSet i = (Z.localTriv i).baseSet :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | baseSet_at | null |
localTriv_apply (p : Z.TotalSpace) :
(Z.localTriv i) p = ⟨p.1, Z.coordChange (Z.indexAt p.1) i p.1 p.2⟩ :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTriv_apply | null |
localTrivAt_apply (p : Z.TotalSpace) : (Z.localTrivAt p.1) p = ⟨p.1, p.2⟩ := by
rw [localTrivAt, localTriv_apply, coordChange_self]
exact Z.mem_baseSet_at p.1
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAt_apply | null |
localTrivAt_apply_mk (b : B) (a : F) : (Z.localTrivAt b) ⟨b, a⟩ = ⟨b, a⟩ :=
Z.localTrivAt_apply _
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTrivAt_apply_mk | null |
mem_localTriv_source (p : Z.TotalSpace) :
p ∈ (Z.localTriv i).source ↔ p.1 ∈ (Z.localTriv i).baseSet :=
Iff.rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTriv_source | null |
mem_localTrivAt_source (p : Z.TotalSpace) (b : B) :
p ∈ (Z.localTrivAt b).source ↔ p.1 ∈ (Z.localTrivAt b).baseSet :=
Iff.rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTrivAt_source | null |
mem_localTriv_target (p : B × F) :
p ∈ (Z.localTriv i).target ↔ p.1 ∈ (Z.localTriv i).baseSet :=
Trivialization.mem_target _
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTriv_target | null |
mem_localTrivAt_target (p : B × F) (b : B) :
p ∈ (Z.localTrivAt b).target ↔ p.1 ∈ (Z.localTrivAt b).baseSet :=
Trivialization.mem_target _
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTrivAt_target | null |
localTriv_symm_apply (p : B × F) :
(Z.localTriv i).toOpenPartialHomeomorph.symm p =
⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | localTriv_symm_apply | null |
mem_localTrivAt_baseSet (b : B) : b ∈ (Z.localTrivAt b).baseSet := by
rw [localTrivAt, ← baseSet_at]
exact Z.mem_baseSet_at b | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_localTrivAt_baseSet | null |
mk_mem_localTrivAt_source : (⟨b, a⟩ : Z.TotalSpace) ∈ (Z.localTrivAt b).source := by
simp only [mfld_simps] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mk_mem_localTrivAt_source | null |
fiberBundle : FiberBundle F Z.Fiber where
totalSpaceMk_isInducing' b := isInducing_iff_nhds.2 fun x ↦ by
rw [(Z.localTrivAt b).nhds_eq_comap_inf_principal (mk_mem_localTrivAt_source _ _ _), comap_inf,
comap_principal, comap_comap]
simp only [Function.comp_def, localTrivAt_apply_mk, Trivialization.coe_co... | instance | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | fiberBundle | A fiber bundle constructed from core is indeed a fiber bundle. |
@[continuity]
continuous_totalSpaceMk (b : B) :
Continuous (TotalSpace.mk b : Z.Fiber b → Bundle.TotalSpace F Z.Fiber) :=
FiberBundle.continuous_totalSpaceMk F Z.Fiber b | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_totalSpaceMk | The inclusion of a fiber into the total space is a continuous map. |
FiberPrebundle where
pretrivializationAtlas : Set (Pretrivialization F (π F E))
pretrivializationAt : B → Pretrivialization F (π F E)
mem_base_pretrivializationAt : ∀ x : B, x ∈ (pretrivializationAt x).baseSet
pretrivialization_mem_atlas : ∀ x : B, pretrivializationAt x ∈ pretrivializationAtlas
continuous_tri... | structure | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | FiberPrebundle | The projection on the base of a fiber bundle created from core is continuous -/
nonrec theorem continuous_proj : Continuous Z.proj :=
FiberBundle.continuous_proj F Z.Fiber
/-- The projection on the base of a fiber bundle created from core is an open map -/
nonrec theorem isOpenMap_proj : IsOpenMap Z.proj :=
FiberB... |
totalSpaceTopology (a : FiberPrebundle F E) : TopologicalSpace (TotalSpace F E) :=
⨆ (e : Pretrivialization F (π F E)) (_ : e ∈ a.pretrivializationAtlas),
coinduced e.setSymm instTopologicalSpaceSubtype | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | totalSpaceTopology | Topology on the total space that will make the prebundle into a bundle. |
continuous_symm_of_mem_pretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
@ContinuousOn _ _ _ a.totalSpaceTopology e.toPartialEquiv.symm e.target := by
refine fun z H U h => preimage_nhdsWithin_coinduced' H (le_def.1 (nhds_mono ?_) U h)
exact le_iSup₂ (α := TopologicalSpace (TotalSpace F E)) e he | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_symm_of_mem_pretrivializationAtlas | null |
isOpen_source (e : Pretrivialization F (π F E)) :
IsOpen[a.totalSpaceTopology] e.source := by
refine isOpen_iSup_iff.mpr fun e' => isOpen_iSup_iff.mpr fun _ => ?_
refine isOpen_coinduced.mpr (isOpen_induced_iff.mpr ⟨e.target, e.open_target, ?_⟩)
ext ⟨x, hx⟩
simp only [mem_preimage, Pretrivialization.setSymm... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | isOpen_source | null |
isOpen_target_of_mem_pretrivializationAtlas_inter (e e' : Pretrivialization F (π F E))
(he' : e' ∈ a.pretrivializationAtlas) :
IsOpen (e'.toPartialEquiv.target ∩ e'.toPartialEquiv.symm ⁻¹' e.source) := by
letI := a.totalSpaceTopology
obtain ⟨u, hu1, hu2⟩ := continuousOn_iff'.mp (a.continuous_symm_of_mem_pre... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | isOpen_target_of_mem_pretrivializationAtlas_inter | null |
trivializationOfMemPretrivializationAtlas (he : e ∈ a.pretrivializationAtlas) :
@Trivialization B F _ _ _ a.totalSpaceTopology (π F E) :=
let _ := a.totalSpaceTopology
{ e with
open_source := a.isOpen_source e,
continuousOn_toFun := by
refine continuousOn_iff'.mpr fun s hs => ⟨e ⁻¹' s ∩ e.source,
... | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | trivializationOfMemPretrivializationAtlas | Promotion from a `Pretrivialization` to a `Trivialization`. |
mem_pretrivializationAt_source (b : B) (x : E b) :
⟨b, x⟩ ∈ (a.pretrivializationAt b).source := by
simp only [(a.pretrivializationAt b).source_eq, mem_preimage]
exact a.mem_base_pretrivializationAt b
@[simp] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | mem_pretrivializationAt_source | null |
totalSpaceMk_preimage_source (b : B) :
TotalSpace.mk b ⁻¹' (a.pretrivializationAt b).source = univ :=
eq_univ_of_forall (a.mem_pretrivializationAt_source b)
@[continuity] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | totalSpaceMk_preimage_source | null |
continuous_totalSpaceMk (b : B) :
Continuous[_, a.totalSpaceTopology] (TotalSpace.mk b) := by
letI := a.totalSpaceTopology
let e := a.trivializationOfMemPretrivializationAtlas (a.pretrivialization_mem_atlas b)
rw [e.toOpenPartialHomeomorph.continuous_iff_continuous_comp_left
(a.totalSpaceMk_preimage_sou... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_totalSpaceMk | null |
inducing_totalSpaceMk_of_inducing_comp (b : B)
(h : IsInducing (a.pretrivializationAt b ∘ TotalSpace.mk b)) :
@IsInducing _ _ _ a.totalSpaceTopology (TotalSpace.mk b) := by
letI := a.totalSpaceTopology
rw [← restrict_comp_codRestrict (a.mem_pretrivializationAt_source b)] at h
apply IsInducing.of_codRestri... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | inducing_totalSpaceMk_of_inducing_comp | null |
toFiberBundle : @FiberBundle B F _ _ E a.totalSpaceTopology _ :=
let _ := a.totalSpaceTopology
{ totalSpaceMk_isInducing' := fun b ↦ a.inducing_totalSpaceMk_of_inducing_comp b
(a.totalSpaceMk_isInducing b)
trivializationAtlas' :=
{ e | ∃ (e₀ : _) (he₀ : e₀ ∈ a.pretrivializationAtlas),
e = a.... | def | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | toFiberBundle | Make a `FiberBundle` from a `FiberPrebundle`. Concretely this means
that, given a `FiberPrebundle` structure for a sigma-type `E` -- which consists of a
number of "pretrivializations" identifying parts of `E` with product spaces `U × F` -- one
establishes that for the topology constructed on the sigma-type using
`Fibe... |
continuous_proj : @Continuous _ _ a.totalSpaceTopology _ (π F E) := by
letI := a.totalSpaceTopology
letI := a.toFiberBundle
exact FiberBundle.continuous_proj F E | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuous_proj | null |
continuousOn_of_comp_right {X : Type*} [TopologicalSpace X] {f : TotalSpace F E → X}
{s : Set B} (hs : IsOpen s) (hf : ∀ b ∈ s,
ContinuousOn (f ∘ (a.pretrivializationAt b).toPartialEquiv.symm)
((s ∩ (a.pretrivializationAt b).baseSet) ×ˢ (Set.univ : Set F))) :
@ContinuousOn _ _ a.totalSpaceTopology... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Trivialization",
"Mathlib.Topology.Order.LeftRightNhds"
] | Mathlib/Topology/FiberBundle/Basic.lean | continuousOn_of_comp_right | For a fiber bundle `E` over `B` constructed using the `FiberPrebundle` mechanism,
continuity of a function `TotalSpace F E → X` on an open set `s` can be checked by precomposing at
each point with the pretrivialization used for the construction at that point. |
topologicalSpace [t₁ : TopologicalSpace B]
[t₂ : TopologicalSpace F] : TopologicalSpace (TotalSpace F (Trivial B F)) :=
induced TotalSpace.proj t₁ ⊓ induced (TotalSpace.trivialSnd B F) t₂
variable [TopologicalSpace B] [TopologicalSpace F] | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | topologicalSpace | null |
isInducing_toProd : IsInducing (TotalSpace.toProd B F) :=
⟨by simp only [instTopologicalSpaceProd, induced_inf, induced_compose]; rfl⟩ | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | isInducing_toProd | null |
@[simps!]
homeomorphProd : TotalSpace F (Trivial B F) ≃ₜ B × F :=
(TotalSpace.toProd _ _).toHomeomorphOfIsInducing (isInducing_toProd B F) | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | homeomorphProd | Homeomorphism between the total space of the trivial bundle and the Cartesian product. |
@[simps!]
trivialization : Trivialization F (π F (Bundle.Trivial B F)) where
toOpenPartialHomeomorph := (homeomorphProd B F).toOpenPartialHomeomorph
baseSet := univ
open_baseSet := isOpen_univ
source_eq := rfl
target_eq := univ_prod_univ.symm
proj_toFun _ _ := rfl
@[simp] lemma trivialization_symm_apply [Ze... | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | trivialization | Local trivialization for trivial bundle. |
@[simps] fiberBundle : FiberBundle F (Bundle.Trivial B F) where
trivializationAtlas' := {trivialization B F}
trivializationAt' _ := trivialization B F
mem_baseSet_trivializationAt' := mem_univ
trivialization_mem_atlas' _ := mem_singleton _
totalSpaceMk_isInducing' _ := (homeomorphProd B F).symm.isInducing.com... | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | fiberBundle | Fiber bundle instance on the trivial bundle. |
eq_trivialization (e : Trivialization F (π F (Bundle.Trivial B F)))
[i : MemTrivializationAtlas e] : e = trivialization B F := i.out | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | eq_trivialization | null |
FiberBundle.Prod.topologicalSpace : TopologicalSpace (TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)) :=
TopologicalSpace.induced
(fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace F₁ E₁), (⟨p.1, p.2.2⟩ : TotalSpace F₂ E₂)))
inferInstance | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | FiberBundle.Prod.topologicalSpace | Equip the total space of the fiberwise product of two fiber bundles `E₁`, `E₂` with
the induced topology from the diagonal embedding into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂`. |
FiberBundle.Prod.isInducing_diag :
IsInducing (fun p ↦ (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂) :=
⟨rfl⟩ | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | FiberBundle.Prod.isInducing_diag | The diagonal map from the total space of the fiberwise product of two fiber bundles
`E₁`, `E₂` into `TotalSpace F₁ E₁ × TotalSpace F₂ E₂` is an inducing map. |
Prod.toFun' : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → B × F₁ × F₂ :=
fun p ↦ ⟨p.1, (e₁ ⟨p.1, p.2.1⟩).2, (e₂ ⟨p.1, p.2.2⟩).2⟩
variable {e₁ e₂} | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.toFun' | Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the forward
function for the construction `Trivialization.prod`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`. |
Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
(π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) := by
let f₁ : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂ :=
fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace F₁ E₁), (⟨p.1, p.2.2⟩ : TotalSpace F₂ E₂))
let f₂ : TotalSpace F₁ E₁ × ... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.continuous_to_fun | null |
noncomputable Prod.invFun' (p : B × F₁ × F₂) : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) :=
⟨p.1, e₁.symm p.1 p.2.1, e₂.symm p.1 p.2.2⟩
variable {e₁ e₂} | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.invFun' | Given trivializations `e₁`, `e₂` for fiber bundles `E₁`, `E₂` over a base `B`, the inverse
function for the construction `Trivialization.prod`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`. |
Prod.left_inv {x : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)}
(h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x := by
obtain ⟨x, v₁, v₂⟩ := x
obtain ⟨h₁ : x ∈ e₁.baseSet, h₂ : x ∈ e₂.baseSet⟩ := h
simp only [Prod.toFun', Prod.invFun', symm_apply_apply_mk, ... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.left_inv | null |
Prod.right_inv {x : B × F₁ × F₂}
(h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x := by
obtain ⟨x, w₁, w₂⟩ := x
obtain ⟨⟨h₁ : x ∈ e₁.baseSet, h₂ : x ∈ e₂.baseSet⟩, -⟩ := h
simp only [Prod.toFun', Prod.invFun', apply_mk_symm, h₁, h₂] | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.right_inv | null |
Prod.continuous_inv_fun :
ContinuousOn (Prod.invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ) := by
rw [(Prod.isInducing_diag F₁ E₁ F₂ E₂).continuousOn_iff]
have H₁ : Continuous fun p : B × F₁ × F₂ ↦ ((p.1, p.2.1), (p.1, p.2.2)) := by fun_prop
refine (e₁.continuousOn_symm.prodMap e₂.continuousOn_symm).comp ... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Prod.continuous_inv_fun | null |
@[simps!]
noncomputable prod : Trivialization (F₁ × F₂) (π (F₁ × F₂) (E₁ ×ᵇ E₂)) where
toFun := Prod.toFun' e₁ e₂
invFun := Prod.invFun' e₁ e₂
source := π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)
target := (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ
map_source' _ h := ⟨h, Set.mem_univ _⟩
map_target' _ h... | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | prod | Given trivializations `e₁`, `e₂` for bundle types `E₁`, `E₂` over a base `B`, the induced
trivialization for the fiberwise product of `E₁` and `E₂`, whose base set is
`e₁.baseSet ∩ e₂.baseSet`. |
prod_symm_apply (x : B) (w₁ : F₁) (w₂ : F₂) :
(prod e₁ e₂).toPartialEquiv.symm (x, w₁, w₂) = ⟨x, e₁.symm x w₁, e₂.symm x w₂⟩ := rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | prod_symm_apply | null |
@[simps] noncomputable FiberBundle.prod : FiberBundle (F₁ × F₂) (E₁ ×ᵇ E₂) where
totalSpaceMk_isInducing' b := by
rw [← (Prod.isInducing_diag F₁ E₁ F₂ E₂).of_comp_iff]
exact (totalSpaceMk_isInducing F₁ E₁ b).prodMap (totalSpaceMk_isInducing F₂ E₂ b)
trivializationAtlas' := { e |
∃ (e₁ : Trivialization F... | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | FiberBundle.prod | The product of two fiber bundles is a fiber bundle. |
Pullback.TotalSpace.topologicalSpace : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
pullbackTopology F E f | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Pullback.TotalSpace.topologicalSpace | Definition of `Pullback.TotalSpace.topologicalSpace`, which we make irreducible. -/
irreducible_def pullbackTopology : TopologicalSpace (TotalSpace F (f *ᵖ E)) :=
induced TotalSpace.proj ‹TopologicalSpace B'› ⊓
induced (Pullback.lift f) ‹TopologicalSpace (TotalSpace F E)›
/-- The topology on the total space of a... |
Pullback.continuous_proj (f : B' → B) : Continuous (π F (f *ᵖ E)) := by
rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
exact inf_le_left | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Pullback.continuous_proj | null |
Pullback.continuous_lift (f : B' → B) : Continuous (@Pullback.lift B F E B' f) := by
rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
exact inf_le_right | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Pullback.continuous_lift | null |
inducing_pullbackTotalSpaceEmbedding (f : B' → B) :
IsInducing (@pullbackTotalSpaceEmbedding B F E B' f) := by
constructor
simp_rw [instTopologicalSpaceProd, induced_inf, induced_compose,
Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
rfl | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | inducing_pullbackTotalSpaceEmbedding | null |
Pullback.continuous_totalSpaceMk [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
{f : B' → B} {x : B'} : Continuous (@TotalSpace.mk _ F (f *ᵖ E) x) := by
simp only [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, induced_compose,
induced_inf, Function.comp_def, induced_const, top_inf_eq, pull... | theorem | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Pullback.continuous_totalSpaceMk | null |
@[simps]
noncomputable Trivialization.pullback (e : Trivialization F (π F E)) (f : K) :
Trivialization F (π F ((f : B' → B) *ᵖ E)) where
toFun z := (z.proj, (e (Pullback.lift f z)).2)
invFun y := @TotalSpace.mk _ F (f *ᵖ E) y.1 (e.symm (f y.1) y.2)
source := Pullback.lift f ⁻¹' e.source
baseSet := f ⁻¹' e.b... | def | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | Trivialization.pullback | A fiber bundle trivialization can be pulled back to a trivialization on the pullback bundle. |
noncomputable FiberBundle.pullback [∀ x, TopologicalSpace (E x)] [FiberBundle F E]
(f : K) : FiberBundle F ((f : B' → B) *ᵖ E) where
totalSpaceMk_isInducing' x :=
(totalSpaceMk_isInducing F E (f x)).of_comp (Pullback.continuous_totalSpaceMk F E)
(Pullback.continuous_lift F E f)
trivializationAtlas' :=... | instance | Topology | [
"Mathlib.Topology.FiberBundle.Basic"
] | Mathlib/Topology/FiberBundle/Constructions.lean | FiberBundle.pullback | null |
IsHomeomorphicTrivialFiberBundle (proj : Z → B) : Prop :=
∃ e : Z ≃ₜ B × F, ∀ x, (e x).1 = proj x | def | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | IsHomeomorphicTrivialFiberBundle | A trivial fiber bundle with fiber `F` over a base `B` is a space `Z`
projecting on `B` for which there exists a homeomorphism to `B × F` that sends `proj`
to `Prod.fst`. |
protected proj_eq (h : IsHomeomorphicTrivialFiberBundle F proj) :
∃ e : Z ≃ₜ B × F, proj = Prod.fst ∘ e :=
⟨h.choose, (funext h.choose_spec).symm⟩ | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | proj_eq | null |
protected surjective_proj [Nonempty F] (h : IsHomeomorphicTrivialFiberBundle F proj) :
Function.Surjective proj := by
obtain ⟨e, rfl⟩ := h.proj_eq
exact Prod.fst_surjective.comp e.surjective | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | surjective_proj | The projection from a trivial fiber bundle to its base is surjective. |
protected continuous_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
Continuous proj := by
obtain ⟨e, rfl⟩ := h.proj_eq; exact continuous_fst.comp e.continuous | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | continuous_proj | The projection from a trivial fiber bundle to its base is continuous. |
protected isOpenMap_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
IsOpenMap proj := by
obtain ⟨e, rfl⟩ := h.proj_eq; exact isOpenMap_fst.comp e.isOpenMap | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | isOpenMap_proj | The projection from a trivial fiber bundle to its base is open. |
protected isQuotientMap_proj [Nonempty F] (h : IsHomeomorphicTrivialFiberBundle F proj) :
IsQuotientMap proj :=
h.isOpenMap_proj.isQuotientMap h.continuous_proj h.surjective_proj | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | isQuotientMap_proj | The projection from a trivial fiber bundle to its base is open. |
isHomeomorphicTrivialFiberBundle_fst :
IsHomeomorphicTrivialFiberBundle F (Prod.fst : B × F → B) :=
⟨Homeomorph.refl _, fun _x => rfl⟩ | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | isHomeomorphicTrivialFiberBundle_fst | The first projection in a product is a trivial fiber bundle. |
isHomeomorphicTrivialFiberBundle_snd :
IsHomeomorphicTrivialFiberBundle F (Prod.snd : F × B → B) :=
⟨Homeomorph.prodComm _ _, fun _x => rfl⟩ | theorem | Topology | [
"Mathlib.Topology.Constructions.SumProd"
] | Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean | isHomeomorphicTrivialFiberBundle_snd | The second projection in a product is a trivial fiber bundle. |
Pretrivialization (proj : Z → B) extends PartialEquiv Z (B × F) where
open_target : IsOpen target
baseSet : Set B
open_baseSet : IsOpen baseSet
source_eq : source = proj ⁻¹' baseSet
target_eq : target = baseSet ×ˢ univ
proj_toFun : ∀ p ∈ source, (toFun p).1 = proj p | structure | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | Pretrivialization | This structure contains the information left for a local trivialization (which is implemented
below as `Trivialization F proj`) if the total space has not been given a topology, but we
have a topology on both the fiber and the base space. Through the construction
`topological_fiber_prebundle F proj` it will be possible... |
@[coe] toFun' : Z → (B × F) := e.toFun | def | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | toFun' | Coercion of a pretrivialization to a function. We don't use `e.toFun` in the `CoeFun` instance
because it is actually `e.toPartialEquiv.toFun`, so `simp` will apply lemmas about
`toPartialEquiv`. While we may want to switch to this behavior later, doing it mid-port will break a
lot of proofs. |
@[ext]
ext' (e e' : Pretrivialization F proj) (h₁ : e.toPartialEquiv = e'.toPartialEquiv)
(h₂ : e.baseSet = e'.baseSet) : e = e' := by
cases e; cases e'; congr | lemma | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | ext' | null |
ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
(h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
e = e' := by
ext1 <;> [ext1; exact h₃]
· apply h₁
· apply h₂
· rw [e.source_eq, e'.source_eq, h₃] | lemma | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | ext | null |
toPartialEquiv_injective [Nonempty F] :
Injective (toPartialEquiv : Pretrivialization F proj → PartialEquiv Z (B × F)) := by
refine fun e e' h ↦ ext' _ _ h ?_
simpa only [fst_image_prod, univ_nonempty, target_eq]
using congr_arg (Prod.fst '' PartialEquiv.target ·) h
@[simp, mfld_simps] | lemma | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | toPartialEquiv_injective | If the fiber is nonempty, then the projection also is. |
coe_coe : ⇑e.toPartialEquiv = e :=
rfl
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | coe_coe | null |
coe_fst (ex : x ∈ e.source) : (e x).1 = proj x :=
e.proj_toFun x ex | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | coe_fst | null |
mem_source : x ∈ e.source ↔ proj x ∈ e.baseSet := by rw [e.source_eq, mem_preimage] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | mem_source | null |
coe_fst' (ex : proj x ∈ e.baseSet) : (e x).1 = proj x :=
e.coe_fst (e.mem_source.2 ex) | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | coe_fst' | null |
protected eqOn : EqOn (Prod.fst ∘ e) proj e.source := fun _ hx => e.coe_fst hx | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | eqOn | null |
mk_proj_snd (ex : x ∈ e.source) : (proj x, (e x).2) = e x :=
Prod.ext (e.coe_fst ex).symm rfl | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | mk_proj_snd | null |
mk_proj_snd' (ex : proj x ∈ e.baseSet) : (proj x, (e x).2) = e x :=
Prod.ext (e.coe_fst' ex).symm rfl | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | mk_proj_snd' | null |
setSymm : e.target → Z :=
e.target.restrict e.toPartialEquiv.symm | def | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | setSymm | Composition of inverse and coercion from the subtype of the target. |
mem_target {x : B × F} : x ∈ e.target ↔ x.1 ∈ e.baseSet := by
rw [e.target_eq, prod_univ, mem_preimage] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | mem_target | null |
proj_symm_apply {x : B × F} (hx : x ∈ e.target) : proj (e.toPartialEquiv.symm x) = x.1 := by
have := (e.coe_fst (e.map_target hx)).symm
rwa [← e.coe_coe, e.right_inv hx] at this | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | proj_symm_apply | null |
proj_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
proj (e.toPartialEquiv.symm (b, x)) = b :=
e.proj_symm_apply (e.mem_target.2 hx) | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | proj_symm_apply' | null |
proj_surjOn_baseSet [Nonempty F] : Set.SurjOn proj e.source e.baseSet := fun b hb =>
let ⟨y⟩ := ‹Nonempty F›
⟨e.toPartialEquiv.symm (b, y), e.toPartialEquiv.map_target <| e.mem_target.2 hb,
e.proj_symm_apply' hb⟩ | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | proj_surjOn_baseSet | null |
apply_symm_apply {x : B × F} (hx : x ∈ e.target) : e (e.toPartialEquiv.symm x) = x :=
e.toPartialEquiv.right_inv hx | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | apply_symm_apply | null |
apply_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
e (e.toPartialEquiv.symm (b, x)) = (b, x) :=
e.apply_symm_apply (e.mem_target.2 hx) | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | apply_symm_apply' | null |
symm_apply_apply {x : Z} (hx : x ∈ e.source) : e.toPartialEquiv.symm (e x) = x :=
e.toPartialEquiv.left_inv hx
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | symm_apply_apply | null |
symm_apply_mk_proj {x : Z} (ex : x ∈ e.source) :
e.toPartialEquiv.symm (proj x, (e x).2) = x := by
rw [← e.coe_fst ex, ← e.coe_coe, e.left_inv ex]
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | symm_apply_mk_proj | null |
preimage_symm_proj_baseSet :
e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target := by
refine inter_eq_right.mpr fun x hx => ?_
simp only [mem_preimage, e.proj_symm_apply hx]
exact e.mem_target.mp hx
@[simp, mfld_simps] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | preimage_symm_proj_baseSet | null |
preimage_symm_proj_inter (s : Set B) :
e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
ext ⟨x, y⟩
suffices x ∈ e.baseSet → (proj (e.toPartialEquiv.symm (x, y)) ∈ s ↔ x ∈ s) by
simpa only [prodMk_mem_set_prod_eq, mem_inter_iff, and_true, mem_univ, and_congr_left_iff... | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | preimage_symm_proj_inter | null |
target_inter_preimage_symm_source_eq (e f : Pretrivialization F proj) :
f.target ∩ f.toPartialEquiv.symm ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ := by
rw [inter_comm, f.target_eq, e.source_eq, f.preimage_symm_proj_inter] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | target_inter_preimage_symm_source_eq | null |
trans_source (e f : Pretrivialization F proj) :
(f.toPartialEquiv.symm.trans e.toPartialEquiv).source = (e.baseSet ∩ f.baseSet) ×ˢ univ := by
rw [PartialEquiv.trans_source, PartialEquiv.symm_source, e.target_inter_preimage_symm_source_eq] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | trans_source | null |
symm_trans_symm (e e' : Pretrivialization F proj) :
(e.toPartialEquiv.symm.trans e'.toPartialEquiv).symm
= e'.toPartialEquiv.symm.trans e.toPartialEquiv := by
rw [PartialEquiv.trans_symm_eq_symm_trans_symm, PartialEquiv.symm_symm] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | symm_trans_symm | null |
symm_trans_source_eq (e e' : Pretrivialization F proj) :
(e.toPartialEquiv.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ := by
rw [PartialEquiv.trans_source, e'.source_eq, PartialEquiv.symm_source, e.target_eq, inter_comm,
e.preimage_symm_proj_inter, inter_comm] | theorem | Topology | [
"Mathlib.Data.Bundle",
"Mathlib.Data.Set.Image",
"Mathlib.Topology.CompactOpen",
"Mathlib.Topology.OpenPartialHomeomorph",
"Mathlib.Topology.Order.Basic"
] | Mathlib/Topology/FiberBundle/Trivialization.lean | symm_trans_source_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.