ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Stonean.finiteCoproduct.hom_ext
lemma finiteCoproduct.hom_ext {B : Stonean.{u}} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g 
Arguments: {α : Type} [Finite α] (X : α → Stonean) {B : Stonean} (f g : Stonean.finiteCoproduct X ⟶ B) (h : ∀ (a : α), Stonean.finiteCoproduct.ι X a ≫ f = Stonean.finiteCoproduct.ι X a ≫ g)
Goal: f = g
-- Stonean.finiteCoproduct.openEmbedding_ι
lemma finiteCoproduct.openEmbedding_ι {α : Type} [Finite α] (Z : α → Stonean.{u}) (a : α) :
    OpenEmbedding (finiteCoproduct.ι Z a) 
Arguments: {α : Type} [Finite α] (Z : α → Stonean) (a : α)
Goal: OpenEmbedding ⇑(Stonean.finiteCoproduct.ι Z a)
-- Stonean.Sigma.openEmbedding_ι
lemma Sigma.openEmbedding_ι {α : Type} [Finite α] (Z : α → Stonean.{u}) (a : α) :
    OpenEmbedding (Sigma.ι Z a) 
Arguments: {α : Type} [Finite α] (Z : α → Stonean) (a : α)
Goal: OpenEmbedding ⇑(CategoryTheory.Limits.Sigma.ι Z a)
-- Stonean.pullback.condition
lemma pullback.condition {X Y Z : Stonean.{u}} (f : X ⟶ Z) {i : Y ⟶ Z}
    (hi : OpenEmbedding i) : pullback.fst f hi ≫ f = pullback.snd f hi ≫ i 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: Stonean.pullback.fst f hi ≫ f = Stonean.pullback.snd f hi ≫ i
-- Stonean.pullback.lift_fst
@[reassoc (attr := simp)]
lemma pullback.lift_fst {W : Stonean} (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i) :
    pullback.lift f hi a b w ≫ pullback.fst f hi = a 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i) {W : Stonean} (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i)
Goal: Stonean.pullback.lift f hi a b w ≫ Stonean.pullback.fst f hi = a
-- Stonean.pullback.lift_snd
@[reassoc (attr := simp)]
lemma pullback.lift_snd {X Y Z W : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding i)
    (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i) :
    pullback.lift f hi a b w ≫ Stonean.pullback.snd f hi = b 
Arguments: {X Y Z W : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i) (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i)
Goal: Stonean.pullback.lift f hi a b w ≫ Stonean.pullback.snd f hi = b
-- Stonean.pullback.cone_π
@[simps! pt π]
noncomputable
def pullback.cone : Limits.PullbackCone f i 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: (Stonean.pullback.cone f hi).π =
  {
    app := fun j =>
      Option.rec (Stonean.pullback.fst f hi ≫ f)
        (fun val => CategoryTheory.Limits.WalkingPair.rec (Stonean.pullback.fst f hi) (Stonean.pullback.snd f hi) val)
        j,
    naturality := ⋯ }
-- Stonean.pullback.cone_pt
@[simps! pt π]
noncomputable
def pullback.cone : Limits.PullbackCone f i 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: (Stonean.pullback.cone f hi).pt = Stonean.pullback f hi
-- Stonean.pullback.hom_ext
lemma pullback.hom_ext {X Y Z W : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding i)
    (a : W ⟶ (pullback.cone f hi).pt) (b : W ⟶ (pullback.cone f hi).pt)
    (hfst : a ≫ pullback.fst f hi = b ≫ pullback.fst f hi) : a = b 
Arguments: {X Y Z W : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i) (a b : W ⟶ (Stonean.pullback.cone f hi).pt) (hfst : a ≫ Stonean.pullback.fst f hi = b ≫ Stonean.pullback.fst f hi)
Goal: a = b
-- Stonean.HasPullbackOpenEmbedding
lemma HasPullbackOpenEmbedding : HasPullback f i 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: CategoryTheory.Limits.HasPullback f i
-- Stonean.pullbackIsoPullback_hom
@[simps]
noncomputable
def pullbackIsoPullback : Stonean.pullback f hi ≅
    @Limits.pullback _ _ _ _ _ f i (HasPullbackOpenEmbedding f hi) 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: (Stonean.pullbackIsoPullback f hi).hom =
  CategoryTheory.Limits.pullback.lift (Stonean.pullback.fst f hi) (Stonean.pullback.snd f hi) ⋯
-- Stonean.pullbackIsoPullback_inv
@[simps]
noncomputable
def pullbackIsoPullback : Stonean.pullback f hi ≅
    @Limits.pullback _ _ _ _ _ f i (HasPullbackOpenEmbedding f hi) 
Arguments: {X Y Z : Stonean} (f : X ⟶ Z) {i : Y ⟶ Z} (hi : OpenEmbedding ⇑i)
Goal: (Stonean.pullbackIsoPullback f hi).inv =
  Stonean.pullback.lift f hi (CategoryTheory.Limits.pullback.fst f i) (CategoryTheory.Limits.pullback.snd f i) ⋯
-- Matrix.uniformity
theorem uniformity :
    𝓤 (Matrix m n 𝕜) = ⨅ (i : m) (j : n), (𝓤 𝕜).comap fun a => (a.1 i j, a.2 i j) 
Arguments: (m : Type u_1) (n : Type u_2) (𝕜 : Type u_3) [UniformSpace 𝕜]
Goal: 𝓤 (Matrix m n 𝕜) = ⨅ i, ⨅ j, Filter.comap (fun a => (a.1 i j, a.2 i j)) (𝓤 𝕜)
-- Matrix.uniformContinuous
theorem uniformContinuous {β : Type*} [UniformSpace β] {f : β → Matrix m n 𝕜} :
    UniformContinuous f ↔ ∀ i j, UniformContinuous fun x => f x i j 
Arguments: (m : Type u_1) (n : Type u_2) (𝕜 : Type u_3) [UniformSpace 𝕜] {β : Type u_4} [UniformSpace β] {f : β → Matrix m n 𝕜}
Goal: UniformContinuous f ↔ ∀ (i : m) (j : n), UniformContinuous fun x => f x i j
-- IsEvenlyCovered.mem_toTrivialization_baseSet
theorem mem_toTrivialization_baseSet {x : X} {I : Type*} [TopologicalSpace I]
    (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {x : X} {I : Type u_3} [TopologicalSpace I] (h : IsEvenlyCovered f x I)
Goal: x ∈ h.toTrivialization.baseSet
-- IsEvenlyCovered.toTrivialization_apply
theorem toTrivialization_apply {x : E} {I : Type*} [TopologicalSpace I]
    (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩ 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {x : E} {I : Type u_3} [TopologicalSpace I] (h : IsEvenlyCovered f (f x) I)
Goal: (↑h.toTrivialization x).2 = ⟨x, ⋯⟩
-- IsEvenlyCovered.continuousAt
protected theorem continuousAt {x : E} {I : Type*} [TopologicalSpace I]
    (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {x : E} {I : Type u_3} [TopologicalSpace I] (h : IsEvenlyCovered f (f x) I)
Goal: ContinuousAt f x
-- IsEvenlyCovered.to_isEvenlyCovered_preimage
theorem to_isEvenlyCovered_preimage {x : X} {I : Type*} [TopologicalSpace I]
    (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x}) 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {x : X} {I : Type u_3} [TopologicalSpace I] (h : IsEvenlyCovered f x I)
Goal: IsEvenlyCovered f x ↑(f ⁻¹' {x})
-- IsCoveringMapOn.mk
theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]
    (e : ∀ x ∈ s, Trivialization (F x) f) (h : ∀ (x : X) (hx : x ∈ s), x ∈ (e x hx).baseSet) :
    IsCoveringMapOn f s 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (s : Set X) (F : X → Type u_3) [(x : X) → TopologicalSpace (F x)] [hF : ∀ (x : X), DiscreteTopology (F x)] (e : (x : X) → x ∈ s → Trivialization (F x) f) (h : ∀ (x : X) (hx : x ∈ s), x ∈ (e x hx).baseSet)
Goal: IsCoveringMapOn f s
-- IsCoveringMapOn.continuousAt
protected theorem continuousAt (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s) :
    ContinuousAt f x 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {s : Set X} (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s)
Goal: ContinuousAt f x
-- IsCoveringMapOn.continuousOn
protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f ⁻¹' s) 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {s : Set X} (hf : IsCoveringMapOn f s)
Goal: ContinuousOn f (f ⁻¹' s)
-- IsCoveringMapOn.isLocalHomeomorphOn
protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :
    IsLocalHomeomorphOn f (f ⁻¹' s) 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {s : Set X} (hf : IsCoveringMapOn f s)
Goal: IsLocalHomeomorphOn f (f ⁻¹' s)
-- isCoveringMap_iff_isCoveringMapOn_univ
theorem isCoveringMap_iff_isCoveringMapOn_univ : IsCoveringMap f ↔ IsCoveringMapOn f Set.univ 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X}
Goal: IsCoveringMap f ↔ IsCoveringMapOn f Set.univ
-- IsCoveringMap.isCoveringMapOn
protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :
    IsCoveringMapOn f Set.univ 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f)
Goal: IsCoveringMapOn f Set.univ
-- IsCoveringMap.mk
theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTopology (F x)]
    (e : ∀ x, Trivialization (F x) f) (h : ∀ x, x ∈ (e x).baseSet) : IsCoveringMap f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] (f : E → X) (F : X → Type u_3) [(x : X) → TopologicalSpace (F x)] [∀ (x : X), DiscreteTopology (F x)] (e : (x : X) → Trivialization (F x) f) (h : ∀ (x : X), x ∈ (e x).baseSet)
Goal: IsCoveringMap f
-- IsCoveringMap.continuous
protected theorem continuous : Continuous f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f)
Goal: Continuous f
-- IsCoveringMap.isLocalHomeomorph
protected theorem isLocalHomeomorph : IsLocalHomeomorph f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f)
Goal: IsLocalHomeomorph f
-- IsCoveringMap.isOpenMap
protected theorem isOpenMap : IsOpenMap f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f)
Goal: IsOpenMap f
-- IsCoveringMap.quotientMap
protected theorem quotientMap (hf' : Function.Surjective f) : QuotientMap f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f) (hf' : Function.Surjective f)
Goal: QuotientMap f
-- IsCoveringMap.isSeparatedMap
protected theorem isSeparatedMap : IsSeparatedMap f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f)
Goal: IsSeparatedMap f
-- IsCoveringMap.eq_of_comp_eq
theorem eq_of_comp_eq [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂)
    (he : f ∘ g₁ = f ∘ g₂) (a : A) (ha : g₁ a = g₂ a) : g₁ = g₂ 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f) {A : Type u_3} [TopologicalSpace A] {g₁ g₂ : A → E} [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂) (he : f ∘ g₁ = f ∘ g₂) (a : A) (ha : g₁ a = g₂ a)
Goal: g₁ = g₂
-- IsCoveringMap.eqOn_of_comp_eqOn
theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)
    (he : s.EqOn (f ∘ g₁) (f ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂ 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f) {A : Type u_3} [TopologicalSpace A] {s : Set A} (hs : IsPreconnected s) {g₁ g₂ : A → E} (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s) (he : Set.EqOn (f ∘ g₁) (f ∘ g₂) s) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a)
Goal: Set.EqOn g₁ g₂ s
-- IsCoveringMap.const_of_comp
theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)
    (he : ∀ a a', f (g a) = f (g a')) (a a') : g a = g a' 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f) {A : Type u_3} [TopologicalSpace A] {g : A → E} [PreconnectedSpace A] (cont : Continuous g) (he : ∀ (a a' : A), f (g a) = f (g a')) (a a' : A)
Goal: g a = g a'
-- IsCoveringMap.constOn_of_comp
theorem constOn_of_comp (cont : ContinuousOn g s)
    (he : ∀ a ∈ s, ∀ a' ∈ s, f (g a) = f (g a'))
    {a a'} (ha : a ∈ s) (ha' : a' ∈ s) : g a = g a' 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} (hf : IsCoveringMap f) {A : Type u_3} [TopologicalSpace A] {s : Set A} (hs : IsPreconnected s) {g : A → E} (cont : ContinuousOn g s) (he : ∀ a ∈ s, ∀ a' ∈ s, f (g a) = f (g a')) {a a' : A} (ha : a ∈ s) (ha' : a' ∈ s)
Goal: g a = g a'
-- IsFiberBundle.isCoveringMap
protected theorem IsFiberBundle.isCoveringMap {F : Type*} [TopologicalSpace F] [DiscreteTopology F]
    (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f 
Arguments: {E : Type u_1} {X : Type u_2} [TopologicalSpace E] [TopologicalSpace X] {f : E → X} {F : Type u_3} [TopologicalSpace F] [DiscreteTopology F] (hf : ∀ (x : X), ∃ e, x ∈ e.baseSet)
Goal: IsCoveringMap f
-- FiberBundle.isCoveringMap
protected theorem FiberBundle.isCoveringMap {F : Type*} {E : X → Type*} [TopologicalSpace F]
    [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]
    [FiberBundle F E] : IsCoveringMap (π F E) 
Arguments: {X : Type u_2} [TopologicalSpace X] {F : Type u_3} {E : X → Type u_4} [TopologicalSpace F] [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [(x : X) → TopologicalSpace (E x)] [FiberBundle F E]
Goal: IsCoveringMap Bundle.TotalSpace.proj
-- IsComplete.isClosed
theorem IsComplete.isClosed [UniformSpace α] [T0Space α] {s : Set α} (h : IsComplete s) :
    IsClosed s 
Arguments: {α : Type u_1} [UniformSpace α] [T0Space α] {s : Set α} (h : IsComplete s)
Goal: IsClosed s
-- UniformEmbedding.toClosedEmbedding
theorem UniformEmbedding.toClosedEmbedding [UniformSpace α] [UniformSpace β] [CompleteSpace α]
    [T0Space β] {f : α → β} (hf : UniformEmbedding f) :
    ClosedEmbedding f 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace α] [UniformSpace β] [CompleteSpace α] [T0Space β] {f : α → β} (hf : UniformEmbedding f)
Goal: ClosedEmbedding f
-- DenseInducing.continuous_extend_of_cauchy
theorem continuous_extend_of_cauchy {e : α → β} {f : α → γ} (de : DenseInducing e)
    (h : ∀ b : β, Cauchy (map f (comap e <| 𝓝 b))) : Continuous (de.extend f) 
Arguments: {α : Type u_1} [TopologicalSpace α] {β : Type u_3} [TopologicalSpace β] {γ : Type u_4} [UniformSpace γ] [CompleteSpace γ] [T0Space γ] {e : α → β} {f : α → γ} (de : DenseInducing e) (h : ∀ (b : β), Cauchy (Filter.map f (Filter.comap e (𝓝 b))))
Goal: Continuous (de.extend f)
-- Pi.uniformSpace_eq
lemma Pi.uniformSpace_eq :
    Pi.uniformSpace α = ⨅ i, UniformSpace.comap (eval i) (U i) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)]
Goal: Pi.uniformSpace α = ⨅ i, UniformSpace.comap (Function.eval i) (U i)
-- Pi.uniformity
theorem Pi.uniformity :
    𝓤 (∀ i, α i) = ⨅ i : ι, (Filter.comap fun a => (a.1 i, a.2 i)) (𝓤 (α i)) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)]
Goal: 𝓤 ((i : ι) → α i) = ⨅ i, Filter.comap (fun a => (a.1 i, a.2 i)) (𝓤 (α i))
-- uniformContinuous_pi
theorem uniformContinuous_pi {β : Type*} [UniformSpace β] {f : β → ∀ i, α i} :
    UniformContinuous f ↔ ∀ i, UniformContinuous fun x => f x i 
Arguments: {ι : Type u_1} {α : ι → Type u} [U : (i : ι) → UniformSpace (α i)] {β : Type u_4} [UniformSpace β] {f : β → (i : ι) → α i}
Goal: UniformContinuous f ↔ ∀ (i : ι), UniformContinuous fun x => f x i
-- Pi.uniformContinuous_proj
theorem Pi.uniformContinuous_proj (i : ι) : UniformContinuous fun a : ∀ i : ι, α i => a i 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (i : ι)
Goal: UniformContinuous fun a => a i
-- Pi.uniformContinuous_precomp'
theorem Pi.uniformContinuous_precomp' (φ : ι' → ι) :
    UniformContinuous (fun (f : (∀ i, α i)) (j : ι') ↦ f (φ j)) 
Arguments: {ι : Type u_1} {ι' : Type u_2} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (φ : ι' → ι)
Goal: UniformContinuous fun f j => f (φ j)
-- Pi.uniformContinuous_precomp
theorem Pi.uniformContinuous_precomp (φ : ι' → ι) :
    UniformContinuous (· ∘ φ : (ι → β) → (ι' → β)) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {β : Type u_3} [UniformSpace β] (φ : ι' → ι)
Goal: UniformContinuous fun x => x ∘ φ
-- Pi.uniformContinuous_postcomp'
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)) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] {β : ι → Type u_4} [(i : ι) → UniformSpace (β i)] {g : (i : ι) → α i → β i} (hg : ∀ (i : ι), UniformContinuous (g i))
Goal: UniformContinuous fun f i => g i (f i)
-- Pi.uniformContinuous_postcomp
theorem Pi.uniformContinuous_postcomp {α : Type*} [UniformSpace α] {g : α → β}
    (hg : UniformContinuous g) : UniformContinuous (g ∘ · : (ι → α) → (ι → β)) 
Arguments: {ι : Type u_1} {β : Type u_3} [UniformSpace β] {α : Type u_4} [UniformSpace α] {g : α → β} (hg : UniformContinuous g)
Goal: UniformContinuous fun x => g ∘ x
-- Pi.uniformSpace_comap_precomp'
lemma Pi.uniformSpace_comap_precomp' (φ : ι' → ι) :
    UniformSpace.comap (fun g i' ↦ g (φ i')) (Pi.uniformSpace (fun i' ↦ α (φ i'))) =
    ⨅ i', UniformSpace.comap (eval (φ i')) (U (φ i')) 
Arguments: {ι : Type u_1} {ι' : Type u_2} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (φ : ι' → ι)
Goal: UniformSpace.comap (fun g i' => g (φ i')) (Pi.uniformSpace fun i' => α (φ i')) =
  ⨅ i', UniformSpace.comap (Function.eval (φ i')) (U (φ i'))
-- Pi.uniformSpace_comap_precomp
lemma Pi.uniformSpace_comap_precomp (φ : ι' → ι) :
    UniformSpace.comap (· ∘ φ) (Pi.uniformSpace (fun _ ↦ β)) =
    ⨅ i', UniformSpace.comap (eval (φ i')) ‹UniformSpace β› 
Arguments: {ι : Type u_1} {ι' : Type u_2} {β : Type u_3} [UniformSpace β] (φ : ι' → ι)
Goal: UniformSpace.comap (fun x => x ∘ φ) (Pi.uniformSpace fun x => β) = ⨅ i', UniformSpace.comap (Function.eval (φ i')) inst✝
-- Pi.uniformContinuous_restrict
lemma Pi.uniformContinuous_restrict (S : Set ι) :
    UniformContinuous (S.restrict : (∀ i : ι, α i) → (∀ i : S, α i)) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (S : Set ι)
Goal: UniformContinuous S.restrict
-- Pi.uniformSpace_comap_restrict
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) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (S : Set ι)
Goal: UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (Function.eval i) (U i)
-- cauchy_pi_iff
lemma cauchy_pi_iff [Nonempty ι] {l : Filter (∀ i, α i)} :
    Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] [Nonempty ι] {l : Filter ((i : ι) → α i)}
Goal: Cauchy l ↔ ∀ (i : ι), Cauchy (Filter.map (Function.eval i) l)
-- cauchy_pi_iff'
lemma cauchy_pi_iff' {l : Filter (∀ i, α i)} [l.NeBot] :
    Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] {l : Filter ((i : ι) → α i)} [l.NeBot]
Goal: Cauchy l ↔ ∀ (i : ι), Cauchy (Filter.map (Function.eval i) l)
-- Cauchy.pi
lemma Cauchy.pi [Nonempty ι] {l : ∀ i, Filter (α i)} (hl : ∀ i, Cauchy (l i)) :
    Cauchy (Filter.pi l) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] [Nonempty ι] {l : (i : ι) → Filter (α i)} (hl : ∀ (i : ι), Cauchy (l i))
Goal: Cauchy (Filter.pi l)
-- Pi.uniformSpace_comap_restrict_sUnion
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)) 
Arguments: {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (𝔖 : Set (Set ι))
Goal: UniformSpace.comap (⋃₀ 𝔖).restrict (Pi.uniformSpace fun i => α ↑i) =
  ⨅ S ∈ 𝔖, UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i)
-- CompleteSpace.iInf
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) 
Arguments: {ι : Type u_4} {X : Type u_5} {u : ι → UniformSpace X} (hu : ∀ (i : ι), CompleteSpace X) (ht : ∃ t, T2Space X ∧ ∀ (i : ι), UniformSpace.toTopologicalSpace ≤ t)
Goal: CompleteSpace X
-- Bundle.Trivial.inducing_toProd
theorem inducing_toProd : Inducing (TotalSpace.toProd B F) 
Arguments: (B : Type u_1) (F : Type u_2) [TopologicalSpace B] [TopologicalSpace F]
Goal: Inducing ⇑(Bundle.TotalSpace.toProd B F)
-- Bundle.Trivial.trivialization_source
@[simp]
theorem trivialization_source : (trivialization B F).source = univ 
Arguments: (B : Type u_1) (F : Type u_2) [TopologicalSpace B] [TopologicalSpace F]
Goal: (Bundle.Trivial.trivialization B F).source = Set.univ
-- Bundle.Trivial.trivialization_target
@[simp]
theorem trivialization_target : (trivialization B F).target = univ 
Arguments: (B : Type u_1) (F : Type u_2) [TopologicalSpace B] [TopologicalSpace F]
Goal: (Bundle.Trivial.trivialization B F).target = Set.univ
-- Bundle.Trivial.eq_trivialization
theorem eq_trivialization (e : Trivialization F (π F (Bundle.Trivial B F)))
    [i : MemTrivializationAtlas e] : e = trivialization B F 
Arguments: (B : Type u_1) (F : Type u_2) [TopologicalSpace B] [TopologicalSpace F] (e : Trivialization F Bundle.TotalSpace.proj) [i : MemTrivializationAtlas e]
Goal: e = Bundle.Trivial.trivialization B F
-- FiberBundle.Prod.inducing_diag
theorem FiberBundle.Prod.inducing_diag :
    Inducing (fun p ↦ (⟨p.1, p.2.1⟩, ⟨p.1, p.2.2⟩) :
      TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂) → TotalSpace F₁ E₁ × TotalSpace F₂ E₂) 
Arguments: {B : Type u_1} (F₁ : Type u_2) (E₁ : B → Type u_3) (F₂ : Type u_4) (E₂ : B → Type u_5) [TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
Goal: Inducing fun p => ({ proj := p.proj, snd := p.snd.1 }, { proj := p.proj, snd := p.snd.2 })
-- Trivialization.Prod.continuous_to_fun
theorem Prod.continuous_to_fun : ContinuousOn (Prod.toFun' e₁ e₂)
    (π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) 
Arguments: {B : Type u_1} [TopologicalSpace B] {F₁ : Type u_2} [TopologicalSpace F₁] {E₁ : B → Type u_3} [TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [TopologicalSpace F₂] {E₂ : B → Type u_5} [TopologicalSpace (Bundle.TotalSpace F₂ E₂)] {e₁ : Trivialization F₁ Bundle.TotalSpace.proj} {e₂ : Trivialization F₂ Bundle.TotalSpace.proj}
Goal: ContinuousOn (Trivialization.Prod.toFun' e₁ e₂) (Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))
-- Trivialization.Prod.left_inv
theorem Prod.left_inv {x : TotalSpace (F₁ × F₂) (E₁ ×ᵇ E₂)}
    (h : x ∈ π (F₁ × F₂) (E₁ ×ᵇ E₂) ⁻¹' (e₁.baseSet ∩ e₂.baseSet)) :
    Prod.invFun' e₁ e₂ (Prod.toFun' e₁ e₂ x) = x 
Arguments: {B : Type u_1} [TopologicalSpace B] {F₁ : Type u_2} [TopologicalSpace F₁] {E₁ : B → Type u_3} [TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [TopologicalSpace F₂] {E₂ : B → Type u_5} [TopologicalSpace (Bundle.TotalSpace F₂ E₂)] {e₁ : Trivialization F₁ Bundle.TotalSpace.proj} {e₂ : Trivialization F₂ Bundle.TotalSpace.proj} [(x : B) → Zero (E₁ x)] [(x : B) → Zero (E₂ x)] {x : Bundle.TotalSpace (F₁ × F₂) fun x => E₁ x × E₂ x} (h : x ∈ Bundle.TotalSpace.proj ⁻¹' (e₁.baseSet ∩ e₂.baseSet))
Goal: Trivialization.Prod.invFun' e₁ e₂ (Trivialization.Prod.toFun' e₁ e₂ x) = x
-- Trivialization.Prod.right_inv
theorem Prod.right_inv {x : B × F₁ × F₂}
    (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
    Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x 
Arguments: {B : Type u_1} [TopologicalSpace B] {F₁ : Type u_2} [TopologicalSpace F₁] {E₁ : B → Type u_3} [TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [TopologicalSpace F₂] {E₂ : B → Type u_5} [TopologicalSpace (Bundle.TotalSpace F₂ E₂)] {e₁ : Trivialization F₁ Bundle.TotalSpace.proj} {e₂ : Trivialization F₂ Bundle.TotalSpace.proj} [(x : B) → Zero (E₁ x)] [(x : B) → Zero (E₂ x)] {x : B × F₁ × F₂} (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ Set.univ)
Goal: Trivialization.Prod.toFun' e₁ e₂ (Trivialization.Prod.invFun' e₁ e₂ x) = x