File: Mathlib/Topology/UniformSpace/Pi.lean

full_name: Pi.uniformSpace
code: instance Pi.uniformSpace : UniformSpace (∀ i, α i) 
goal: UniformSpace ((i : ι) → α i)

full_name: Pi.uniformSpace_eq
code: lemma Pi.uniformSpace_eq :
    Pi.uniformSpace α = ⨅ i, UniformSpace.comap (eval i) (U i) 
goal: Pi.uniformSpace α = ⨅ i, UniformSpace.comap (Function.eval i) (U i)

full_name: Pi.uniformity
code: theorem Pi.uniformity :
    𝓤 (∀ i, α i) = ⨅ i : ι, (Filter.comap fun a => (a.1 i, a.2 i)) (𝓤 (α i)) 
goal: 𝓤 ((i : ι) → α i) = ⨅ i, Filter.comap (fun a => (a.1 i, a.2 i)) (𝓤 (α i))

full_name: instIsCountablyGeneratedProdForallUniformityOfCountable
code: instance [Countable ι] [∀ i, IsCountablyGenerated (𝓤 (α i))] :
    IsCountablyGenerated (𝓤 (∀ i, α i)) 
goal: (𝓤 ((i : ι) → α i)).IsCountablyGenerated

full_name: uniformContinuous_pi
code: theorem uniformContinuous_pi {β : Type*} [UniformSpace β] {f : β → ∀ i, α i} :
    UniformContinuous f ↔ ∀ i, UniformContinuous fun x => f x i 
goal: UniformContinuous f ↔ ∀ (i : ι), UniformContinuous fun x => f x i

full_name: Pi.uniformContinuous_proj
code: theorem Pi.uniformContinuous_proj (i : ι) : UniformContinuous fun a : ∀ i : ι, α i => a i 
goal: UniformContinuous fun a => a i

full_name: Pi.uniformContinuous_precomp'
code: theorem Pi.uniformContinuous_precomp' (φ : ι' → ι) :
    UniformContinuous (fun (f : (∀ i, α i)) (j : ι') ↦ f (φ j)) 
goal: UniformContinuous fun f j => f (φ j)

full_name: Pi.uniformContinuous_precomp
code: theorem Pi.uniformContinuous_precomp (φ : ι' → ι) :
    UniformContinuous (· ∘ φ : (ι → β) → (ι' → β)) 
goal: UniformContinuous fun x => x ∘ φ

full_name: Pi.uniformContinuous_postcomp'
code: theorem Pi.uniformContinuous_postcomp' {β : ι → Type*} [∀ i, UniformSpace (β i)]
    {g : ∀ i, α i → β i} (hg : ∀ i, UniformContinuous (g i)) :
    UniformContinuous (fun (f : (∀ i, α i)) (i : ι) ↦ g i (f i)) 
goal: UniformContinuous fun f i => g i (f i)

full_name: Pi.uniformContinuous_postcomp
code: theorem Pi.uniformContinuous_postcomp {α : Type*} [UniformSpace α] {g : α → β}
    (hg : UniformContinuous g) : UniformContinuous (g ∘ · : (ι → α) → (ι → β)) 
goal: UniformContinuous fun x => g ∘ x

full_name: Pi.uniformSpace_comap_precomp'
code: lemma Pi.uniformSpace_comap_precomp' (φ : ι' → ι) :
    UniformSpace.comap (fun g i' ↦ g (φ i')) (Pi.uniformSpace (fun i' ↦ α (φ i'))) =
    ⨅ i', UniformSpace.comap (eval (φ i')) (U (φ i')) 
goal: UniformSpace.comap (fun g i' => g (φ i')) (Pi.uniformSpace fun i' => α (φ i')) =
  ⨅ i', UniformSpace.comap (Function.eval (φ i')) (U (φ i'))

full_name: Pi.uniformSpace_comap_precomp
code: lemma Pi.uniformSpace_comap_precomp (φ : ι' → ι) :
    UniformSpace.comap (· ∘ φ) (Pi.uniformSpace (fun _ ↦ β)) =
    ⨅ i', UniformSpace.comap (eval (φ i')) ‹UniformSpace β› 
goal: UniformSpace.comap (fun x => x ∘ φ) (Pi.uniformSpace fun x => β) = ⨅ i', UniformSpace.comap (Function.eval (φ i')) inst✝

full_name: Pi.uniformContinuous_restrict
code: lemma Pi.uniformContinuous_restrict (S : Set ι) :
    UniformContinuous (S.restrict : (∀ i : ι, α i) → (∀ i : S, α i)) 
goal: UniformContinuous S.restrict

full_name: Pi.uniformSpace_comap_restrict
code: lemma Pi.uniformSpace_comap_restrict (S : Set ι) :
    UniformSpace.comap (S.restrict) (Pi.uniformSpace (fun i : S ↦ α i)) =
    ⨅ i ∈ S, UniformSpace.comap (eval i) (U i) 
goal: UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (Function.eval i) (U i)

full_name: cauchy_pi_iff
code: lemma cauchy_pi_iff [Nonempty ι] {l : Filter (∀ i, α i)} :
    Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) 
goal: Cauchy l ↔ ∀ (i : ι), Cauchy (Filter.map (Function.eval i) l)

full_name: cauchy_pi_iff'
code: lemma cauchy_pi_iff' {l : Filter (∀ i, α i)} [l.NeBot] :
    Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) 
goal: Cauchy l ↔ ∀ (i : ι), Cauchy (Filter.map (Function.eval i) l)

full_name: Cauchy.pi
code: lemma Cauchy.pi [Nonempty ι] {l : ∀ i, Filter (α i)} (hl : ∀ i, Cauchy (l i)) :
    Cauchy (Filter.pi l) 
goal: Cauchy (Filter.pi l)

full_name: Pi.complete
code: instance Pi.complete [∀ i, CompleteSpace (α i)] : CompleteSpace (∀ i, α i) 
goal: CompleteSpace ((i : ι) → α i)

full_name: Pi.uniformSpace_comap_restrict_sUnion
code: lemma Pi.uniformSpace_comap_restrict_sUnion (𝔖 : Set (Set ι)) :
    UniformSpace.comap (⋃₀ 𝔖).restrict (Pi.uniformSpace (fun i : (⋃₀ 𝔖) ↦ α i)) =
    ⨅ S ∈ 𝔖, UniformSpace.comap S.restrict (Pi.uniformSpace (fun i : S ↦ α i)) 
goal: UniformSpace.comap (⋃₀ 𝔖).restrict (Pi.uniformSpace fun i => α ↑i) =
  ⨅ S ∈ 𝔖, UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i)

full_name: CompleteSpace.iInf
code: protected theorem CompleteSpace.iInf {ι X : Type*} {u : ι → UniformSpace X}
    (hu : ∀ i, @CompleteSpace X (u i))
    (ht : ∃ t, @T2Space X t ∧ ∀ i, (u i).toTopologicalSpace ≤ t) :
    @CompleteSpace X (⨅ i, u i) 
goal: CompleteSpace X