l3lab/ntp-mathlib huggingface dataset:
theorem nhdsAdjoint_nhds {α : Type*} (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) a = pure a ⊔ f := by
  letI := nhdsAdjoint a f
  ext U
  rw [mem_nhds_iff]
  constructor
  · rintro ⟨t, htU, ht, hat⟩
    exact ⟨htU hat, mem_of_superset (ht hat) htU⟩
  · 

Proof state:
case a.mpr
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
⊢ U ∈ pure a ⊔ f → ∃ t ⊆ U, IsOpen t ∧ a ∈ t

Next tactic:
rintro ⟨haU, hU⟩
theorem nhdsAdjoint_nhds {α : Type*} (a : α) (f : Filter α) :
    @nhds α (nhdsAdjoint a f) a = pure a ⊔ f := by
  letI := nhdsAdjoint a f
  ext U
  rw [mem_nhds_iff]
  constructor
  · rintro ⟨t, htU, ht, hat⟩
    exact ⟨htU hat, mem_of_superset (ht hat) htU⟩
  · rintro ⟨haU, hU⟩
    

Proof state:
case a.mpr.intro
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
haU : U ∈ (pure a).sets
hU : U ∈ f.sets
⊢ ∃ t ⊆ U, IsOpen t ∧ a ∈ t

Next tactic:
exact ⟨U, Subset.rfl, fun _ => hU, haU⟩
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
⊢ 𝓝 b = pure b

Next tactic:
letI := nhdsAdjoint a f
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 b = pure b

Next tactic:
apply le_antisymm
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · 

Proof state:
case a
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 b ≤ pure b

Next tactic:
intro U hU
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · intro U hU
    

Proof state:
case a
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
hU : U ∈ pure b
⊢ U ∈ 𝓝 b

Next tactic:
rw [mem_nhds_iff]
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · intro U hU
    rw [mem_nhds_iff]
    

Proof state:
case a
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
hU : U ∈ pure b
⊢ ∃ t ⊆ U, IsOpen t ∧ b ∈ t

Next tactic:
use {b}
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · intro U hU
    rw [mem_nhds_iff]
    use {b}
    

Proof state:
case h
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
hU : U ∈ pure b
⊢ {b} ⊆ U ∧ IsOpen {b} ∧ b ∈ {b}

Next tactic:
simp only [and_true_iff, singleton_subset_iff, mem_singleton]
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · intro U hU
    rw [mem_nhds_iff]
    use {b}
    simp only [and_true_iff, singleton_subset_iff, mem_singleton]
    

Proof state:
case h
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
U : Set α
hU : U ∈ pure b
⊢ b ∈ U ∧ IsOpen {b}

Next tactic:
refine' ⟨hU, fun ha => (h.symm ha).elim⟩
theorem nhdsAdjoint_nhds_of_ne {α : Type*} (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b := by
  letI := nhdsAdjoint a f
  apply le_antisymm
  · intro U hU
    rw [mem_nhds_iff]
    use {b}
    simp only [and_true_iff, singleton_subset_iff, mem_singleton]
    refine' ⟨hU, fun ha => (h.symm ha).elim⟩
  · 

Proof state:
case a
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
b : α
h : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ pure b ≤ 𝓝 b

Next tactic:
exact @pure_le_nhds α (nhdsAdjoint a f) b
theorem isOpen_singleton_nhdsAdjoint {α : Type*} {a b : α} (f : Filter α) (hb : b ≠ a) :
    IsOpen[nhdsAdjoint a f] {b} := by
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
⊢ IsOpen {b}

Next tactic:
letI := nhdsAdjoint a f
theorem isOpen_singleton_nhdsAdjoint {α : Type*} {a b : α} (f : Filter α) (hb : b ≠ a) :
    IsOpen[nhdsAdjoint a f] {b} := by
  letI := nhdsAdjoint a f
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ IsOpen {b}

Next tactic:
rw [isOpen_singleton_iff_nhds_eq_pure]
theorem isOpen_singleton_nhdsAdjoint {α : Type*} {a b : α} (f : Filter α) (hb : b ≠ a) :
    IsOpen[nhdsAdjoint a f] {b} := by
  letI := nhdsAdjoint a f
  rw [isOpen_singleton_iff_nhds_eq_pure]
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 b = pure b

Next tactic:
exact nhdsAdjoint_nhds_of_ne a f hb
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b

Next tactic:
rw [le_iff_nhds]
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ (∀ (x : α), 𝓝 x ≤ 𝓝 x) ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b

Next tactic:
constructor
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · 

Proof state:
case mp
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ (∀ (x : α), 𝓝 x ≤ 𝓝 x) → 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b

Next tactic:
intro h
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    

Proof state:
case mp
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
⊢ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b

Next tactic:
constructor
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · 

Proof state:
case mp.left
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
⊢ 𝓝 a ≤ pure a ⊔ f

Next tactic:
specialize h a
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      

Proof state:
case mp.left
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : 𝓝 a ≤ 𝓝 a
⊢ 𝓝 a ≤ pure a ⊔ f

Next tactic:
rwa [nhdsAdjoint_nhds] at h
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · 

Proof state:
case mp.right
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
⊢ ∀ (b : α), b ≠ a → 𝓝 b = pure b

Next tactic:
intro b hb
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      

Proof state:
case mp.right
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
b : α
hb : b ≠ a
⊢ 𝓝 b = pure b

Next tactic:
apply le_antisymm _ (pure_le_nhds b)
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : ∀ (x : α), 𝓝 x ≤ 𝓝 x
b : α
hb : b ≠ a
⊢ 𝓝 b ≤ pure b

Next tactic:
specialize h b
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      specialize h b
      

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
b : α
hb : b ≠ a
h : 𝓝 b ≤ 𝓝 b
⊢ 𝓝 b ≤ pure b

Next tactic:
rwa [nhdsAdjoint_nhds_of_ne a f hb] at h
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      specialize h b
      rwa [nhdsAdjoint_nhds_of_ne a f hb] at h
  · 

Proof state:
case mpr
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ (𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → 𝓝 b = pure b) → ∀ (x : α), 𝓝 x ≤ 𝓝 x

Next tactic:
rintro ⟨h, h'⟩ b
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      specialize h b
      rwa [nhdsAdjoint_nhds_of_ne a f hb] at h
  · rintro ⟨h, h'⟩ b
    

Proof state:
case mpr.intro
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : 𝓝 a ≤ pure a ⊔ f
h' : ∀ (b : α), b ≠ a → 𝓝 b = pure b
b : α
⊢ 𝓝 b ≤ 𝓝 b

Next tactic:
by_cases hb : b = a
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      specialize h b
      rwa [nhdsAdjoint_nhds_of_ne a f hb] at h
  · rintro ⟨h, h'⟩ b
    by_cases hb : b = a
    · 

Proof state:
case pos
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : 𝓝 a ≤ pure a ⊔ f
h' : ∀ (b : α), b ≠ a → 𝓝 b = pure b
b : α
hb : b = a
⊢ 𝓝 b ≤ 𝓝 b

Next tactic:
rwa [hb, nhdsAdjoint_nhds]
theorem le_nhdsAdjoint_iff' {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → @nhds α t b = pure b := by
  rw [le_iff_nhds]
  constructor
  · intro h
    constructor
    · specialize h a
      rwa [nhdsAdjoint_nhds] at h
    · intro b hb
      apply le_antisymm _ (pure_le_nhds b)
      specialize h b
      rwa [nhdsAdjoint_nhds_of_ne a f hb] at h
  · rintro ⟨h, h'⟩ b
    by_cases hb : b = a
    · rwa [hb, nhdsAdjoint_nhds]
    · 

Proof state:
case neg
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
h : 𝓝 a ≤ pure a ⊔ f
h' : ∀ (b : α), b ≠ a → 𝓝 b = pure b
b : α
hb : ¬b = a
⊢ 𝓝 b ≤ 𝓝 b

Next tactic:
simp [nhdsAdjoint_nhds_of_ne a f hb, h' b hb]
theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → IsOpen[t] {b} := by
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → IsOpen {b}

Next tactic:
change _ ↔ _ ∧ ∀ b : α, b ≠ a → IsOpen {b}
theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → IsOpen[t] {b} := by
  change _ ↔ _ ∧ ∀ b : α, b ≠ a → IsOpen {b}
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ t ≤ nhdsAdjoint a f ↔ 𝓝 a ≤ pure a ⊔ f ∧ ∀ (b : α), b ≠ a → IsOpen {b}

Next tactic:
rw [le_nhdsAdjoint_iff', and_congr_right_iff]
theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → IsOpen[t] {b} := by
  change _ ↔ _ ∧ ∀ b : α, b ≠ a → IsOpen {b}
  rw [le_nhdsAdjoint_iff', and_congr_right_iff]
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
⊢ 𝓝 a ≤ pure a ⊔ f → ((∀ (b : α), b ≠ a → 𝓝 b = pure b) ↔ ∀ (b : α), b ≠ a → IsOpen {b})

Next tactic:
refine fun _ => forall_congr' fun b => ?_
theorem le_nhdsAdjoint_iff {α : Type*} (a : α) (f : Filter α) (t : TopologicalSpace α) :
    t ≤ nhdsAdjoint a f ↔ @nhds α t a ≤ pure a ⊔ f ∧ ∀ b, b ≠ a → IsOpen[t] {b} := by
  change _ ↔ _ ∧ ∀ b : α, b ≠ a → IsOpen {b}
  rw [le_nhdsAdjoint_iff', and_congr_right_iff]
  refine fun _ => forall_congr' fun b => ?_
  

Proof state:
α✝ : Type u
β : Type v
α : Type u_1
a : α
f : Filter α
t : TopologicalSpace α
x✝ : 𝓝 a ≤ pure a ⊔ f
b : α
⊢ b ≠ a → 𝓝 b = pure b ↔ b ≠ a → IsOpen {b}

Next tactic:
rw [@isOpen_singleton_iff_nhds_eq_pure α t b]
theorem continuous_induced_rng {g : γ → α} {t₂ : TopologicalSpace β} {t₁ : TopologicalSpace γ} :
    Continuous[t₁, induced f t₂] g ↔ Continuous[t₁, t₂] (f ∘ g) := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
g : γ → α
t₂ : TopologicalSpace β
t₁ : TopologicalSpace γ
⊢ Continuous g ↔ Continuous (f ∘ g)

Next tactic:
simp only [continuous_iff_le_induced, induced_compose]
theorem continuous_coinduced_dom {g : β → γ} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace γ} :
    Continuous[coinduced f t₁, t₂] g ↔ Continuous[t₁, t₂] (g ∘ f) := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
g : β → γ
t₁ : TopologicalSpace α
t₂ : TopologicalSpace γ
⊢ Continuous g ↔ Continuous (g ∘ f)

Next tactic:
simp only [continuous_iff_coinduced_le, coinduced_compose]
theorem continuous_le_dom {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₁)
    (h₂ : Continuous[t₁, t₃] f) : Continuous[t₂, t₃] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ t₂ : TopologicalSpace α
t₃ : TopologicalSpace β
h₁ : t₂ ≤ t₁
h₂ : Continuous f
⊢ Continuous f

Next tactic:
rw [continuous_iff_le_induced] at h₂ ⊢
theorem continuous_le_dom {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₁)
    (h₂ : Continuous[t₁, t₃] f) : Continuous[t₂, t₃] f := by
  rw [continuous_iff_le_induced] at h₂ ⊢
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ t₂ : TopologicalSpace α
t₃ : TopologicalSpace β
h₁ : t₂ ≤ t₁
h₂ : t₁ ≤ induced f t₃
⊢ t₂ ≤ induced f t₃

Next tactic:
exact le_trans h₁ h₂
theorem continuous_le_rng {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₃)
    (h₂ : Continuous[t₁, t₂] f) : Continuous[t₁, t₃] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
t₂ t₃ : TopologicalSpace β
h₁ : t₂ ≤ t₃
h₂ : Continuous f
⊢ Continuous f

Next tactic:
rw [continuous_iff_coinduced_le] at h₂ ⊢
theorem continuous_le_rng {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β} (h₁ : t₂ ≤ t₃)
    (h₂ : Continuous[t₁, t₂] f) : Continuous[t₁, t₃] f := by
  rw [continuous_iff_coinduced_le] at h₂ ⊢
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
t₂ t₃ : TopologicalSpace β
h₁ : t₂ ≤ t₃
h₂ : coinduced f t₁ ≤ t₂
⊢ coinduced f t₁ ≤ t₃

Next tactic:
exact le_trans h₂ h₁
theorem continuous_sup_dom {t₁ t₂ : TopologicalSpace α} {t₃ : TopologicalSpace β} :
    Continuous[t₁ ⊔ t₂, t₃] f ↔ Continuous[t₁, t₃] f ∧ Continuous[t₂, t₃] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ t₂ : TopologicalSpace α
t₃ : TopologicalSpace β
⊢ Continuous f ↔ Continuous f ∧ Continuous f

Next tactic:
simp only [continuous_iff_le_induced, sup_le_iff]
theorem continuous_sSup_dom {T : Set (TopologicalSpace α)} {t₂ : TopologicalSpace β} :
    Continuous[sSup T, t₂] f ↔ ∀ t ∈ T, Continuous[t, t₂] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
T : Set (TopologicalSpace α)
t₂ : TopologicalSpace β
⊢ Continuous f ↔ ∀ t ∈ T, Continuous f

Next tactic:
simp only [continuous_iff_le_induced, sSup_le_iff]
theorem continuous_iSup_dom {t₁ : ι → TopologicalSpace α} {t₂ : TopologicalSpace β} :
    Continuous[iSup t₁, t₂] f ↔ ∀ i, Continuous[t₁ i, t₂] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : ι → TopologicalSpace α
t₂ : TopologicalSpace β
⊢ Continuous f ↔ ∀ (i : ι), Continuous f

Next tactic:
simp only [continuous_iff_le_induced, iSup_le_iff]
theorem continuous_inf_rng {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β} :
    Continuous[t₁, t₂ ⊓ t₃] f ↔ Continuous[t₁, t₂] f ∧ Continuous[t₁, t₃] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
t₂ t₃ : TopologicalSpace β
⊢ Continuous f ↔ Continuous f ∧ Continuous f

Next tactic:
simp only [continuous_iff_coinduced_le, le_inf_iff]
theorem continuous_sInf_rng {t₁ : TopologicalSpace α} {T : Set (TopologicalSpace β)} :
    Continuous[t₁, sInf T] f ↔ ∀ t ∈ T, Continuous[t₁, t] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
T : Set (TopologicalSpace β)
⊢ Continuous f ↔ ∀ t ∈ T, Continuous f

Next tactic:
simp only [continuous_iff_coinduced_le, le_sInf_iff]
theorem continuous_iInf_rng {t₁ : TopologicalSpace α} {t₂ : ι → TopologicalSpace β} :
    Continuous[t₁, iInf t₂] f ↔ ∀ i, Continuous[t₁, t₂ i] f := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
t₂ : ι → TopologicalSpace β
⊢ Continuous f ↔ ∀ (i : ι), Continuous f

Next tactic:
simp only [continuous_iff_coinduced_le, le_iInf_iff]
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s

Next tactic:
letI := T.induced f
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s

Next tactic:
simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) ↔ ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

Next tactic:
constructor
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
  constructor
  · 

Proof state:
case mp
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) → ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

Next tactic:
rintro ⟨u, usub, ⟨v, openv, rfl⟩, au⟩
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
  constructor
  · rintro ⟨u, usub, ⟨v, openv, rfl⟩, au⟩
    

Proof state:
case mp.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
v : Set α
openv : IsOpen v
usub : f ⁻¹' v ⊆ s
au : a ∈ f ⁻¹' v
⊢ ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

Next tactic:
exact ⟨v, ⟨v, Subset.rfl, openv, au⟩, usub⟩
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
  constructor
  · rintro ⟨u, usub, ⟨v, openv, rfl⟩, au⟩
    exact ⟨v, ⟨v, Subset.rfl, openv, au⟩, usub⟩
  · 

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s) → ∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t

Next tactic:
rintro ⟨u, ⟨v, vsubu, openv, amem⟩, finvsub⟩
theorem mem_nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) (s : Set β) :
    s ∈ @nhds β (TopologicalSpace.induced f T) a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s := by
  letI := T.induced f
  simp only [mem_nhds_iff, isOpen_induced_iff, exists_prop, Set.mem_setOf_eq]
  constructor
  · rintro ⟨u, usub, ⟨v, openv, rfl⟩, au⟩
    exact ⟨v, ⟨v, Subset.rfl, openv, au⟩, usub⟩
  · rintro ⟨u, ⟨v, vsubu, openv, amem⟩, finvsub⟩
    

Proof state:
case mpr.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
u : Set α
finvsub : f ⁻¹' u ⊆ s
v : Set α
vsubu : v ⊆ u
openv : IsOpen v
amem : f a ∈ v
⊢ ∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t

Next tactic:
exact ⟨f ⁻¹' v, (Set.preimage_mono vsubu).trans finvsub, ⟨⟨v, openv, rfl⟩, amem⟩⟩
theorem nhds_induced [T : TopologicalSpace α] (f : β → α) (a : β) :
    @nhds β (TopologicalSpace.induced f T) a = comap f (𝓝 (f a)) := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
⊢ 𝓝 a = comap f (𝓝 (f a))

Next tactic:
ext s