l3lab/ntp-mathlib huggingface dataset:
theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
    (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s :=
  Filter.ext fun s => by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : α → Filter β
s✝ s : Set β
⊢ (s ∈ bind f fun x => g x ⊓ 𝓟 s✝) ↔ s ∈ bind f g ⊓ 𝓟 s✝

Next tactic:
simp only [mem_bind, mem_inf_principal]
theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x :=
  show join (map f (𝓟 s)) = ⨆ x ∈ s, f x by
    

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
f : α → Filter β
⊢ join (map f (𝓟 s)) = ⨆ x ∈ s, f x

Next tactic:
simp only [sSup_image, join_principal_eq_sSup, map_principal, eq_self_iff_true]
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ t ∈ traverse f fs ↔ ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t

Next tactic:
constructor
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · 

Proof state:
case mp
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ t ∈ traverse f fs → ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t

Next tactic:
induction fs generalizing t
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    

Proof state:
case mp.nil
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t
case mp.cons
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
head✝ : β'
tail✝ : List β'
tail_ih✝ : ∀ t ∈ traverse f tail✝, ∃ us, Forall₂ (fun b s => s ∈ f b) tail✝ us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (head✝ :: tail✝) → ∃ us, Forall₂ (fun b s => s ∈ f b) (head✝ :: tail✝) us ∧ sequence us ⊆ t

Next tactic:
case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t

Next tactic:
case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
t : Set (List α')
⊢ t ∈ traverse f [] → ∃ us, Forall₂ (fun b s => s ∈ f b) [] us ∧ sequence us ⊆ t

Next tactic:
simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    

Proof state:
case mp.cons
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
head✝ : β'
tail✝ : List β'
tail_ih✝ : ∀ t ∈ traverse f tail✝, ∃ us, Forall₂ (fun b s => s ∈ f b) tail✝ us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (head✝ :: tail✝) → ∃ us, Forall₂ (fun b s => s ∈ f b) (head✝ :: tail✝) us ∧ sequence us ⊆ t

Next tactic:
case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      rcases ih v hv with ⟨us, hus, hu⟩
      exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (b :: fs) → ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      rcases ih v hv with ⟨us, hus, hu⟩
      exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
⊢ t ∈ traverse f (b :: fs) → ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
intro ht
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht : t ∈ traverse f (b :: fs)
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      

Proof state:
case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      

Proof state:
case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
w : Set α'
hw : w ∈ f b
hwu : cons '' w ⊆ u
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
rcases ih v hv with ⟨us, hus, hu⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      rcases ih v hv with ⟨us, hus, hu⟩
      

Proof state:
case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
b : β'
fs : List β'
ih : ∀ t ∈ traverse f fs, ∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t
t : Set (List α')
ht✝ : t ∈ traverse f (b :: fs)
u : Set (List α' → List α')
hu✝ : u ∈ cons <$> f b
v : Set (List α')
hv : v ∈ (fun x => List.traverse f fs) ()
ht : Set.seq u v ⊆ t
w : Set α'
hw : w ∈ f b
hwu : cons '' w ⊆ u
us : List (Set α')
hus : Forall₂ (fun b s => s ∈ f b) fs us
hu : sequence us ⊆ v
⊢ ∃ us, Forall₂ (fun b s => s ∈ f b) (b :: fs) us ∧ sequence us ⊆ t

Next tactic:
exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      rcases ih v hv with ⟨us, hus, hu⟩
      exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
  · 

Proof state:
case mpr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
⊢ (∃ us, Forall₂ (fun b s => s ∈ f b) fs us ∧ sequence us ⊆ t) → t ∈ traverse f fs

Next tactic:
rintro ⟨us, hus, hs⟩
theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
    t ∈ traverse f fs ↔
      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
  constructor
  · induction fs generalizing t
    case nil =>
      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
        singleton_subset_iff, traverse_nil]
    case cons b fs ih =>
      intro ht
      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
      rcases ih v hv with ⟨us, hus, hu⟩
      exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
  · rintro ⟨us, hus, hs⟩
    

Proof state:
case mpr.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
α' β' γ' : Type u
f : β' → Filter α'
s : γ' → Set α'
fs : List β'
t : Set (List α')
us : List (Set α')
hus : Forall₂ (fun b s => s ∈ f b) fs us
hs : sequence us ⊆ t
⊢ t ∈ traverse f fs

Next tactic:
exact mem_of_superset (mem_traverse _ _ hus) hs
/-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
GaloisConnection.toGaloisCoinsertion (λ s f ↦ by 

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f✝ g : Filter α
s✝ : Set α
a : α
s : Set α
f : Filter α
⊢ 𝓟 s ≤ f ↔ s ≤ ker f

Next tactic:
simp [principal_le_iff]
/-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) $ by
  

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f g : Filter α
s : Set α
a : α
⊢ ∀ (a : Set α), ker (𝓟 a) ≤ a

Next tactic:
simp only [le_iff_subset, subset_def, mem_ker, mem_principal]
/-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) $ by
  simp only [le_iff_subset, subset_def, mem_ker, mem_principal]; 

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f g : Filter α
s : Set α
a : α
⊢ ∀ (a : Set α) (x : α), (∀ (s : Set α), (∀ x ∈ a, x ∈ s) → x ∈ s) → x ∈ a

Next tactic:
aesop
@[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ := gi_principal_ker.gc.u_eq_top.trans $ by 

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f g : Filter α
s : Set α
a : α
⊢ 𝓟 ⊤ ≤ f ↔ f = ⊤

Next tactic:
simp
@[simp] lemma ker_pure (a : α) : ker (pure a) = {a} := by 

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f g : Filter α
s : Set α
a✝ a : α
⊢ ker (pure a) = {a}

Next tactic:
rw [← principal_singleton, ker_principal]
@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f := by
  

Proof state:
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f✝ g : Filter α
s : Set α
a : α
m : α → β
f : Filter β
⊢ ker (comap m f) = m ⁻¹' ker f

Next tactic:
ext a
@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f := by
  ext a
  

Proof state:
case h
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f✝ g : Filter α
s : Set α
a✝ : α
m : α → β
f : Filter β
a : α
⊢ a ∈ ker (comap m f) ↔ a ∈ m ⁻¹' ker f

Next tactic:
simp only [mem_ker, mem_comap, forall_exists_index, and_imp, @forall_swap (Set α), mem_preimage]
@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f := by
  ext a
  simp only [mem_ker, mem_comap, forall_exists_index, and_imp, @forall_swap (Set α), mem_preimage]
  

Proof state:
case h
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
ι : Sort u_2
α : Type u_3
β : Type u_4
f✝ g : Filter α
s : Set α
a✝ : α
m : α → β
f : Filter β
a : α
⊢ (∀ y ∈ f, ∀ (x : Set α), m ⁻¹' y ⊆ x → a ∈ x) ↔ ∀ s ∈ f, m a ∈ s

Next tactic:
exact forall₂_congr λ s _ ↦ ⟨λ h ↦ h _ Subset.rfl, λ ha t ht ↦ ht ha⟩
@[simp]
theorem tendsto_bot {f : α → β} {l : Filter β} : Tendsto f ⊥ l := by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
l : Filter β
⊢ Tendsto f ⊥ l

Next tactic:
simp [Tendsto]
theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ g ≤ map mab f

Next tactic:
rw [← @map_id _ g, ← map_congr h₁, ← map_map]
theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f := by
  rw [← @map_id _ g, ← map_congr h₁, ← map_map]
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ map mab (map mba g) ≤ map mab f

Next tactic:
exact map_mono h₂
theorem tendsto_of_isEmpty [IsEmpty α] {f : α → β} {la : Filter α} {lb : Filter β} :
    Tendsto f la lb := by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : IsEmpty α
f : α → β
la : Filter α
lb : Filter β
⊢ Tendsto f la lb

Next tactic:
simp only [filter_eq_bot_of_isEmpty la, tendsto_bot]
theorem tendsto_congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂) :
    Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂ := by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f₁ f₂ : α → β
l₁ : Filter α
l₂ : Filter β
hl : f₁ =ᶠ[l₁] f₂
⊢ Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂

Next tactic:
rw [Tendsto, Tendsto, map_congr hl]
@[simp]
theorem tendsto_map'_iff {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ} :
    Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : β → γ
g : α → β
x : Filter α
y : Filter γ
⊢ Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y

Next tactic:
rw [Tendsto, Tendsto, map_map]
@[simp]
theorem tendsto_comap_iff {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ} :
    Tendsto f a (c.comap g) ↔ Tendsto (g ∘ f) a c :=
  ⟨fun h => tendsto_comap.comp h, fun h => map_le_iff_le_comap.mp <| by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
c : Filter γ
h : Tendsto (g ∘ f) a c
⊢ map g (map f a) ≤ c

Next tactic:
rwa [map_map]
theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i : γ → α} (h : range i ∈ f) :
    Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g

Next tactic:
rw [Tendsto, ← map_compose]
theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i : γ → α} (h : range i ∈ f) :
    Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g := by
  rw [Tendsto, ← map_compose]
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ (map m ∘ map i) (comap i f) ≤ g ↔ Tendsto m f g

Next tactic:
simp only [(· ∘ ·), map_comap_of_mem h, Tendsto]
theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
    (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : Tendsto (g ∘ f) a c
hg : comap g c ≤ b
⊢ Tendsto f a b

Next tactic:
rw [tendsto_iff_comap] at hfg ⊢
theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
    (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b := by
  rw [tendsto_iff_comap] at hfg ⊢
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : a ≤ comap (g ∘ f) c
hg : comap g c ≤ b
⊢ a ≤ comap f b

Next tactic:
calc
    a ≤ comap (g ∘ f) c := hfg
    _ ≤ comap f b := by simpa [comap_comap] using comap_mono hg
theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
    (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b := by
  rw [tendsto_iff_comap] at hfg ⊢
  calc
    a ≤ comap (g ∘ f) c := hfg
    _ ≤ comap f b := by 

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
g : β → γ
a : Filter α
b : Filter β
c : Filter γ
hfg : a ≤ comap (g ∘ f) c
hg : comap g c ≤ b
⊢ comap (g ∘ f) c ≤ comap f b

Next tactic:
simpa [comap_comap] using comap_mono hg
theorem comap_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : ψ ∘ φ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : comap φ g = f := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ g = f

Next tactic:
refine' ((comap_mono <| map_le_iff_le_comap.1 hψ).trans _).antisymm (map_le_iff_le_comap.1 hφ)
theorem comap_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : ψ ∘ φ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : comap φ g = f := by
  refine' ((comap_mono <| map_le_iff_le_comap.1 hψ).trans _).antisymm (map_le_iff_le_comap.1 hφ)
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ (comap ψ f) ≤ f

Next tactic:
rw [comap_comap, eq, comap_id]
theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : φ ∘ ψ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : map φ f = g := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ map φ f = g

Next tactic:
refine' le_antisymm hφ (le_trans _ (map_mono hψ))
theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : φ ∘ ψ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : map φ f = g := by
  refine' le_antisymm hφ (le_trans _ (map_mono hψ))
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ g ≤ map φ (map ψ g)

Next tactic:
rw [map_map, eq, map_id]
theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
    Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂ := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x : Filter α
y₁ y₂ : Filter β
⊢ Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂

Next tactic:
simp only [Tendsto, le_inf_iff, iff_self_iff]
@[simp]
theorem tendsto_iInf {f : α → β} {x : Filter α} {y : ι → Filter β} :
    Tendsto f x (⨅ i, y i) ↔ ∀ i, Tendsto f x (y i) := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x : Filter α
y : ι → Filter β
⊢ Tendsto f x (⨅ i, y i) ↔ ∀ (i : ι), Tendsto f x (y i)

Next tactic:
simp only [Tendsto, iff_self_iff, le_iInf_iff]
@[simp]
theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
    Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y := by
  

Proof state:
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : α → β
x₁ x₂ : Filter α
y : Filter β
⊢ Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y

Next tactic:
simp only [Tendsto, map_sup, sup_le_iff]