Theorem: Trivialization.Prod.continuous_to_fun
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: let f₁ : TotalSpace (E₁ ×ᵇ E₂) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p ↦ ((⟨p.1, p.2.1⟩ : TotalSpace E₁), (⟨p.1, p.2.2⟩ : TotalSpace E₂))
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: let f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p ↦ ⟨e₁ p.1, e₂ p.2⟩
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: let f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p ↦ ⟨p.1.1, p.1.2, p.2.2⟩
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: have hf₁ : Continuous f₁ := (Prod.inducing_diag E₁ E₂).continuous
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: have hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source) :=
  e₁.toLocalHomeomorph.continuousOn.prod_map e₂.toLocalHomeomorph.continuousOn
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: have hf₃ : Continuous f₃ :=
  (continuous_fst.comp continuous_fst).prod_mk (continuous_snd.prod_map continuous_snd)
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: refine' ((hf₃.comp_continuousOn hf₂).comp hf₁.continuousOn _).congr _
state_before: B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
⊢ ContinuousOn (toFun' e₁ e₂) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: rintro ⟨b, v₁, v₂⟩ ⟨hb₁, _⟩
state_before: case refine'_2
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
⊢ EqOn (toFun' e₁ e₂) ((f₃ ∘ f₂) ∘ f₁) (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))

tactic: simp only [Prod.toFun', Prod.mk.inj_iff, Function.comp_apply, and_true_iff]
state_before: case refine'_2.mk.mk.intro
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
b : B
v₁ : E₁ b
v₂ : E₂ b
hb₁ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₁.baseSet
right✝ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₂.baseSet
⊢ toFun' e₁ e₂ { fst := b, snd := (v₁, v₂) } = ((f₃ ∘ f₂) ∘ f₁) { fst := b, snd := (v₁, v₂) }

tactic: rw [e₁.coe_fst]
state_before: case refine'_2.mk.mk.intro
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
b : B
v₁ : E₁ b
v₂ : E₂ b
hb₁ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₁.baseSet
right✝ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₂.baseSet
⊢ b = (↑e₁ { fst := b, snd := v₁ }).fst

tactic: rw [e₁.source_eq, mem_preimage]
state_before: case refine'_2.mk.mk.intro
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
b : B
v₁ : E₁ b
v₂ : E₂ b
hb₁ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₁.baseSet
right✝ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₂.baseSet
⊢ { fst := b, snd := v₁ } ∈ e₁.source

tactic: exact hb₁
state_before: case refine'_2.mk.mk.intro
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
b : B
v₁ : E₁ b
v₂ : E₂ b
hb₁ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₁.baseSet
right✝ : TotalSpace.proj { fst := b, snd := (v₁, v₂) } ∈ e₂.baseSet
⊢ TotalSpace.proj { fst := b, snd := v₁ } ∈ e₁.baseSet

tactic: rw [e₁.source_eq, e₂.source_eq]
state_before: case refine'_1
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
⊢ MapsTo f₁ (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) (e₁.source ×ˢ e₂.source)

tactic: exact mapsTo_preimage _ _
state_before: case refine'_1
B : Type u_3
inst✝⁴ : TopologicalSpace B
F₁ : Type u_5
inst✝³ : TopologicalSpace F₁
E₁ : B → Type u_2
inst✝² : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_4
inst✝¹ : TopologicalSpace F₂
E₂ : B → Type u_1
inst✝ : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
f₁ : (TotalSpace fun x => E₁ x × E₂ x) → TotalSpace E₁ × TotalSpace E₂ :=
  fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })
f₂ : TotalSpace E₁ × TotalSpace E₂ → (B × F₁) × B × F₂ := fun p => (↑e₁ p.fst, ↑e₂ p.snd)
f₃ : (B × F₁) × B × F₂ → B × F₁ × F₂ := fun p => (p.fst.fst, p.fst.snd, p.snd.snd)
hf₁ : Continuous f₁
hf₂ : ContinuousOn f₂ (e₁.source ×ˢ e₂.source)
hf₃ : Continuous f₃
⊢ MapsTo f₁ (TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))
    ((TotalSpace.proj ⁻¹' e₁.baseSet) ×ˢ (TotalSpace.proj ⁻¹' e₂.baseSet))