File: Mathlib/Data/Bundle.lean

full_name: Bundle.TotalSpace
code: /-- `Bundle.TotalSpace F E` is the total space of the bundle. It consists of pairs
`(proj : B, snd : E proj)`.
-/
@[ext]
structure TotalSpace (F : Type*) (E : B → Type*) where
  /-- `Bundle.TotalSpace.proj` is the canonical projection `Bundle.TotalSpace F E → B` from the
  total space to the base space. -/
  proj : B
  snd : E proj
goal: Type (max u_1 u_5)

full_name: Bundle.TotalSpace.proj
code: /-- `Bundle.TotalSpace F E` is the total space of the bundle. It consists of pairs
`(proj : B, snd : E proj)`.
-/
@[ext]
structure TotalSpace (F : Type*) (E : B → Type*) where
  /-- `Bundle.TotalSpace.proj` is the canonical projection `Bundle.TotalSpace F E → B` from the
  total space to the base space. -/
  proj : B
  snd : E proj
goal: B

full_name: Bundle.TotalSpace.snd
code: /-- `Bundle.TotalSpace F E` is the total space of the bundle. It consists of pairs
`(proj : B, snd : E proj)`.
-/
@[ext]
structure TotalSpace (F : Type*) (E : B → Type*) where
  /-- `Bundle.TotalSpace.proj` is the canonical projection `Bundle.TotalSpace F E → B` from the
  total space to the base space. -/
  proj : B
  snd : E proj
goal: E self.proj

full_name: Bundle.instInhabitedTotalSpaceOfDefault
code: instance [Inhabited B] [Inhabited (E default)] : Inhabited (TotalSpace F E) 
goal: Inhabited (Bundle.TotalSpace F E)

full_name: Bundle._aux_Mathlib_Data_Bundle___unexpand_Bundle_TotalSpace_proj_1
code: @[inherit_doc]
scoped notation:max "π" F':max E':max => Bundle.TotalSpace.proj (F := F') (E := E')
goal: Lean.PrettyPrinter.Unexpander

full_name: Bundle._aux_Mathlib_Data_Bundle___macroRules_Bundle_termπ___1
code: @[inherit_doc]
scoped notation:max "π" F':max E':max => Bundle.TotalSpace.proj (F := F') (E := E')
goal: Lean.Macro

full_name: Bundle.TotalSpace.mk'
code: abbrev TotalSpace.mk' (F : Type*) (x : B) (y : E x) : TotalSpace F E 
goal: Bundle.TotalSpace F E

full_name: Bundle.TotalSpace.mk_cast
code: theorem TotalSpace.mk_cast {x x' : B} (h : x = x') (b : E x) :
    .mk' F x' (cast (congr_arg E h) b) = TotalSpace.mk x b 
goal: Bundle.TotalSpace.mk' F x' (cast ⋯ b) = { proj := x, snd := b }

full_name: Bundle.TotalSpace.mk_inj
code: @[simp 1001, mfld_simps 1001]
theorem TotalSpace.mk_inj {b : B} {y y' : E b} : mk' F b y = mk' F b y' ↔ y = y' 
goal: Bundle.TotalSpace.mk' F b y = Bundle.TotalSpace.mk' F b y' ↔ y = y'

full_name: Bundle.TotalSpace.mk_injective
code: theorem TotalSpace.mk_injective (b : B) : Injective (mk b : E b → TotalSpace F E) 
goal: Function.Injective (Bundle.TotalSpace.mk b)

full_name: Bundle.instCoeTCTotalSpace
code: instance {x : B} : CoeTC (E x) (TotalSpace F E) 
goal: CoeTC (E x) (Bundle.TotalSpace F E)

full_name: Bundle.TotalSpace.eta
code: theorem TotalSpace.eta (z : TotalSpace F E) : TotalSpace.mk z.proj z.2 = z 
goal: { proj := z.proj, snd := z.snd } = z

full_name: Bundle.TotalSpace.exists
code: @[simp]
theorem TotalSpace.exists {p : TotalSpace F E → Prop} : (∃ x, p x) ↔ ∃ b y, p ⟨b, y⟩ 
goal: (∃ x, p x) ↔ ∃ b y, p { proj := b, snd := y }

full_name: Bundle.TotalSpace.range_mk
code: @[simp]
theorem TotalSpace.range_mk (b : B) : range ((↑) : E b → TotalSpace F E) = π F E ⁻¹' {b} 
goal: Set.range (Bundle.TotalSpace.mk b) = Bundle.TotalSpace.proj ⁻¹' {b}

full_name: Bundle.«_aux_Mathlib_Data_Bundle___macroRules_Bundle_term_×ᵇ__1»
code: /-- Notation for the direct sum of two bundles over the same base. -/
notation:100 E₁ " ×ᵇ " E₂ => fun x => E₁ x × E₂ x
goal: Lean.Macro

full_name: Bundle.Trivial
code: /-- `Bundle.Trivial B F` is the trivial bundle over `B` of fiber `F`. -/
@[reducible, nolint unusedArguments]
def Trivial (B : Type*) (F : Type*) : B → Type _ 
goal: B → Type u_5

full_name: Bundle.TotalSpace.trivialSnd
code: /-- The trivial bundle, unlike other bundles, has a canonical projection on the fiber. -/
def TotalSpace.trivialSnd (B : Type*) (F : Type*) : TotalSpace F (Bundle.Trivial B F) → F 
goal: Bundle.TotalSpace F (Bundle.Trivial B F) → F

full_name: Bundle.TotalSpace.toProd_symm_apply_snd
code: /-- A trivial bundle is equivalent to the product `B × F`. -/
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
goal: ((Bundle.TotalSpace.toProd B F).symm x).snd = x.2

full_name: Bundle.TotalSpace.toProd_apply
code: /-- A trivial bundle is equivalent to the product `B × F`. -/
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
goal: (Bundle.TotalSpace.toProd B F) x = (x.proj, x.snd)

full_name: Bundle.TotalSpace.toProd_symm_apply_proj
code: /-- A trivial bundle is equivalent to the product `B × F`. -/
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
goal: ((Bundle.TotalSpace.toProd B F).symm x).proj = x.1

full_name: Bundle.TotalSpace.toProd
code: /-- A trivial bundle is equivalent to the product `B × F`. -/
@[simps (config := { attrs := [`mfld_simps] })]
def TotalSpace.toProd (B F : Type*) : (TotalSpace F fun _ : B => F) ≃ B × F 
goal: (Bundle.TotalSpace F fun x => F) ≃ B × F

full_name: Bundle.Pullback
code: /-- The pullback of a bundle `E` over a base `B` under a map `f : B' → B`, denoted by
`Bundle.Pullback f E` or `f *ᵖ E`, is the bundle over `B'` whose fiber over `b'` is `E (f b')`. -/
def Pullback (f : B' → B) (E : B → Type*) : B' → Type _ 
goal: B' → Type u_5

full_name: Bundle._aux_Mathlib_Data_Bundle___unexpand_Bundle_Pullback_1
code: @[inherit_doc]
notation f " *ᵖ " E:arg => Pullback f E
goal: Lean.PrettyPrinter.Unexpander

full_name: Bundle.«_aux_Mathlib_Data_Bundle___macroRules_Bundle_term_*ᵖ__1»
code: @[inherit_doc]
notation f " *ᵖ " E:arg => Pullback f E
goal: Lean.Macro

full_name: Bundle.instNonemptyPullback
code: instance {f : B' → B} {x : B'} [Nonempty (E (f x))] : Nonempty ((f *ᵖ E) x) 
goal: Nonempty ((f *ᵖ E) x)

full_name: Bundle.pullbackTotalSpaceEmbedding
code: /-- Natural embedding of the total space of `f *ᵖ E` into `B' × TotalSpace F E`. -/
@[simp]
def pullbackTotalSpaceEmbedding (f : B' → B) : TotalSpace F (f *ᵖ E) → B' × TotalSpace F E 
goal: Bundle.TotalSpace F (f *ᵖ E) → B' × Bundle.TotalSpace F E

full_name: Bundle.Pullback.lift_snd
code: /-- The base map `f : B' → B` lifts to a canonical map on the total spaces. -/
@[simps (config := { attrs := [`mfld_simps] })]
def Pullback.lift (f : B' → B) : TotalSpace F (f *ᵖ E) → TotalSpace F E 
goal: ∀ (a : Bundle.TotalSpace F (f *ᵖ E)), (Bundle.Pullback.lift f a).snd = a.snd

full_name: Bundle.Pullback.lift_proj
code: /-- The base map `f : B' → B` lifts to a canonical map on the total spaces. -/
@[simps (config := { attrs := [`mfld_simps] })]
def Pullback.lift (f : B' → B) : TotalSpace F (f *ᵖ E) → TotalSpace F E 
goal: ∀ (a : Bundle.TotalSpace F (f *ᵖ E)), (Bundle.Pullback.lift f a).proj = f a.proj

full_name: Bundle.Pullback.lift
code: /-- The base map `f : B' → B` lifts to a canonical map on the total spaces. -/
@[simps (config := { attrs := [`mfld_simps] })]
def Pullback.lift (f : B' → B) : TotalSpace F (f *ᵖ E) → TotalSpace F E 
goal: Bundle.TotalSpace F (f *ᵖ E) → Bundle.TotalSpace F E

full_name: Bundle.Pullback.lift_mk
code: @[simp, mfld_simps]
theorem Pullback.lift_mk (f : B' → B) (x : B') (y : E (f x)) :
    Pullback.lift f (.mk' F x y) = ⟨f x, y⟩ 
goal: Bundle.Pullback.lift f (Bundle.TotalSpace.mk' F x y) = { proj := f x, snd := y }