ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.HasBasis.uniformContinuousOn_iff
theorem Filter.HasBasis.uniformContinuousOn_iff {ι'} [UniformSpace β] {p : ι → Prop}
    {s : ι → Set (α × α)} (ha : (𝓤 α).HasBasis p s) {q : ι' → Prop} {t : ι' → Set (β × β)}
    (hb : (𝓤 β).HasBasis q t) {f : α → β} {S : Set α} :
    UniformContinuousOn f S ↔
      ∀ i, q i → ∃ j, p j ∧ ∀ x, x ∈ S → ∀ y, y ∈ S → (x, y) ∈ s j → (f x, f y) ∈ t i 
Arguments: {α : Type ua} {β : Type ub} {ι : Sort u_1} [UniformSpace α] {ι' : Sort u_2} [UniformSpace β] {p : ι → Prop} {s : ι → Set (α × α)} (ha : (𝓤 α).HasBasis p s) {q : ι' → Prop} {t : ι' → Set (β × β)} (hb : (𝓤 β).HasBasis q t) {f : α → β} {S : Set α}
Goal: UniformContinuousOn f S ↔ ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ x ∈ S, ∀ y ∈ S, (x, y) ∈ s j → (f x, f y) ∈ t i
-- UniformSpace.le_def
protected theorem UniformSpace.le_def {u₁ u₂ : UniformSpace α} : u₁ ≤ u₂ ↔ 𝓤[u₁] ≤ 𝓤[u₂] 
Arguments: {α : Type ua} {u₁ u₂ : UniformSpace α}
Goal: u₁ ≤ u₂ ↔ 𝓤 α ≤ 𝓤 α
-- UniformSpace.sInf_le
protected theorem UniformSpace.sInf_le {tt : Set (UniformSpace α)} {t : UniformSpace α}
    (h : t ∈ tt) : sInf tt ≤ t 
Arguments: {α : Type ua} {tt : Set (UniformSpace α)} {t : UniformSpace α} (h : t ∈ tt)
Goal: sInf tt ≤ t
-- UniformSpace.le_sInf
protected theorem UniformSpace.le_sInf {tt : Set (UniformSpace α)} {t : UniformSpace α}
    (h : ∀ t' ∈ tt, t ≤ t') : t ≤ sInf tt 
Arguments: {α : Type ua} {tt : Set (UniformSpace α)} {t : UniformSpace α} (h : ∀ t' ∈ tt, t ≤ t')
Goal: t ≤ sInf tt
-- iInf_uniformity
theorem iInf_uniformity {ι : Sort*} {u : ι → UniformSpace α} : 𝓤[iInf u] = ⨅ i, 𝓤[u i] 
Arguments: {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}
Goal: 𝓤 α = ⨅ i, 𝓤 α
-- inf_uniformity
theorem inf_uniformity {u v : UniformSpace α} : 𝓤[u ⊓ v] = 𝓤[u] ⊓ 𝓤[v] 
Arguments: {α : Type ua} {u v : UniformSpace α}
Goal: 𝓤 α = 𝓤 α ⊓ 𝓤 α
-- bot_uniformity
lemma bot_uniformity : 𝓤[(⊥ : UniformSpace α)] = 𝓟 idRel 
Arguments: {α : Type ua}
Goal: 𝓤 α = 𝓟 idRel
-- top_uniformity
lemma top_uniformity : 𝓤[(⊤ : UniformSpace α)] = ⊤ 
Arguments: {α : Type ua}
Goal: 𝓤 α = ⊤
-- uniformity_comap
theorem uniformity_comap {_ : UniformSpace β} (f : α → β) :
    𝓤[UniformSpace.comap f ‹_›] = comap (Prod.map f f) (𝓤 β) 
Arguments: {α : Type ua} {β : Type ub}
Goal: ∀ {x : UniformSpace β} (f : α → β), 𝓤 α = Filter.comap (Prod.map f f) (𝓤 β)
-- uniformSpace_comap_id
@[simp]
theorem uniformSpace_comap_id {α : Type*} : UniformSpace.comap (id : α → α) = id 
Arguments: {α : Type u_2}
Goal: UniformSpace.comap id = id
-- UniformSpace.comap_comap
theorem UniformSpace.comap_comap {α β γ} {uγ : UniformSpace γ} {f : α → β} {g : β → γ} :
    UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ}
Goal: UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ)
-- UniformSpace.comap_inf
theorem UniformSpace.comap_inf {α γ} {u₁ u₂ : UniformSpace γ} {f : α → γ} :
    (u₁ ⊓ u₂).comap f = u₁.comap f ⊓ u₂.comap f 
Arguments: {α : Type u_2} {γ : Type u_3} {u₁ u₂ : UniformSpace γ} {f : α → γ}
Goal: UniformSpace.comap f (u₁ ⊓ u₂) = UniformSpace.comap f u₁ ⊓ UniformSpace.comap f u₂
-- UniformSpace.comap_iInf
theorem UniformSpace.comap_iInf {ι α γ} {u : ι → UniformSpace γ} {f : α → γ} :
    (⨅ i, u i).comap f = ⨅ i, (u i).comap f 
Arguments: {ι : Sort u_2} {α : Type u_3} {γ : Type u_4} {u : ι → UniformSpace γ} {f : α → γ}
Goal: UniformSpace.comap f (⨅ i, u i) = ⨅ i, UniformSpace.comap f (u i)
-- UniformSpace.comap_mono
theorem UniformSpace.comap_mono {α γ} {f : α → γ} :
    Monotone fun u : UniformSpace γ => u.comap f 
Arguments: {α : Type u_2} {γ : Type u_3} {f : α → γ}
Goal: Monotone fun u => UniformSpace.comap f u
-- uniformContinuous_iff
theorem uniformContinuous_iff {α β} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β} :
    UniformContinuous f ↔ uα ≤ uβ.comap f 
Arguments: {α : Type u_2} {β : Type u_3} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β}
Goal: UniformContinuous f ↔ uα ≤ UniformSpace.comap f uβ
-- le_iff_uniformContinuous_id
theorem le_iff_uniformContinuous_id {u v : UniformSpace α} :
    u ≤ v ↔ @UniformContinuous _ _ u v id 
Arguments: {α : Type ua} {u v : UniformSpace α}
Goal: u ≤ v ↔ UniformContinuous id
-- uniformContinuous_comap
theorem uniformContinuous_comap {f : α → β} [u : UniformSpace β] :
    @UniformContinuous α β (UniformSpace.comap f u) u f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} [u : UniformSpace β]
Goal: UniformContinuous f
-- uniformContinuous_comap'
theorem uniformContinuous_comap' {f : γ → β} {g : α → γ} [v : UniformSpace β] [u : UniformSpace α]
    (h : UniformContinuous (f ∘ g)) : @UniformContinuous α γ u (UniformSpace.comap f v) g 
Arguments: {α : Type ua} {β : Type ub} {γ : Type uc} {f : γ → β} {g : α → γ} [v : UniformSpace β] [u : UniformSpace α] (h : UniformContinuous (f ∘ g))
Goal: UniformContinuous g
-- UniformSpace.to_nhds_mono
theorem to_nhds_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) (a : α) :
    @nhds _ (@UniformSpace.toTopologicalSpace _ u₁) a ≤
      @nhds _ (@UniformSpace.toTopologicalSpace _ u₂) a 
Arguments: {α : Type ua} {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) (a : α)
Goal: 𝓝 a ≤ 𝓝 a
-- UniformSpace.toTopologicalSpace_mono
theorem toTopologicalSpace_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) :
    @UniformSpace.toTopologicalSpace _ u₁ ≤ @UniformSpace.toTopologicalSpace _ u₂ 
Arguments: {α : Type ua} {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂)
Goal: UniformSpace.toTopologicalSpace ≤ UniformSpace.toTopologicalSpace
-- UniformSpace.toTopologicalSpace_comap
theorem toTopologicalSpace_comap {f : α → β} {u : UniformSpace β} :
    @UniformSpace.toTopologicalSpace _ (UniformSpace.comap f u) =
      TopologicalSpace.induced f (@UniformSpace.toTopologicalSpace β u) 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u : UniformSpace β}
Goal: UniformSpace.toTopologicalSpace = TopologicalSpace.induced f UniformSpace.toTopologicalSpace
-- UniformSpace.uniformSpace_eq_bot
lemma uniformSpace_eq_bot {u : UniformSpace α} : u = ⊥ ↔ idRel ∈ 𝓤[u] 
Arguments: {α : Type ua} {u : UniformSpace α}
Goal: u = ⊥ ↔ idRel ∈ 𝓤 α
-- Filter.HasBasis.uniformSpace_eq_bot
protected lemma _root_.Filter.HasBasis.uniformSpace_eq_bot {ι p} {s : ι → Set (α × α)}
    {u : UniformSpace α} (h : 𝓤[u].HasBasis p s) :
    u = ⊥ ↔ ∃ i, p i ∧ Pairwise fun x y : α ↦ (x, y) ∉ s i 
Arguments: {α : Type ua} {ι : Sort u_2} {p : ι → Prop} {s : ι → Set (α × α)} {u : UniformSpace α} (h : (𝓤 α).HasBasis p s)
Goal: u = ⊥ ↔ ∃ i, p i ∧ Pairwise fun x y => (x, y) ∉ s i
-- UniformSpace.toTopologicalSpace_bot
theorem toTopologicalSpace_bot : @UniformSpace.toTopologicalSpace α ⊥ = ⊥ 
Arguments: {α : Type ua}
Goal: UniformSpace.toTopologicalSpace = ⊥
-- UniformSpace.toTopologicalSpace_top
theorem toTopologicalSpace_top : @UniformSpace.toTopologicalSpace α ⊤ = ⊤ 
Arguments: {α : Type ua}
Goal: UniformSpace.toTopologicalSpace = ⊤
-- UniformSpace.toTopologicalSpace_iInf
theorem toTopologicalSpace_iInf {ι : Sort*} {u : ι → UniformSpace α} :
    (iInf u).toTopologicalSpace = ⨅ i, (u i).toTopologicalSpace 
Arguments: {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}
Goal: UniformSpace.toTopologicalSpace = ⨅ i, UniformSpace.toTopologicalSpace
-- UniformSpace.toTopologicalSpace_sInf
theorem toTopologicalSpace_sInf {s : Set (UniformSpace α)} :
    (sInf s).toTopologicalSpace = ⨅ i ∈ s, @UniformSpace.toTopologicalSpace α i 
Arguments: {α : Type ua} {s : Set (UniformSpace α)}
Goal: UniformSpace.toTopologicalSpace = ⨅ i ∈ s, UniformSpace.toTopologicalSpace
-- UniformSpace.toTopologicalSpace_inf
theorem toTopologicalSpace_inf {u v : UniformSpace α} :
    (u ⊓ v).toTopologicalSpace = u.toTopologicalSpace ⊓ v.toTopologicalSpace 
Arguments: {α : Type ua} {u v : UniformSpace α}
Goal: UniformSpace.toTopologicalSpace = UniformSpace.toTopologicalSpace ⊓ UniformSpace.toTopologicalSpace
-- UniformContinuous.continuous
theorem UniformContinuous.continuous [UniformSpace α] [UniformSpace β] {f : α → β}
    (hf : UniformContinuous f) : Continuous f 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β] {f : α → β} (hf : UniformContinuous f)
Goal: Continuous f
-- UniformContinuous.inf_rng
theorem UniformContinuous.inf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ u₃ : UniformSpace β}
    (h₁ : UniformContinuous[u₁, u₂] f) (h₂ : UniformContinuous[u₁, u₃] f) :
    UniformContinuous[u₁, u₂ ⊓ u₃] f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u₁ : UniformSpace α} {u₂ u₃ : UniformSpace β} (h₁ : UniformContinuous f) (h₂ : UniformContinuous f)
Goal: UniformContinuous f
-- UniformContinuous.inf_dom_left
theorem UniformContinuous.inf_dom_left {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β}
    (hf : UniformContinuous[u₁, u₃] f) : UniformContinuous[u₁ ⊓ u₂, u₃] f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β} (hf : UniformContinuous f)
Goal: UniformContinuous f
-- UniformContinuous.inf_dom_right
theorem UniformContinuous.inf_dom_right {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β}
    (hf : UniformContinuous[u₂, u₃] f) : UniformContinuous[u₁ ⊓ u₂, u₃] f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β} (hf : UniformContinuous f)
Goal: UniformContinuous f
-- uniformContinuous_sInf_dom
theorem uniformContinuous_sInf_dom {f : α → β} {u₁ : Set (UniformSpace α)} {u₂ : UniformSpace β}
    {u : UniformSpace α} (h₁ : u ∈ u₁) (hf : UniformContinuous[u, u₂] f) :
    UniformContinuous[sInf u₁, u₂] f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u₁ : Set (UniformSpace α)} {u₂ : UniformSpace β} {u : UniformSpace α} (h₁ : u ∈ u₁) (hf : UniformContinuous f)
Goal: UniformContinuous f
-- uniformContinuous_sInf_rng
theorem uniformContinuous_sInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : Set (UniformSpace β)} :
    UniformContinuous[u₁, sInf u₂] f ↔ ∀ u ∈ u₂, UniformContinuous[u₁, u] f 
Arguments: {α : Type ua} {β : Type ub} {f : α → β} {u₁ : UniformSpace α} {u₂ : Set (UniformSpace β)}
Goal: UniformContinuous f ↔ ∀ u ∈ u₂, UniformContinuous f
-- uniformContinuous_iInf_dom
theorem uniformContinuous_iInf_dom {f : α → β} {u₁ : ι → UniformSpace α} {u₂ : UniformSpace β}
    {i : ι} (hf : UniformContinuous[u₁ i, u₂] f) : UniformContinuous[iInf u₁, u₂] f 
Arguments: {α : Type ua} {β : Type ub} {ι : Sort u_1} {f : α → β} {u₁ : ι → UniformSpace α} {u₂ : UniformSpace β} {i : ι} (hf : UniformContinuous f)
Goal: UniformContinuous f
-- uniformContinuous_iInf_rng
theorem uniformContinuous_iInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : ι → UniformSpace β} :
    UniformContinuous[u₁, iInf u₂] f ↔ ∀ i, UniformContinuous[u₁, u₂ i] f 
Arguments: {α : Type ua} {β : Type ub} {ι : Sort u_1} {f : α → β} {u₁ : UniformSpace α} {u₂ : ι → UniformSpace β}
Goal: UniformContinuous f ↔ ∀ (i : ι), UniformContinuous f
-- discreteTopology_of_discrete_uniformity
theorem discreteTopology_of_discrete_uniformity [hα : UniformSpace α] (h : uniformity α = 𝓟 idRel) :
    DiscreteTopology α 
Arguments: {α : Type ua} [hα : UniformSpace α] (h : 𝓤 α = 𝓟 idRel)
Goal: DiscreteTopology α
-- uniformContinuous_ofMul
theorem uniformContinuous_ofMul : UniformContinuous (ofMul : α → Additive α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous ⇑Additive.ofMul
-- uniformContinuous_toMul
theorem uniformContinuous_toMul : UniformContinuous (toMul : Additive α → α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous ⇑Additive.toMul
-- uniformContinuous_ofAdd
theorem uniformContinuous_ofAdd : UniformContinuous (ofAdd : α → Multiplicative α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous ⇑Multiplicative.ofAdd
-- uniformContinuous_toAdd
theorem uniformContinuous_toAdd : UniformContinuous (toAdd : Multiplicative α → α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous ⇑Multiplicative.toAdd
-- uniformity_additive
theorem uniformity_additive : 𝓤 (Additive α) = (𝓤 α).map (Prod.map ofMul ofMul) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: 𝓤 (Additive α) = Filter.map (Prod.map ⇑Additive.ofMul ⇑Additive.ofMul) (𝓤 α)
-- uniformity_multiplicative
theorem uniformity_multiplicative : 𝓤 (Multiplicative α) = (𝓤 α).map (Prod.map ofAdd ofAdd) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: 𝓤 (Multiplicative α) = Filter.map (Prod.map ⇑Multiplicative.ofAdd ⇑Multiplicative.ofAdd) (𝓤 α)
-- uniformity_subtype
theorem uniformity_subtype {p : α → Prop} [UniformSpace α] :
    𝓤 (Subtype p) = comap (fun q : Subtype p × Subtype p => (q.1.1, q.2.1)) (𝓤 α) 
Arguments: {α : Type ua} {p : α → Prop} [UniformSpace α]
Goal: 𝓤 (Subtype p) = Filter.comap (fun q => (↑q.1, ↑q.2)) (𝓤 α)
-- uniformity_setCoe
theorem uniformity_setCoe {s : Set α} [UniformSpace α] :
    𝓤 s = comap (Prod.map ((↑) : s → α) ((↑) : s → α)) (𝓤 α) 
Arguments: {α : Type ua} {s : Set α} [UniformSpace α]
Goal: 𝓤 ↑s = Filter.comap (Prod.map Subtype.val Subtype.val) (𝓤 α)
-- map_uniformity_set_coe
theorem map_uniformity_set_coe {s : Set α} [UniformSpace α] :
    map (Prod.map (↑) (↑)) (𝓤 s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s) 
Arguments: {α : Type ua} {s : Set α} [UniformSpace α]
Goal: Filter.map (Prod.map Subtype.val Subtype.val) (𝓤 ↑s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s)
-- uniformContinuous_subtype_val
theorem uniformContinuous_subtype_val {p : α → Prop} [UniformSpace α] :
    UniformContinuous (Subtype.val : { a : α // p a } → α) 
Arguments: {α : Type ua} {p : α → Prop} [UniformSpace α]
Goal: UniformContinuous Subtype.val
-- UniformContinuous.subtype_mk
theorem UniformContinuous.subtype_mk {p : α → Prop} [UniformSpace α] [UniformSpace β] {f : β → α}
    (hf : UniformContinuous f) (h : ∀ x, p (f x)) :
    UniformContinuous (fun x => ⟨f x, h x⟩ : β → Subtype p) 
Arguments: {α : Type ua} {β : Type ub} {p : α → Prop} [UniformSpace α] [UniformSpace β] {f : β → α} (hf : UniformContinuous f) (h : ∀ (x : β), p (f x))
Goal: UniformContinuous fun x => ⟨f x, ⋯⟩
-- uniformContinuousOn_iff_restrict
theorem uniformContinuousOn_iff_restrict [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α} :
    UniformContinuousOn f s ↔ UniformContinuous (s.restrict f) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α}
Goal: UniformContinuousOn f s ↔ UniformContinuous (s.restrict f)
-- tendsto_of_uniformContinuous_subtype
theorem tendsto_of_uniformContinuous_subtype [UniformSpace α] [UniformSpace β] {f : α → β}
    {s : Set α} {a : α} (hf : UniformContinuous fun x : s => f x.val) (ha : s ∈ 𝓝 a) :
    Tendsto f (𝓝 a) (𝓝 (f a)) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α} {a : α} (hf : UniformContinuous fun x => f ↑x) (ha : s ∈ 𝓝 a)
Goal: Filter.Tendsto f (𝓝 a) (𝓝 (f a))
-- UniformContinuousOn.continuousOn
theorem UniformContinuousOn.continuousOn [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α}
    (h : UniformContinuousOn f s) : ContinuousOn f s 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α} (h : UniformContinuousOn f s)
Goal: ContinuousOn f s
-- uniformity_addOpposite
@[to_additive]
theorem uniformity_mulOpposite [UniformSpace α] :
    𝓤 αᵐᵒᵖ = comap (fun q : αᵐᵒᵖ × αᵐᵒᵖ => (q.1.unop, q.2.unop)) (𝓤 α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: 𝓤 αᵃᵒᵖ = Filter.comap (fun q => (AddOpposite.unop q.1, AddOpposite.unop q.2)) (𝓤 α)
-- uniformity_mulOpposite
@[to_additive]
theorem uniformity_mulOpposite [UniformSpace α] :
    𝓤 αᵐᵒᵖ = comap (fun q : αᵐᵒᵖ × αᵐᵒᵖ => (q.1.unop, q.2.unop)) (𝓤 α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: 𝓤 αᵐᵒᵖ = Filter.comap (fun q => (MulOpposite.unop q.1, MulOpposite.unop q.2)) (𝓤 α)
-- comap_uniformity_addOpposite
@[to_additive (attr := simp)]
theorem comap_uniformity_mulOpposite [UniformSpace α] :
    comap (fun p : α × α => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α 
Arguments: {α : Type ua} [UniformSpace α]
Goal: Filter.comap (fun p => (AddOpposite.op p.1, AddOpposite.op p.2)) (𝓤 αᵃᵒᵖ) = 𝓤 α
-- comap_uniformity_mulOpposite
@[to_additive (attr := simp)]
theorem comap_uniformity_mulOpposite [UniformSpace α] :
    comap (fun p : α × α => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α 
Arguments: {α : Type ua} [UniformSpace α]
Goal: Filter.comap (fun p => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α
-- MulOpposite.uniformContinuous_unop
@[to_additive]
theorem uniformContinuous_unop [UniformSpace α] : UniformContinuous (unop : αᵐᵒᵖ → α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous MulOpposite.unop
-- AddOpposite.uniformContinuous_unop
@[to_additive]
theorem uniformContinuous_unop [UniformSpace α] : UniformContinuous (unop : αᵐᵒᵖ → α) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous AddOpposite.unop
-- MulOpposite.uniformContinuous_op
@[to_additive]
theorem uniformContinuous_op [UniformSpace α] : UniformContinuous (op : α → αᵐᵒᵖ) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous MulOpposite.op
-- AddOpposite.uniformContinuous_op
@[to_additive]
theorem uniformContinuous_op [UniformSpace α] : UniformContinuous (op : α → αᵐᵒᵖ) 
Arguments: {α : Type ua} [UniformSpace α]
Goal: UniformContinuous AddOpposite.op
-- uniformity_prod
theorem uniformity_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) =
      ((𝓤 α).comap fun p : (α × β) × α × β => (p.1.1, p.2.1)) ⊓
        (𝓤 β).comap fun p : (α × β) × α × β => (p.1.2, p.2.2) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: 𝓤 (α × β) = Filter.comap (fun p => (p.1.1, p.2.1)) (𝓤 α) ⊓ Filter.comap (fun p => (p.1.2, p.2.2)) (𝓤 β)
-- uniformity_prod_eq_comap_prod
theorem uniformity_prod_eq_comap_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) =
      comap (fun p : (α × β) × α × β => ((p.1.1, p.2.1), (p.1.2, p.2.2))) (𝓤 α ×ˢ 𝓤 β) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: 𝓤 (α × β) = Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 β)
-- uniformity_prod_eq_prod
theorem uniformity_prod_eq_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) = map (fun p : (α × α) × β × β => ((p.1.1, p.2.1), (p.1.2, p.2.2))) (𝓤 α ×ˢ 𝓤 β) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: 𝓤 (α × β) = Filter.map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 β)
-- mem_uniformity_of_uniformContinuous_invariant
theorem mem_uniformity_of_uniformContinuous_invariant [UniformSpace α] [UniformSpace β]
    {s : Set (β × β)} {f : α → α → β} (hf : UniformContinuous fun p : α × α => f p.1 p.2)
    (hs : s ∈ 𝓤 β) : ∃ u ∈ 𝓤 α, ∀ a b c, (a, b) ∈ u → (f a c, f b c) ∈ s 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β] {s : Set (β × β)} {f : α → α → β} (hf : UniformContinuous fun p => f p.1 p.2) (hs : s ∈ 𝓤 β)
Goal: ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
-- mem_uniform_prod
theorem mem_uniform_prod [t₁ : UniformSpace α] [t₂ : UniformSpace β] {a : Set (α × α)}
    {b : Set (β × β)} (ha : a ∈ 𝓤 α) (hb : b ∈ 𝓤 β) :
    { p : (α × β) × α × β | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b } ∈ 𝓤 (α × β) 
Arguments: {α : Type ua} {β : Type ub} [t₁ : UniformSpace α] [t₂ : UniformSpace β] {a : Set (α × α)} {b : Set (β × β)} (ha : a ∈ 𝓤 α) (hb : b ∈ 𝓤 β)
Goal: {p | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b} ∈ 𝓤 (α × β)
-- tendsto_prod_uniformity_fst
theorem tendsto_prod_uniformity_fst [UniformSpace α] [UniformSpace β] :
    Tendsto (fun p : (α × β) × α × β => (p.1.1, p.2.1)) (𝓤 (α × β)) (𝓤 α) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: Filter.Tendsto (fun p => (p.1.1, p.2.1)) (𝓤 (α × β)) (𝓤 α)
-- tendsto_prod_uniformity_snd
theorem tendsto_prod_uniformity_snd [UniformSpace α] [UniformSpace β] :
    Tendsto (fun p : (α × β) × α × β => (p.1.2, p.2.2)) (𝓤 (α × β)) (𝓤 β) 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: Filter.Tendsto (fun p => (p.1.2, p.2.2)) (𝓤 (α × β)) (𝓤 β)
-- uniformContinuous_fst
theorem uniformContinuous_fst [UniformSpace α] [UniformSpace β] :
    UniformContinuous fun p : α × β => p.1 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: UniformContinuous fun p => p.1
-- uniformContinuous_snd
theorem uniformContinuous_snd [UniformSpace α] [UniformSpace β] :
    UniformContinuous fun p : α × β => p.2 
Arguments: {α : Type ua} {β : Type ub} [UniformSpace α] [UniformSpace β]
Goal: UniformContinuous fun p => p.2
-- UniformContinuous.prod_mk
theorem UniformContinuous.prod_mk {f₁ : α → β} {f₂ : α → γ} (h₁ : UniformContinuous f₁)
    (h₂ : UniformContinuous f₂) : UniformContinuous fun a => (f₁ a, f₂ a) 
Arguments: {α : Type ua} {β : Type ub} {γ : Type uc} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f₁ : α → β} {f₂ : α → γ} (h₁ : UniformContinuous f₁) (h₂ : UniformContinuous f₂)
Goal: UniformContinuous fun a => (f₁ a, f₂ a)
-- UniformContinuous.prod_mk_left
theorem UniformContinuous.prod_mk_left {f : α × β → γ} (h : UniformContinuous f) (b) :
    UniformContinuous fun a => f (a, b) 
Arguments: {α : Type ua} {β : Type ub} {γ : Type uc} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f : α × β → γ} (h : UniformContinuous f) (b : β)
Goal: UniformContinuous fun a => f (a, b)
-- UniformContinuous.prod_mk_right
theorem UniformContinuous.prod_mk_right {f : α × β → γ} (h : UniformContinuous f) (a) :
    UniformContinuous fun b => f (a, b) 
Arguments: {α : Type ua} {β : Type ub} {γ : Type uc} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f : α × β → γ} (h : UniformContinuous f) (a : α)
Goal: UniformContinuous fun b => f (a, b)
-- UniformContinuous.prod_map
theorem UniformContinuous.prod_map [UniformSpace δ] {f : α → γ} {g : β → δ}
    (hf : UniformContinuous f) (hg : UniformContinuous g) : UniformContinuous (Prod.map f g) 
Arguments: {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] {f : α → γ} {g : β → δ} (hf : UniformContinuous f) (hg : UniformContinuous g)
Goal: UniformContinuous (Prod.map f g)
-- toTopologicalSpace_prod
theorem toTopologicalSpace_prod {α} {β} [u : UniformSpace α] [v : UniformSpace β] :
    @UniformSpace.toTopologicalSpace (α × β) instUniformSpaceProd =
      @instTopologicalSpaceProd α β u.toTopologicalSpace v.toTopologicalSpace 
Arguments: {α : Type u_2} {β : Type u_3} [u : UniformSpace α] [v : UniformSpace β]
Goal: UniformSpace.toTopologicalSpace = instTopologicalSpaceProd
-- uniformContinuous_inf_dom_left₂
theorem uniformContinuous_inf_dom_left₂ {α β γ} {f : α → β → γ} {ua1 ua2 : UniformSpace α}
    {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ}
    (h : by haveI := ua1; haveI := ub1; exact UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := ua1 ⊓ ua2; haveI := ub1 ⊓ ub2
      exact UniformContinuous fun p : α × β => f p.1 p.2 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {f : α → β → γ} {ua1 ua2 : UniformSpace α} {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ} (h : UniformContinuous fun p => f p.1 p.2)
Goal: UniformContinuous fun p => f p.1 p.2
-- uniformContinuous_inf_dom_right₂
theorem uniformContinuous_inf_dom_right₂ {α β γ} {f : α → β → γ} {ua1 ua2 : UniformSpace α}
    {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ}
    (h : by haveI := ua2; haveI := ub2; exact UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := ua1 ⊓ ua2; haveI := ub1 ⊓ ub2
      exact UniformContinuous fun p : α × β => f p.1 p.2 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {f : α → β → γ} {ua1 ua2 : UniformSpace α} {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ} (h : UniformContinuous fun p => f p.1 p.2)
Goal: UniformContinuous fun p => f p.1 p.2
-- uniformContinuous_sInf_dom₂
theorem uniformContinuous_sInf_dom₂ {α β γ} {f : α → β → γ} {uas : Set (UniformSpace α)}
    {ubs : Set (UniformSpace β)} {ua : UniformSpace α} {ub : UniformSpace β} {uc : UniformSpace γ}
    (ha : ua ∈ uas) (hb : ub ∈ ubs) (hf : UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := sInf uas; haveI := sInf ubs
      exact @UniformContinuous _ _ _ uc fun p : α × β => f p.1 p.2 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {f : α → β → γ} {uas : Set (UniformSpace α)} {ubs : Set (UniformSpace β)} {ua : UniformSpace α} {ub : UniformSpace β} {uc : UniformSpace γ} (ha : ua ∈ uas) (hb : ub ∈ ubs) (hf : UniformContinuous fun p => f p.1 p.2)
Goal: UniformContinuous fun p => f p.1 p.2