File: Mathlib/Topology/FiberBundle/Trivialization.lean

full_name: Pretrivialization
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: Type (max (max u_2 u_3) u_5)

full_name: Pretrivialization.baseSet
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: Set B

full_name: Pretrivialization.open_baseSet
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: IsOpen self.baseSet

full_name: Pretrivialization.source_eq
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: self.source = proj ⁻¹' self.baseSet

full_name: Pretrivialization.open_target
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: IsOpen self.target

full_name: Pretrivialization.proj_toFun
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: p ∈ self.source → (↑self.toPartialEquiv p).1 = proj p

full_name: Pretrivialization.target_eq
code: /-- 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 to promote a
`Pretrivialization F proj` to a `Trivialization F proj`. -/
structure 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
goal: self.target = self.baseSet ×ˢ Set.univ

full_name: Pretrivialization.toFun'
code: /-- 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.  -/
@[coe] def toFun' : Z → (B × F) 
goal: Z → B × F

full_name: Pretrivialization.instCoeFunForallProd
code: instance : CoeFun (Pretrivialization F proj) fun _ => Z → B × F 
goal: CoeFun (Pretrivialization F proj) fun x => Z → B × F

full_name: Pretrivialization.ext'
code: @[ext]
lemma ext' (e e' : Pretrivialization F proj) (h₁ : e.toPartialEquiv = e'.toPartialEquiv)
    (h₂ : e.baseSet = e'.baseSet) : e = e' 
goal: e = e'

full_name: Pretrivialization.ext
code: lemma 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' 
goal: e = e'

full_name: Pretrivialization.toPartialEquiv_injective
code: /-- If the fiber is nonempty, then the projection also is. -/
lemma toPartialEquiv_injective [Nonempty F] :
    Injective (toPartialEquiv : Pretrivialization F proj → PartialEquiv Z (B × F)) 
goal: Function.Injective Pretrivialization.toPartialEquiv

full_name: Pretrivialization.coe_coe
code: @[simp, mfld_simps]
theorem coe_coe : ⇑e.toPartialEquiv = e 
goal: ↑e.toPartialEquiv = ↑e

full_name: Pretrivialization.coe_fst
code: @[simp, mfld_simps]
theorem coe_fst (ex : x ∈ e.source) : (e x).1 = proj x 
goal: (↑e x).1 = proj x

full_name: Pretrivialization.mem_source
code: theorem mem_source : x ∈ e.source ↔ proj x ∈ e.baseSet 
goal: x ∈ e.source ↔ proj x ∈ e.baseSet

full_name: Pretrivialization.coe_fst'
code: theorem coe_fst' (ex : proj x ∈ e.baseSet) : (e x).1 = proj x 
goal: (↑e x).1 = proj x

full_name: Pretrivialization.eqOn
code: protected theorem eqOn : EqOn (Prod.fst ∘ e) proj e.source 
goal: Set.EqOn (Prod.fst ∘ ↑e) proj e.source

full_name: Pretrivialization.mk_proj_snd
code: theorem mk_proj_snd (ex : x ∈ e.source) : (proj x, (e x).2) = e x 
goal: (proj x, (↑e x).2) = ↑e x

full_name: Pretrivialization.mk_proj_snd'
code: theorem mk_proj_snd' (ex : proj x ∈ e.baseSet) : (proj x, (e x).2) = e x 
goal: (proj x, (↑e x).2) = ↑e x

full_name: Pretrivialization.setSymm
code: /-- Composition of inverse and coercion from the subtype of the target. -/
def setSymm : e.target → Z 
goal: ↑e.target → Z

full_name: Pretrivialization.mem_target
code: theorem mem_target {x : B × F} : x ∈ e.target ↔ x.1 ∈ e.baseSet 
goal: x ∈ e.target ↔ x.1 ∈ e.baseSet

full_name: Pretrivialization.proj_symm_apply
code: theorem proj_symm_apply {x : B × F} (hx : x ∈ e.target) : proj (e.toPartialEquiv.symm x) = x.1 
goal: proj (↑e.symm x) = x.1

full_name: Pretrivialization.proj_symm_apply'
code: theorem proj_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
    proj (e.toPartialEquiv.symm (b, x)) = b 
goal: proj (↑e.symm (b, x)) = b

full_name: Pretrivialization.proj_surjOn_baseSet
code: theorem proj_surjOn_baseSet [Nonempty F] : Set.SurjOn proj e.source e.baseSet 
goal: Set.SurjOn proj e.source e.baseSet

full_name: Pretrivialization.apply_symm_apply
code: theorem apply_symm_apply {x : B × F} (hx : x ∈ e.target) : e (e.toPartialEquiv.symm x) = x 
goal: ↑e (↑e.symm x) = x

full_name: Pretrivialization.apply_symm_apply'
code: theorem apply_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
    e (e.toPartialEquiv.symm (b, x)) = (b, x) 
goal: ↑e (↑e.symm (b, x)) = (b, x)

full_name: Pretrivialization.symm_apply_apply
code: theorem symm_apply_apply {x : Z} (hx : x ∈ e.source) : e.toPartialEquiv.symm (e x) = x 
goal: ↑e.symm (↑e x) = x

full_name: Pretrivialization.symm_apply_mk_proj
code: @[simp, mfld_simps]
theorem symm_apply_mk_proj {x : Z} (ex : x ∈ e.source) :
    e.toPartialEquiv.symm (proj x, (e x).2) = x 
goal: ↑e.symm (proj x, (↑e x).2) = x

full_name: Pretrivialization.preimage_symm_proj_baseSet
code: @[simp, mfld_simps]
theorem preimage_symm_proj_baseSet :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target 
goal: ↑e.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target

full_name: Pretrivialization.preimage_symm_proj_inter
code: @[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ 
goal: ↑e.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ Set.univ = (s ∩ e.baseSet) ×ˢ Set.univ

full_name: Pretrivialization.target_inter_preimage_symm_source_eq
code: theorem target_inter_preimage_symm_source_eq (e f : Pretrivialization F proj) :
    f.target ∩ f.toPartialEquiv.symm ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ 
goal: f.target ∩ ↑f.symm ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ Set.univ

full_name: Pretrivialization.trans_source
code: theorem trans_source (e f : Pretrivialization F proj) :
    (f.toPartialEquiv.symm.trans e.toPartialEquiv).source = (e.baseSet ∩ f.baseSet) ×ˢ univ 
goal: (f.symm.trans e.toPartialEquiv).source = (e.baseSet ∩ f.baseSet) ×ˢ Set.univ

full_name: Pretrivialization.symm_trans_symm
code: theorem symm_trans_symm (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).symm
      = e'.toPartialEquiv.symm.trans e.toPartialEquiv 
goal: (e.symm.trans e'.toPartialEquiv).symm = e'.symm.trans e.toPartialEquiv

full_name: Pretrivialization.symm_trans_source_eq
code: theorem symm_trans_source_eq (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ 
goal: (e.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ Set.univ

full_name: Pretrivialization.symm_trans_target_eq
code: theorem symm_trans_target_eq (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ 
goal: (e.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ Set.univ

full_name: Pretrivialization.coe_mem_source
code: @[simp]
theorem coe_mem_source : ↑y ∈ e'.source ↔ b ∈ e'.baseSet 
goal: { proj := b, snd := y } ∈ e'.source ↔ b ∈ e'.baseSet

full_name: Pretrivialization.coe_coe_fst
code: @[simp, mfld_simps]
theorem coe_coe_fst (hb : b ∈ e'.baseSet) : (e' y).1 = b 
goal: (↑e' { proj := b, snd := y }).1 = b

full_name: Pretrivialization.mk_mem_target
code: theorem mk_mem_target {x : B} {y : F} : (x, y) ∈ e'.target ↔ x ∈ e'.baseSet 
goal: (x, y) ∈ e'.target ↔ x ∈ e'.baseSet

full_name: Pretrivialization.symm_coe_proj
code: theorem symm_coe_proj {x : B} {y : F} (e' : Pretrivialization F (π F E)) (h : x ∈ e'.baseSet) :
    (e'.toPartialEquiv.symm (x, y)).1 = x 
goal: (↑e'.symm (x, y)).proj = x

full_name: Pretrivialization.symm
code: /-- A fiberwise inverse to `e`. This is the function `F → E b` that induces a local inverse
`B × F → TotalSpace F E` of `e` on `e.baseSet`. It is defined to be `0` outside `e.baseSet`. -/
protected noncomputable def symm (e : Pretrivialization F (π F E)) (b : B) (y : F) : E b 
goal: E b

full_name: Pretrivialization.symm_apply
code: theorem symm_apply (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e.symm b y = cast (congr_arg E (e.symm_coe_proj hb)) (e.toPartialEquiv.symm (b, y)).2 
goal: e.symm b y = cast ⋯ (↑e.symm (b, y)).snd

full_name: Pretrivialization.symm_apply_of_not_mem
code: theorem symm_apply_of_not_mem (e : Pretrivialization F (π F E)) {b : B} (hb : b ∉ e.baseSet)
    (y : F) : e.symm b y = 0 
goal: e.symm b y = 0

full_name: Pretrivialization.coe_symm_of_not_mem
code: theorem coe_symm_of_not_mem (e : Pretrivialization F (π F E)) {b : B} (hb : b ∉ e.baseSet) :
    (e.symm b : F → E b) = 0 
goal: e.symm b = 0

full_name: Pretrivialization.mk_symm
code: theorem mk_symm (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    TotalSpace.mk b (e.symm b y) = e.toPartialEquiv.symm (b, y) 
goal: { proj := b, snd := e.symm b y } = ↑e.symm (b, y)

full_name: Pretrivialization.symm_proj_apply
code: theorem symm_proj_apply (e : Pretrivialization F (π F E)) (z : TotalSpace F E)
    (hz : z.proj ∈ e.baseSet) : e.symm z.proj (e z).2 = z.2 
goal: e.symm z.proj (↑e z).2 = z.snd

full_name: Pretrivialization.symm_apply_apply_mk
code: theorem symm_apply_apply_mk (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet)
    (y : E b) : e.symm b (e ⟨b, y⟩).2 = y 
goal: e.symm b (↑e { proj := b, snd := y }).2 = y

full_name: Pretrivialization.apply_mk_symm
code: theorem apply_mk_symm (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e ⟨b, e.symm b y⟩ = (b, y) 
goal: ↑e { proj := b, snd := e.symm b y } = (b, y)

full_name: Trivialization
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: Type (max (max u_2 u_3) u_5)

full_name: Trivialization.source_eq
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: self.source = proj ⁻¹' self.baseSet

full_name: Trivialization.proj_toFun
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: p ∈ self.source → (↑self.toPartialHomeomorph p).1 = proj p

full_name: Trivialization.baseSet
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: Set B

full_name: Trivialization.target_eq
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: self.target = self.baseSet ×ˢ Set.univ

full_name: Trivialization.open_baseSet
code: /-- A structure extending partial homeomorphisms, defining a local trivialization of a projection
`proj : Z → B` with fiber `F`, as a partial homeomorphism between `Z` and `B × F` defined between
two sets of the form `proj ⁻¹' baseSet` and `baseSet × F`, acting trivially on the first coordinate.
-/
-- Porting note (#5171): was @[nolint has_nonempty_instance]
structure Trivialization (proj : Z → B) extends PartialHomeomorph Z (B × F) where
  baseSet : Set B
  open_baseSet : IsOpen baseSet
  source_eq : source = proj ⁻¹' baseSet
  target_eq : target = baseSet ×ˢ univ
  proj_toFun : ∀ p ∈ source, (toPartialHomeomorph p).1 = proj p
goal: IsOpen self.baseSet

full_name: Trivialization.ext'
code: @[ext]
lemma ext' (e e' : Trivialization F proj) (h₁ : e.toPartialHomeomorph = e'.toPartialHomeomorph)
    (h₂ : e.baseSet = e'.baseSet) : e = e' 
goal: e = e'

full_name: Trivialization.toFun'
code: /-- Coercion of a trivialization 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.  -/
@[coe] def toFun' : Z → (B × F) 
goal: Z → B × F

full_name: Trivialization.toPretrivialization
code: /-- Natural identification as a `Pretrivialization`. -/
def toPretrivialization : Pretrivialization F proj 
goal: Pretrivialization F proj

full_name: Trivialization.instCoeFunForallProd
code: instance : CoeFun (Trivialization F proj) fun _ => Z → B × F 
goal: CoeFun (Trivialization F proj) fun x => Z → B × F

full_name: Trivialization.instCoePretrivialization
code: instance : Coe (Trivialization F proj) (Pretrivialization F proj) 
goal: Coe (Trivialization F proj) (Pretrivialization F proj)

full_name: Trivialization.toPretrivialization_injective
code: theorem toPretrivialization_injective :
    Function.Injective fun e : Trivialization F proj => e.toPretrivialization 
goal: Function.Injective fun e => e.toPretrivialization

full_name: Trivialization.coe_coe
code: @[simp, mfld_simps]
theorem coe_coe : ⇑e.toPartialHomeomorph = e 
goal: ↑e.toPartialHomeomorph = ↑e

full_name: Trivialization.coe_fst
code: @[simp, mfld_simps]
theorem coe_fst (ex : x ∈ e.source) : (e x).1 = proj x 
goal: (↑e x).1 = proj x

full_name: Trivialization.eqOn
code: protected theorem eqOn : EqOn (Prod.fst ∘ e) proj e.source 
goal: Set.EqOn (Prod.fst ∘ ↑e) proj e.source

full_name: Trivialization.mem_source
code: theorem mem_source : x ∈ e.source ↔ proj x ∈ e.baseSet 
goal: x ∈ e.source ↔ proj x ∈ e.baseSet

full_name: Trivialization.coe_fst'
code: theorem coe_fst' (ex : proj x ∈ e.baseSet) : (e x).1 = proj x 
goal: (↑e x).1 = proj x

full_name: Trivialization.mk_proj_snd
code: theorem mk_proj_snd (ex : x ∈ e.source) : (proj x, (e x).2) = e x 
goal: (proj x, (↑e x).2) = ↑e x

full_name: Trivialization.mk_proj_snd'
code: theorem mk_proj_snd' (ex : proj x ∈ e.baseSet) : (proj x, (e x).2) = e x 
goal: (proj x, (↑e x).2) = ↑e x

full_name: Trivialization.source_inter_preimage_target_inter
code: theorem source_inter_preimage_target_inter (s : Set (B × F)) :
    e.source ∩ e ⁻¹' (e.target ∩ s) = e.source ∩ e ⁻¹' s 
goal: e.source ∩ ↑e ⁻¹' (e.target ∩ s) = e.source ∩ ↑e ⁻¹' s

full_name: Trivialization.coe_mk
code: @[simp, mfld_simps]
theorem coe_mk (e : PartialHomeomorph Z (B × F)) (i j k l m) (x : Z) :
    (Trivialization.mk e i j k l m : Trivialization F proj) x = e x 
goal: ↑{ toPartialHomeomorph := e, baseSet := i, open_baseSet := j, source_eq := k, target_eq := l, proj_toFun := m } x = ↑e x

full_name: Trivialization.mem_target
code: theorem mem_target {x : B × F} : x ∈ e.target ↔ x.1 ∈ e.baseSet 
goal: x ∈ e.target ↔ x.1 ∈ e.baseSet

full_name: Trivialization.map_target
code: theorem map_target {x : B × F} (hx : x ∈ e.target) : e.toPartialHomeomorph.symm x ∈ e.source 
goal: ↑e.symm x ∈ e.source

full_name: Trivialization.proj_symm_apply
code: theorem proj_symm_apply {x : B × F} (hx : x ∈ e.target) :
    proj (e.toPartialHomeomorph.symm x) = x.1 
goal: proj (↑e.symm x) = x.1

full_name: Trivialization.proj_symm_apply'
code: theorem proj_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
    proj (e.toPartialHomeomorph.symm (b, x)) = b 
goal: proj (↑e.symm (b, x)) = b

full_name: Trivialization.proj_surjOn_baseSet
code: theorem proj_surjOn_baseSet [Nonempty F] : Set.SurjOn proj e.source e.baseSet 
goal: Set.SurjOn proj e.source e.baseSet

full_name: Trivialization.apply_symm_apply
code: theorem apply_symm_apply {x : B × F} (hx : x ∈ e.target) : e (e.toPartialHomeomorph.symm x) = x 
goal: ↑e (↑e.symm x) = x

full_name: Trivialization.apply_symm_apply'
code: theorem apply_symm_apply' {b : B} {x : F} (hx : b ∈ e.baseSet) :
    e (e.toPartialHomeomorph.symm (b, x)) = (b, x) 
goal: ↑e (↑e.symm (b, x)) = (b, x)

full_name: Trivialization.symm_apply_mk_proj
code: @[simp, mfld_simps]
theorem symm_apply_mk_proj (ex : x ∈ e.source) : e.toPartialHomeomorph.symm (proj x, (e x).2) = x 
goal: ↑e.symm (proj x, (↑e x).2) = x

full_name: Trivialization.symm_trans_source_eq
code: theorem symm_trans_source_eq (e e' : Trivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ 
goal: (e.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ Set.univ

full_name: Trivialization.symm_trans_target_eq
code: theorem symm_trans_target_eq (e e' : Trivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ 
goal: (e.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ Set.univ

full_name: Trivialization.coe_fst_eventuallyEq_proj
code: theorem coe_fst_eventuallyEq_proj (ex : x ∈ e.source) : Prod.fst ∘ e =ᶠ[𝓝 x] proj 
goal: Prod.fst ∘ ↑e =ᶠ[𝓝 x] proj

full_name: Trivialization.coe_fst_eventuallyEq_proj'
code: theorem coe_fst_eventuallyEq_proj' (ex : proj x ∈ e.baseSet) : Prod.fst ∘ e =ᶠ[𝓝 x] proj 
goal: Prod.fst ∘ ↑e =ᶠ[𝓝 x] proj

full_name: Trivialization.map_proj_nhds
code: theorem map_proj_nhds (ex : x ∈ e.source) : map proj (𝓝 x) = 𝓝 (proj x) 
goal: Filter.map proj (𝓝 x) = 𝓝 (proj x)

full_name: Trivialization.preimage_subset_source
code: theorem preimage_subset_source {s : Set B} (hb : s ⊆ e.baseSet) : proj ⁻¹' s ⊆ e.source 
goal: proj ⁻¹' s ⊆ e.source

full_name: Trivialization.image_preimage_eq_prod_univ
code: theorem image_preimage_eq_prod_univ {s : Set B} (hb : s ⊆ e.baseSet) :
    e '' (proj ⁻¹' s) = s ×ˢ univ 
goal: ↑e '' (proj ⁻¹' s) = s ×ˢ Set.univ

full_name: Trivialization.tendsto_nhds_iff
code: theorem tendsto_nhds_iff {α : Type*} {l : Filter α} {f : α → Z} {z : Z} (hz : z ∈ e.source) :
    Tendsto f l (𝓝 z) ↔
      Tendsto (proj ∘ f) l (𝓝 (proj z)) ∧ Tendsto (fun x ↦ (e (f x)).2) l (𝓝 (e z).2) 
goal: Filter.Tendsto f l (𝓝 z) ↔
  Filter.Tendsto (proj ∘ f) l (𝓝 (proj z)) ∧ Filter.Tendsto (fun x => (↑e (f x)).2) l (𝓝 (↑e z).2)

full_name: Trivialization.nhds_eq_inf_comap
code: theorem nhds_eq_inf_comap {z : Z} (hz : z ∈ e.source) :
    𝓝 z = comap proj (𝓝 (proj z)) ⊓ comap (Prod.snd ∘ e) (𝓝 (e z).2) 
goal: 𝓝 z = Filter.comap proj (𝓝 (proj z)) ⊓ Filter.comap (Prod.snd ∘ ↑e) (𝓝 (↑e z).2)

full_name: Trivialization.preimageHomeomorph
code: /-- The preimage of a subset of the base set is homeomorphic to the product with the fiber. -/
def preimageHomeomorph {s : Set B} (hb : s ⊆ e.baseSet) : proj ⁻¹' s ≃ₜ s × F 
goal: ↑(proj ⁻¹' s) ≃ₜ ↑s × F

full_name: Trivialization.preimageHomeomorph_apply
code: @[simp]
theorem preimageHomeomorph_apply {s : Set B} (hb : s ⊆ e.baseSet) (p : proj ⁻¹' s) :
    e.preimageHomeomorph hb p = (⟨proj p, p.2⟩, (e p).2) 
goal: (e.preimageHomeomorph hb) p = (⟨proj ↑p, ⋯⟩, (↑e ↑p).2)

full_name: Trivialization.preimageHomeomorph_symm_apply.aux
code: /-- Auxilliary definition to avoid looping in `dsimp`
with `Trivialization.preimageHomeomorph_symm_apply`. -/
protected def preimageHomeomorph_symm_apply.aux {s : Set B} (hb : s ⊆ e.baseSet) 
goal: ↑s × F ≃ₜ ↑(proj ⁻¹' s)

full_name: Trivialization.preimageHomeomorph_symm_apply
code: @[simp]
theorem preimageHomeomorph_symm_apply {s : Set B} (hb : s ⊆ e.baseSet) (p : s × F) :
    (e.preimageHomeomorph hb).symm p =
      ⟨e.symm (p.1, p.2), ((preimageHomeomorph_symm_apply.aux e hb) p).2⟩ 
goal: (e.preimageHomeomorph hb).symm p = ⟨↑e.symm (↑p.1, p.2), ⋯⟩

full_name: Trivialization.sourceHomeomorphBaseSetProd
code: /-- The source is homeomorphic to the product of the base set with the fiber. -/
def sourceHomeomorphBaseSetProd : e.source ≃ₜ e.baseSet × F 
goal: ↑e.source ≃ₜ ↑e.baseSet × F

full_name: Trivialization.sourceHomeomorphBaseSetProd_apply
code: @[simp]
theorem sourceHomeomorphBaseSetProd_apply (p : e.source) :
    e.sourceHomeomorphBaseSetProd p = (⟨proj p, e.mem_source.mp p.2⟩, (e p).2) 
goal: e.sourceHomeomorphBaseSetProd p = (⟨proj ↑p, ⋯⟩, (↑e ↑p).2)

full_name: Trivialization.sourceHomeomorphBaseSetProd_symm_apply.aux
code: /-- Auxilliary definition to avoid looping in `dsimp`
with `Trivialization.sourceHomeomorphBaseSetProd_symm_apply`. -/
protected def sourceHomeomorphBaseSetProd_symm_apply.aux 
goal: ↑e.baseSet × F ≃ₜ ↑e.source

full_name: Trivialization.sourceHomeomorphBaseSetProd_symm_apply
code: @[simp]
theorem sourceHomeomorphBaseSetProd_symm_apply (p : e.baseSet × F) :
    e.sourceHomeomorphBaseSetProd.symm p =
      ⟨e.symm (p.1, p.2), (sourceHomeomorphBaseSetProd_symm_apply.aux e p).2⟩ 
goal: e.sourceHomeomorphBaseSetProd.symm p = ⟨↑e.symm (↑p.1, p.2), ⋯⟩

full_name: Trivialization.preimageSingletonHomeomorph
code: /-- Each fiber of a trivialization is homeomorphic to the specified fiber. -/
def preimageSingletonHomeomorph {b : B} (hb : b ∈ e.baseSet) : proj ⁻¹' {b} ≃ₜ F 
goal: ↑(proj ⁻¹' {b}) ≃ₜ F

full_name: Trivialization.preimageSingletonHomeomorph_apply
code: @[simp]
theorem preimageSingletonHomeomorph_apply {b : B} (hb : b ∈ e.baseSet) (p : proj ⁻¹' {b}) :
    e.preimageSingletonHomeomorph hb p = (e p).2 
goal: (e.preimageSingletonHomeomorph hb) p = (↑e ↑p).2

full_name: Trivialization.preimageSingletonHomeomorph_symm_apply
code: @[simp]
theorem preimageSingletonHomeomorph_symm_apply {b : B} (hb : b ∈ e.baseSet) (p : F) :
    (e.preimageSingletonHomeomorph hb).symm p =
      ⟨e.symm (b, p), by rw [mem_preimage, e.proj_symm_apply' hb, mem_singleton_iff]⟩ 
goal: (e.preimageSingletonHomeomorph hb).symm p = ⟨↑e.symm (b, p), ⋯⟩

full_name: Trivialization.continuousAt_proj
code: /-- In the domain of a bundle trivialization, the projection is continuous-/
theorem continuousAt_proj (ex : x ∈ e.source) : ContinuousAt proj x 
goal: ContinuousAt proj x

full_name: Trivialization.compHomeomorph
code: /-- Composition of a `Trivialization` and a `Homeomorph`. -/
protected def compHomeomorph {Z' : Type*} [TopologicalSpace Z'] (h : Z' ≃ₜ Z) :
    Trivialization F (proj ∘ h) 
goal: Trivialization F (proj ∘ ⇑h)

full_name: Trivialization.continuousAt_of_comp_right
code: /-- Read off the continuity of a function `f : Z → X` at `z : Z` by transferring via a
trivialization of `Z` containing `z`. -/
theorem continuousAt_of_comp_right {X : Type*} [TopologicalSpace X] {f : Z → X} {z : Z}
    (e : Trivialization F proj) (he : proj z ∈ e.baseSet)
    (hf : ContinuousAt (f ∘ e.toPartialEquiv.symm) (e z)) : ContinuousAt f z 
goal: ContinuousAt f z

full_name: Trivialization.continuousAt_of_comp_left
code: /-- Read off the continuity of a function `f : X → Z` at `x : X` by transferring via a
trivialization of `Z` containing `f x`. -/
theorem continuousAt_of_comp_left {X : Type*} [TopologicalSpace X] {f : X → Z} {x : X}
    (e : Trivialization F proj) (hf_proj : ContinuousAt (proj ∘ f) x) (he : proj (f x) ∈ e.baseSet)
    (hf : ContinuousAt (e ∘ f) x) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: Trivialization.continuousOn
code: protected theorem continuousOn : ContinuousOn e' e'.source 
goal: ContinuousOn (↑e') e'.source

full_name: Trivialization.coe_mem_source
code: theorem coe_mem_source : ↑y ∈ e'.source ↔ b ∈ e'.baseSet 
goal: { proj := b, snd := y } ∈ e'.source ↔ b ∈ e'.baseSet

full_name: Trivialization.coe_coe_fst
code: @[simp, mfld_simps]
theorem coe_coe_fst (hb : b ∈ e'.baseSet) : (e' y).1 = b 
goal: (↑e' { proj := b, snd := y }).1 = b

full_name: Trivialization.mk_mem_target
code: theorem mk_mem_target {y : F} : (b, y) ∈ e'.target ↔ b ∈ e'.baseSet 
goal: (b, y) ∈ e'.target ↔ b ∈ e'.baseSet

full_name: Trivialization.symm_apply_apply
code: theorem symm_apply_apply {x : TotalSpace F E} (hx : x ∈ e'.source) :
    e'.toPartialHomeomorph.symm (e' x) = x 
goal: ↑e'.symm (↑e' x) = x

full_name: Trivialization.symm_coe_proj
code: @[simp, mfld_simps]
theorem symm_coe_proj {x : B} {y : F} (e : Trivialization F (π F E)) (h : x ∈ e.baseSet) :
    (e.toPartialHomeomorph.symm (x, y)).1 = x 
goal: (↑e.symm (x, y)).proj = x

full_name: Trivialization.symm
code: /-- A fiberwise inverse to `e'`. The function `F → E x` that induces a local inverse
`B × F → TotalSpace F E` of `e'` on `e'.baseSet`. It is defined to be `0` outside `e'.baseSet`. -/
protected noncomputable def symm (e : Trivialization F (π F E)) (b : B) (y : F) : E b 
goal: E b

full_name: Trivialization.symm_apply
code: theorem symm_apply (e : Trivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e.symm b y = cast (congr_arg E (e.symm_coe_proj hb)) (e.toPartialHomeomorph.symm (b, y)).2 
goal: e.symm b y = cast ⋯ (↑e.symm (b, y)).snd

full_name: Trivialization.symm_apply_of_not_mem
code: theorem symm_apply_of_not_mem (e : Trivialization F (π F E)) {b : B} (hb : b ∉ e.baseSet) (y : F) :
    e.symm b y = 0 
goal: e.symm b y = 0

full_name: Trivialization.mk_symm
code: theorem mk_symm (e : Trivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    TotalSpace.mk b (e.symm b y) = e.toPartialHomeomorph.symm (b, y) 
goal: { proj := b, snd := e.symm b y } = ↑e.symm (b, y)

full_name: Trivialization.symm_proj_apply
code: theorem symm_proj_apply (e : Trivialization F (π F E)) (z : TotalSpace F E)
    (hz : z.proj ∈ e.baseSet) : e.symm z.proj (e z).2 = z.2 
goal: e.symm z.proj (↑e z).2 = z.snd

full_name: Trivialization.symm_apply_apply_mk
code: theorem symm_apply_apply_mk (e : Trivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : E b) :
    e.symm b (e ⟨b, y⟩).2 = y 
goal: e.symm b (↑e { proj := b, snd := y }).2 = y

full_name: Trivialization.apply_mk_symm
code: theorem apply_mk_symm (e : Trivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e ⟨b, e.symm b y⟩ = (b, y) 
goal: ↑e { proj := b, snd := e.symm b y } = (b, y)

full_name: Trivialization.continuousOn_symm
code: theorem continuousOn_symm (e : Trivialization F (π F E)) :
    ContinuousOn (fun z : B × F => TotalSpace.mk' F z.1 (e.symm z.1 z.2)) (e.baseSet ×ˢ univ) 
goal: ContinuousOn (fun z => Bundle.TotalSpace.mk' F z.1 (e.symm z.1 z.2)) (e.baseSet ×ˢ Set.univ)

full_name: Trivialization.transFiberHomeomorph
code: /-- If `e` is a `Trivialization` of `proj : Z → B` with fiber `F` and `h` is a homeomorphism
`F ≃ₜ F'`, then `e.trans_fiber_homeomorph h` is the trivialization of `proj` with the fiber `F'`
that sends `p : Z` to `((e p).1, h (e p).2)`. -/
def transFiberHomeomorph {F' : Type*} [TopologicalSpace F'] (e : Trivialization F proj)
    (h : F ≃ₜ F') : Trivialization F' proj 
goal: Trivialization F' proj

full_name: Trivialization.transFiberHomeomorph_apply
code: @[simp]
theorem transFiberHomeomorph_apply {F' : Type*} [TopologicalSpace F'] (e : Trivialization F proj)
    (h : F ≃ₜ F') (x : Z) : e.transFiberHomeomorph h x = ((e x).1, h (e x).2) 
goal: ↑(e.transFiberHomeomorph h) x = ((↑e x).1, h (↑e x).2)

full_name: Trivialization.coordChange
code: /-- Coordinate transformation in the fiber induced by a pair of bundle trivializations. See also
`Trivialization.coordChangeHomeomorph` for a version bundled as `F ≃ₜ F`. -/
def coordChange (e₁ e₂ : Trivialization F proj) (b : B) (x : F) : F 
goal: F

full_name: Trivialization.mk_coordChange
code: theorem mk_coordChange (e₁ e₂ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) (x : F) :
    (b, e₁.coordChange e₂ b x) = e₂ (e₁.toPartialHomeomorph.symm (b, x)) 
goal: (b, e₁.coordChange e₂ b x) = ↑e₂ (↑e₁.symm (b, x))

full_name: Trivialization.coordChange_apply_snd
code: theorem coordChange_apply_snd (e₁ e₂ : Trivialization F proj) {p : Z} (h : proj p ∈ e₁.baseSet) :
    e₁.coordChange e₂ (proj p) (e₁ p).snd = (e₂ p).snd 
goal: e₁.coordChange e₂ (proj p) (↑e₁ p).2 = (↑e₂ p).2

full_name: Trivialization.coordChange_same_apply
code: theorem coordChange_same_apply (e : Trivialization F proj) {b : B} (h : b ∈ e.baseSet) (x : F) :
    e.coordChange e b x = x 
goal: e.coordChange e b x = x

full_name: Trivialization.coordChange_same
code: theorem coordChange_same (e : Trivialization F proj) {b : B} (h : b ∈ e.baseSet) :
    e.coordChange e b = id 
goal: e.coordChange e b = id

full_name: Trivialization.coordChange_coordChange
code: theorem coordChange_coordChange (e₁ e₂ e₃ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) (x : F) :
    e₂.coordChange e₃ b (e₁.coordChange e₂ b x) = e₁.coordChange e₃ b x 
goal: e₂.coordChange e₃ b (e₁.coordChange e₂ b x) = e₁.coordChange e₃ b x

full_name: Trivialization.continuous_coordChange
code: theorem continuous_coordChange (e₁ e₂ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) : Continuous (e₁.coordChange e₂ b) 
goal: Continuous (e₁.coordChange e₂ b)

full_name: Trivialization.coordChangeHomeomorph
code: /-- Coordinate transformation in the fiber induced by a pair of bundle trivializations,
as a homeomorphism. -/
protected def coordChangeHomeomorph (e₁ e₂ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) : F ≃ₜ F 
goal: F ≃ₜ F

full_name: Trivialization.coordChangeHomeomorph_coe
code: @[simp]
theorem coordChangeHomeomorph_coe (e₁ e₂ : Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
    (h₂ : b ∈ e₂.baseSet) : ⇑(e₁.coordChangeHomeomorph e₂ h₁ h₂) = e₁.coordChange e₂ b 
goal: ⇑(e₁.coordChangeHomeomorph e₂ h₁ h₂) = e₁.coordChange e₂ b

full_name: Trivialization.isImage_preimage_prod
code: theorem isImage_preimage_prod (e : Trivialization F proj) (s : Set B) :
    e.toPartialHomeomorph.IsImage (proj ⁻¹' s) (s ×ˢ univ) 
goal: e.IsImage (proj ⁻¹' s) (s ×ˢ Set.univ)

full_name: Trivialization.restrOpen
code: /-- Restrict a `Trivialization` to an open set in the base. -/
protected def restrOpen (e : Trivialization F proj) (s : Set B) (hs : IsOpen s) :
    Trivialization F proj 
goal: Trivialization F proj

full_name: Trivialization.frontier_preimage
code: theorem frontier_preimage (e : Trivialization F proj) (s : Set B) :
    e.source ∩ frontier (proj ⁻¹' s) = proj ⁻¹' (e.baseSet ∩ frontier s) 
goal: e.source ∩ frontier (proj ⁻¹' s) = proj ⁻¹' (e.baseSet ∩ frontier s)

full_name: Trivialization.piecewise
code: /-- Given two bundle trivializations `e`, `e'` of `proj : Z → B` and a set `s : Set B` such that
the base sets of `e` and `e'` intersect `frontier s` on the same set and `e p = e' p` whenever
`proj p ∈ e.baseSet ∩ frontier s`, `e.piecewise e' s Hs Heq` is the bundle trivialization over
`Set.ite s e.baseSet e'.baseSet` that is equal to `e` on `proj ⁻¹ s` and is equal to `e'`
otherwise. -/
noncomputable def piecewise (e e' : Trivialization F proj) (s : Set B)
    (Hs : e.baseSet ∩ frontier s = e'.baseSet ∩ frontier s)
    (Heq : EqOn e e' <| proj ⁻¹' (e.baseSet ∩ frontier s)) : Trivialization F proj 
goal: Trivialization F proj

full_name: Trivialization.piecewiseLeOfEq
code: /-- Given two bundle trivializations `e`, `e'` of a topological fiber bundle `proj : Z → B`
over a linearly ordered base `B` and a point `a ∈ e.baseSet ∩ e'.baseSet` such that
`e` equals `e'` on `proj ⁻¹' {a}`, `e.piecewise_le_of_eq e' a He He' Heq` is the bundle
trivialization over `Set.ite (Iic a) e.baseSet e'.baseSet` that is equal to `e` on points `p`
such that `proj p ≤ a` and is equal to `e'` otherwise. -/
noncomputable def piecewiseLeOfEq [LinearOrder B] [OrderTopology B] (e e' : Trivialization F proj)
    (a : B) (He : a ∈ e.baseSet) (He' : a ∈ e'.baseSet) (Heq : ∀ p, proj p = a → e p = e' p) :
    Trivialization F proj 
goal: Trivialization F proj

full_name: Trivialization.piecewiseLe
code: /-- Given two bundle trivializations `e`, `e'` of a topological fiber bundle `proj : Z → B` over a
linearly ordered base `B` and a point `a ∈ e.baseSet ∩ e'.baseSet`, `e.piecewise_le e' a He He'`
is the bundle trivialization over `Set.ite (Iic a) e.baseSet e'.baseSet` that is equal to `e` on
points `p` such that `proj p ≤ a` and is equal to `((e' p).1, h (e' p).2)` otherwise, where
`h = e'.coord_change_homeomorph e _ _` is the homeomorphism of the fiber such that
`h (e' p).2 = (e p).2` whenever `e p = a`. -/
noncomputable def piecewiseLe [LinearOrder B] [OrderTopology B] (e e' : Trivialization F proj)
    (a : B) (He : a ∈ e.baseSet) (He' : a ∈ e'.baseSet) : Trivialization F proj 
goal: Trivialization F proj

full_name: Trivialization.disjointUnion
code: /-- Given two bundle trivializations `e`, `e'` over disjoint sets, `e.disjoint_union e' H` is the
bundle trivialization over the union of the base sets that agrees with `e` and `e'` over their
base sets. -/
noncomputable def disjointUnion (e e' : Trivialization F proj) (H : Disjoint e.baseSet e'.baseSet) :
    Trivialization F proj 
goal: Trivialization F proj