l3lab/ntp-mathlib huggingface dataset:
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    

Proof state:
case refine'_1
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
⊢ ∃ t ⊆ X, IsOpen t ∧ f ∈ t

Next tactic:
have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
⊢ X ∈ FilterBasis.filter (compactConvergenceFilterBasis f)

Next tactic:
rw [← nhds_compactConvergence]
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
⊢ X ∈ 𝓝 f

Next tactic:
exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    

Proof state:
case refine'_1
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
hXf : X ∈ FilterBasis.filter (compactConvergenceFilterBasis f)
⊢ ∃ t ⊆ X, IsOpen t ∧ f ∈ t

Next tactic:
obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    

Proof state:
case refine'_1.intro.intro.intro.mk.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
K : Set α
V : Set (β × β)
hK : IsCompact (K, V).1
hV : (K, V).2 ∈ 𝓤 β
hXf : (fun KV => compactConvNhd KV.1 KV.2 f) (K, V) ⊆ X
⊢ ∃ t ⊆ X, IsOpen t ∧ f ∈ t

Next tactic:
obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    

Proof state:
case refine'_1.intro.intro.intro.mk.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
K : Set α
V : Set (β × β)
hK : IsCompact (K, V).1
hV : (K, V).2 ∈ 𝓤 β
hXf : (fun KV => compactConvNhd KV.1 KV.2 f) (K, V) ⊆ X
ι : Type u₁
hι : Fintype ι
C : ι → Set α
hC : ∀ (i : ι), IsCompact (C i)
U : ι → Set β
hU : ∀ (i : ι), IsOpen (U i)
h₁ : f ∈ ⋂ i, CompactOpen.gen (C i) (U i)
h₂ : ⋂ i, CompactOpen.gen (C i) (U i) ⊆ compactConvNhd (K, V).1 (K, V).2 f
⊢ ∃ t ⊆ X, IsOpen t ∧ f ∈ t

Next tactic:
haveI := hι
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    haveI := hι
    

Proof state:
case refine'_1.intro.intro.intro.mk.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f✝ : C(α, β)
X : Set C(α, β)
hX : IsOpen X
f : C(α, β)
hf : f ∈ X
K : Set α
V : Set (β × β)
hK : IsCompact (K, V).1
hV : (K, V).2 ∈ 𝓤 β
hXf : (fun KV => compactConvNhd KV.1 KV.2 f) (K, V) ⊆ X
ι : Type u₁
hι : Fintype ι
C : ι → Set α
hC : ∀ (i : ι), IsCompact (C i)
U : ι → Set β
hU : ∀ (i : ι), IsOpen (U i)
h₁ : f ∈ ⋂ i, CompactOpen.gen (C i) (U i)
h₂ : ⋂ i, CompactOpen.gen (C i) (U i) ⊆ compactConvNhd (K, V).1 (K, V).2 f
this : Fintype ι
⊢ ∃ t ⊆ X, IsOpen t ∧ f ∈ t

Next tactic:
exact
      ⟨⋂ i, CompactOpen.gen (C i) (U i), h₂.trans hXf,
        isOpen_iInter_of_finite fun i => ContinuousMap.isOpen_gen (hC i) (hU i), h₁⟩
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    haveI := hι
    exact
      ⟨⋂ i, CompactOpen.gen (C i) (U i), h₂.trans hXf,
        isOpen_iInter_of_finite fun i => ContinuousMap.isOpen_gen (hC i) (hU i), h₁⟩
  · 

Proof state:
case refine'_2
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ (TopologicalSpace.mkOfNhds fun f => FilterBasis.filter (compactConvergenceFilterBasis f)) ≤
    TopologicalSpace.generateFrom {m | ∃ s, ∃ (_ : IsCompact s), ∃ u, ∃ (_ : IsOpen u), m = CompactOpen.gen s u}

Next tactic:
simp only [TopologicalSpace.le_generateFrom_iff_subset_isOpen, and_imp, exists_prop,
      forall_exists_index, setOf_subset_setOf]
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    haveI := hι
    exact
      ⟨⋂ i, CompactOpen.gen (C i) (U i), h₂.trans hXf,
        isOpen_iInter_of_finite fun i => ContinuousMap.isOpen_gen (hC i) (hU i), h₁⟩
  · simp only [TopologicalSpace.le_generateFrom_iff_subset_isOpen, and_imp, exists_prop,
      forall_exists_index, setOf_subset_setOf]
    

Proof state:
case refine'_2
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ ∀ (a : Set C(α, β)) (x : Set α), IsCompact x → ∀ (x_1 : Set β), IsOpen x_1 → a = CompactOpen.gen x x_1 → IsOpen a

Next tactic:
rintro - K hK U hU rfl f hf
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    haveI := hι
    exact
      ⟨⋂ i, CompactOpen.gen (C i) (U i), h₂.trans hXf,
        isOpen_iInter_of_finite fun i => ContinuousMap.isOpen_gen (hC i) (hU i), h₁⟩
  · simp only [TopologicalSpace.le_generateFrom_iff_subset_isOpen, and_imp, exists_prop,
      forall_exists_index, setOf_subset_setOf]
    rintro - K hK U hU rfl f hf
    

Proof state:
case refine'_2
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f✝ : C(α, β)
K : Set α
hK : IsCompact K
U : Set β
hU : IsOpen U
f : C(α, β)
hf : f ∈ CompactOpen.gen K U
⊢ CompactOpen.gen K U ∈ (fun f => FilterBasis.filter (compactConvergenceFilterBasis f)) f

Next tactic:
obtain ⟨V, hV, _hV', hVf⟩ := compactConvNhd_subset_compactOpen f hK hU hf
/-- The compact-open topology is equal to the compact-convergence topology. -/
theorem compactOpen_eq_compactConvergence :
    ContinuousMap.compactOpen = (compactConvergenceTopology : TopologicalSpace C(α, β)) := by
  rw [compactConvergenceTopology, ContinuousMap.compactOpen]
  refine' le_antisymm _ _
  · refine' fun X hX => isOpen_iff_forall_mem_open.mpr fun f hf => _
    have hXf : X ∈ (compactConvergenceFilterBasis f).filter := by
      rw [← nhds_compactConvergence]
      exact @IsOpen.mem_nhds C(α, β) compactConvergenceTopology _ _ hX hf
    obtain ⟨-, ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩, hXf⟩ := hXf
    obtain ⟨ι, hι, C, hC, U, hU, h₁, h₂⟩ := iInter_compactOpen_gen_subset_compactConvNhd f hK hV
    haveI := hι
    exact
      ⟨⋂ i, CompactOpen.gen (C i) (U i), h₂.trans hXf,
        isOpen_iInter_of_finite fun i => ContinuousMap.isOpen_gen (hC i) (hU i), h₁⟩
  · simp only [TopologicalSpace.le_generateFrom_iff_subset_isOpen, and_imp, exists_prop,
      forall_exists_index, setOf_subset_setOf]
    rintro - K hK U hU rfl f hf
    obtain ⟨V, hV, _hV', hVf⟩ := compactConvNhd_subset_compactOpen f hK hU hf
    

Proof state:
case refine'_2.intro.intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f✝ : C(α, β)
K : Set α
hK : IsCompact K
U : Set β
hU : IsOpen U
f : C(α, β)
hf : f ∈ CompactOpen.gen K U
V : Set (β × β)
hV : V ∈ 𝓤 β
_hV' : IsOpen V
hVf : compactConvNhd K V f ⊆ CompactOpen.gen K U
⊢ CompactOpen.gen K U ∈ (fun f => FilterBasis.filter (compactConvergenceFilterBasis f)) f

Next tactic:
exact Filter.mem_of_superset (FilterBasis.mem_filter_of_mem _ ⟨⟨K, V⟩, ⟨hK, hV⟩, rfl⟩) hVf
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ HasBasis compactConvergenceUniformity (fun p => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
    {fg | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2}

Next tactic:
refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
  

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ DirectedOn ((fun KV => {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2}) ⁻¹'o fun x x_1 => x ≥ x_1)
    {KV | IsCompact KV.1 ∧ KV.2 ∈ 𝓤 β}

Next tactic:
rintro ⟨K₁, V₁⟩ ⟨hK₁, hV₁⟩ ⟨K₂, V₂⟩ ⟨hK₂, hV₂⟩
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
  rintro ⟨K₁, V₁⟩ ⟨hK₁, hV₁⟩ ⟨K₂, V₂⟩ ⟨hK₂, hV₂⟩
  

Proof state:
case mk.intro.mk.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
K₁ : Set α
V₁ : Set (β × β)
hK₁ : IsCompact (K₁, V₁).1
hV₁ : (K₁, V₁).2 ∈ 𝓤 β
K₂ : Set α
V₂ : Set (β × β)
hK₂ : IsCompact (K₂, V₂).1
hV₂ : (K₂, V₂).2 ∈ 𝓤 β
⊢ ∃ z ∈ {KV | IsCompact KV.1 ∧ KV.2 ∈ 𝓤 β},
    ((fun KV => {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2}) ⁻¹'o fun x x_1 => x ≥ x_1) (K₁, V₁) z ∧
      ((fun KV => {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2}) ⁻¹'o fun x x_1 => x ≥ x_1) (K₂, V₂) z

Next tactic:
refine' ⟨⟨K₁ ∪ K₂, V₁ ∩ V₂⟩, ⟨hK₁.union hK₂, Filter.inter_mem hV₁ hV₂⟩, _⟩
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
  rintro ⟨K₁, V₁⟩ ⟨hK₁, hV₁⟩ ⟨K₂, V₂⟩ ⟨hK₂, hV₂⟩
  refine' ⟨⟨K₁ ∪ K₂, V₁ ∩ V₂⟩, ⟨hK₁.union hK₂, Filter.inter_mem hV₁ hV₂⟩, _⟩
  

Proof state:
case mk.intro.mk.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
K₁ : Set α
V₁ : Set (β × β)
hK₁ : IsCompact (K₁, V₁).1
hV₁ : (K₁, V₁).2 ∈ 𝓤 β
K₂ : Set α
V₂ : Set (β × β)
hK₂ : IsCompact (K₂, V₂).1
hV₂ : (K₂, V₂).2 ∈ 𝓤 β
⊢ ((fun KV => {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2}) ⁻¹'o fun x x_1 => x ≥ x_1) (K₁, V₁) (K₁ ∪ K₂, V₁ ∩ V₂) ∧
    ((fun KV => {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2}) ⁻¹'o fun x x_1 => x ≥ x_1) (K₂, V₂) (K₁ ∪ K₂, V₁ ∩ V₂)

Next tactic:
simp only [le_eq_subset, Prod.forall, setOf_subset_setOf, ge_iff_le, Order.Preimage, ←
    forall_and, mem_inter_iff, mem_union]
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
  rintro ⟨K₁, V₁⟩ ⟨hK₁, hV₁⟩ ⟨K₂, V₂⟩ ⟨hK₂, hV₂⟩
  refine' ⟨⟨K₁ ∪ K₂, V₁ ∩ V₂⟩, ⟨hK₁.union hK₂, Filter.inter_mem hV₁ hV₂⟩, _⟩
  simp only [le_eq_subset, Prod.forall, setOf_subset_setOf, ge_iff_le, Order.Preimage, ←
    forall_and, mem_inter_iff, mem_union]
  

Proof state:
case mk.intro.mk.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
K₁ : Set α
V₁ : Set (β × β)
hK₁ : IsCompact (K₁, V₁).1
hV₁ : (K₁, V₁).2 ∈ 𝓤 β
K₂ : Set α
V₂ : Set (β × β)
hK₂ : IsCompact (K₂, V₂).1
hV₂ : (K₂, V₂).2 ∈ 𝓤 β
⊢ ∀ (x x_1 : C(α, β)),
    (∀ (x_2 : α), x_2 ∈ K₁ ∨ x_2 ∈ K₂ → (x x_2, x_1 x_2) ∈ V₁ ∧ (x x_2, x_1 x_2) ∈ V₂) →
      ∀ (x_3 : α), (x_3 ∈ K₁ → (x x_3, x_1 x_3) ∈ V₁) ∧ (x_3 ∈ K₂ → (x x_3, x_1 x_3) ∈ V₂)

Next tactic:
exact fun f g => forall_imp fun x => by tauto
theorem hasBasis_compactConvergenceUniformity_aux :
    HasBasis (@compactConvergenceUniformity α β _ _)
      (fun p : Set α × Set (β × β) => IsCompact p.1 ∧ p.2 ∈ 𝓤 β) fun p =>
      { fg : C(α, β) × C(α, β) | ∀ x ∈ p.1, (fg.1 x, fg.2 x) ∈ p.2 } := by
  refine' Filter.hasBasis_biInf_principal _ compactConvNhd_compact_entourage_nonempty
  rintro ⟨K₁, V₁⟩ ⟨hK₁, hV₁⟩ ⟨K₂, V₂⟩ ⟨hK₂, hV₂⟩
  refine' ⟨⟨K₁ ∪ K₂, V₁ ∩ V₂⟩, ⟨hK₁.union hK₂, Filter.inter_mem hV₁ hV₂⟩, _⟩
  simp only [le_eq_subset, Prod.forall, setOf_subset_setOf, ge_iff_le, Order.Preimage, ←
    forall_and, mem_inter_iff, mem_union]
  exact fun f g => forall_imp fun x => by 

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f✝ : C(α, β)
K₁ : Set α
V₁ : Set (β × β)
hK₁ : IsCompact (K₁, V₁).1
hV₁ : (K₁, V₁).2 ∈ 𝓤 β
K₂ : Set α
V₂ : Set (β × β)
hK₂ : IsCompact (K₂, V₂).1
hV₂ : (K₂, V₂).2 ∈ 𝓤 β
f g : C(α, β)
x : α
⊢ (x ∈ K₁ ∨ x ∈ K₂ → (f x, g x) ∈ V₁ ∧ (f x, g x) ∈ V₂) → (x ∈ K₁ → (f x, g x) ∈ V₁) ∧ (x ∈ K₂ → (f x, g x) ∈ V₂)

Next tactic:
tauto
/-- An intermediate lemma. Usually `ContinuousMap.mem_compactConvergence_entourage_iff` is more
useful. -/
theorem mem_compactConvergenceUniformity (X : Set (C(α, β) × C(α, β))) :
    X ∈ @compactConvergenceUniformity α β _ _ ↔
      ∃ (K : Set α) (V : Set (β × β)) (_hK : IsCompact K) (_hV : V ∈ 𝓤 β),
        { fg : C(α, β) × C(α, β) | ∀ x ∈ K, (fg.1 x, fg.2 x) ∈ V } ⊆ X := by
  

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
X : Set (C(α, β) × C(α, β))
⊢ X ∈ compactConvergenceUniformity ↔ ∃ K V, ∃ (_ : IsCompact K) (_ : V ∈ 𝓤 β), {fg | ∀ x ∈ K, (fg.1 x, fg.2 x) ∈ V} ⊆ X

Next tactic:
simp only [hasBasis_compactConvergenceUniformity_aux.mem_iff, exists_prop, Prod.exists,
    and_assoc]
/-- Note that we ensure the induced topology is definitionally the compact-open topology. -/
instance compactConvergenceUniformSpace : UniformSpace C(α, β)
    where
  uniformity := compactConvergenceUniformity
  refl := by
    

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ 𝓟 idRel ≤ compactConvergenceUniformity

Next tactic:
simp only [compactConvergenceUniformity, and_imp, Filter.le_principal_iff, Prod.forall,
      Filter.mem_principal, mem_setOf_eq, le_iInf_iff, idRel_subset]
/-- Note that we ensure the induced topology is definitionally the compact-open topology. -/
instance compactConvergenceUniformSpace : UniformSpace C(α, β)
    where
  uniformity := compactConvergenceUniformity
  refl := by
    simp only [compactConvergenceUniformity, and_imp, Filter.le_principal_iff, Prod.forall,
      Filter.mem_principal, mem_setOf_eq, le_iInf_iff, idRel_subset]
    

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ ∀ (a : Set α) (b : Set (β × β)), IsCompact a → b ∈ 𝓤 β → ∀ (a_3 : C(α, β)), ∀ x ∈ a, (a_3 x, a_3 x) ∈ b

Next tactic:
exact fun K V _hK hV f x _hx => refl_mem_uniformity hV
/-- Note that we ensure the induced topology is definitionally the compact-open topology. -/
instance compactConvergenceUniformSpace : UniformSpace C(α, β)
    where
  uniformity := compactConvergenceUniformity
  refl := by
    simp only [compactConvergenceUniformity, and_imp, Filter.le_principal_iff, Prod.forall,
      Filter.mem_principal, mem_setOf_eq, le_iInf_iff, idRel_subset]
    exact fun K V _hK hV f x _hx => refl_mem_uniformity hV
  symm := by
    

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ Tendsto Prod.swap compactConvergenceUniformity compactConvergenceUniformity

Next tactic:
simp only [compactConvergenceUniformity, and_imp, Prod.forall, mem_setOf_eq, Prod.fst_swap,
      Filter.tendsto_principal, Prod.snd_swap, Filter.tendsto_iInf]
/-- Note that we ensure the induced topology is definitionally the compact-open topology. -/
instance compactConvergenceUniformSpace : UniformSpace C(α, β)
    where
  uniformity := compactConvergenceUniformity
  refl := by
    simp only [compactConvergenceUniformity, and_imp, Filter.le_principal_iff, Prod.forall,
      Filter.mem_principal, mem_setOf_eq, le_iInf_iff, idRel_subset]
    exact fun K V _hK hV f x _hx => refl_mem_uniformity hV
  symm := by
    simp only [compactConvergenceUniformity, and_imp, Prod.forall, mem_setOf_eq, Prod.fst_swap,
      Filter.tendsto_principal, Prod.snd_swap, Filter.tendsto_iInf]
    

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
⊢ ∀ (a : Set α) (b : Set (β × β)),
    IsCompact a →
      b ∈ 𝓤 β →
        ∀ᶠ (a_3 : C(α, β) × C(α, β)) in
          ⨅ KV, ⨅ (_ : IsCompact KV.1 ∧ KV.2 ∈ 𝓤 β), 𝓟 {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2},
          ∀ x ∈ a, (a_3.2 x, a_3.1 x) ∈ b

Next tactic:
intro K V hK hV
/-- Note that we ensure the induced topology is definitionally the compact-open topology. -/
instance compactConvergenceUniformSpace : UniformSpace C(α, β)
    where
  uniformity := compactConvergenceUniformity
  refl := by
    simp only [compactConvergenceUniformity, and_imp, Filter.le_principal_iff, Prod.forall,
      Filter.mem_principal, mem_setOf_eq, le_iInf_iff, idRel_subset]
    exact fun K V _hK hV f x _hx => refl_mem_uniformity hV
  symm := by
    simp only [compactConvergenceUniformity, and_imp, Prod.forall, mem_setOf_eq, Prod.fst_swap,
      Filter.tendsto_principal, Prod.snd_swap, Filter.tendsto_iInf]
    intro K V hK hV
    

Proof state:
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V✝ : Set (β × β)
f : C(α, β)
K : Set α
V : Set (β × β)
hK : IsCompact K
hV : V ∈ 𝓤 β
⊢ ∀ᶠ (a : C(α, β) × C(α, β)) in ⨅ KV, ⨅ (_ : IsCompact KV.1 ∧ KV.2 ∈ 𝓤 β), 𝓟 {fg | ∀ x ∈ KV.1, (fg.1 x, fg.2 x) ∈ KV.2},
    ∀ x ∈ K, (a.2 x, a.1 x) ∈ V

Next tactic:
obtain ⟨V', hV', hsymm, hsub⟩ := symm_of_uniformity hV