Theorem: UniformFun.comap_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: letI : UniformSpace γ := ‹UniformSpace β›.comap f
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
⊢ uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (uniformSpace α β)

tactic: ext : 1
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
⊢ uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (uniformSpace α β)

tactic: change UniformFun.filter α γ ((𝓤 β).comap _) = (UniformFun.filter α β (𝓤 β)).comap _
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)

tactic: have h₁ := Filter.gc_map_comap (Prod.map fcomp fcomp)
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
⊢ UniformFun.filter α γ (comap (fun p => (f p.fst, f p.snd)) (𝓤 β)) =
    comap (fun p => ((fun x => f ∘ x) p.fst, (fun x => f ∘ x) p.snd)) (UniformFun.filter α β (𝓤 β))

tactic: have h₂ := Filter.gc_map_comap (Prod.map f f)
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
⊢ UniformFun.filter α γ (comap (fun p => (f p.fst, f p.snd)) (𝓤 β)) =
    comap (fun p => ((fun x => f ∘ x) p.fst, (fun x => f ∘ x) p.snd)) (UniformFun.filter α β (𝓤 β))

tactic: have h₃ := UniformFun.gc α β
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
⊢ UniformFun.filter α γ (comap (fun p => (f p.fst, f p.snd)) (𝓤 β)) =
    comap (fun p => ((fun x => f ∘ x) p.fst, (fun x => f ∘ x) p.snd)) (UniformFun.filter α β (𝓤 β))

tactic: have h₄ := UniformFun.gc α γ
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
⊢ UniformFun.filter α γ (comap (fun p => (f p.fst, f p.snd)) (𝓤 β)) =
    comap (fun p => ((fun x => f ∘ x) p.fst, (fun x => f ∘ x) p.snd)) (UniformFun.filter α β (𝓤 β))

tactic: refine' GaloisConnection.u_comm_of_l_comm h₁ h₂ h₃ h₄ fun 𝓐 => _
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
h₄ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α γ 𝓕
⊢ UniformFun.filter α γ (comap (fun p => (f p.fst, f p.snd)) (𝓤 β)) =
    comap (fun p => ((fun x => f ∘ x) p.fst, (fun x => f ∘ x) p.snd)) (UniformFun.filter α β (𝓤 β))

tactic: have : Prod.map f f ∘ (UniformFun.phi α γ)
    = (UniformFun.phi α β) ∘ Prod.map (Prod.map fcomp fcomp) (id : α → α) := by
  ext <;> rfl
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
h₄ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α γ 𝓕
𝓐 : Filter ((α → γ) × (α → γ))
⊢ map (Prod.map f f) (map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) = map (UniformFun.phi α β) (map (Prod.map fcomp fcomp) 𝓐 ×ˢ ⊤)

tactic: rw [map_comm this, ← prod_map_map_eq']
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this✝ : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
h₄ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α γ 𝓕
𝓐 : Filter ((α → γ) × (α → γ))
this : Prod.map f f ∘ UniformFun.phi α γ = UniformFun.phi α β ∘ Prod.map (Prod.map fcomp fcomp) id
⊢ map (Prod.map f f) (map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) = map (UniformFun.phi α β) (map (Prod.map fcomp fcomp) 𝓐 ×ˢ ⊤)

tactic: rfl
state_before: case a
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this✝ : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
h₄ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α γ 𝓕
𝓐 : Filter ((α → γ) × (α → γ))
this : Prod.map f f ∘ UniformFun.phi α γ = UniformFun.phi α β ∘ Prod.map (Prod.map fcomp fcomp) id
⊢ map (UniformFun.phi α β) (map (Prod.map fcomp fcomp) 𝓐 ×ˢ map id ⊤) =
    map (UniformFun.phi α β) (map (Prod.map fcomp fcomp) 𝓐 ×ˢ ⊤)

tactic: ext <;> rfl
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Type ?u.38626
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → β
this : UniformSpace γ := UniformSpace.comap f inst✝
fcomp : (α → γ) → α → β := fun x => f ∘ x
h₁ : GaloisConnection (map (Prod.map fcomp fcomp)) (comap (Prod.map fcomp fcomp))
h₂ : GaloisConnection (map (Prod.map f f)) (comap (Prod.map f f))
h₃ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
h₄ : GaloisConnection (fun 𝓐 => map (UniformFun.phi α γ) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α γ 𝓕
𝓐 : Filter ((α → γ) × (α → γ))
⊢ Prod.map f f ∘ UniformFun.phi α γ = UniformFun.phi α β ∘ Prod.map (Prod.map fcomp fcomp) id