ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.HasBasis.mem_lift_iff
theorem HasBasis.mem_lift_iff {ι} {p : ι → Prop} {s : ι → Set α} {f : Filter α}
    (hf : f.HasBasis p s) {β : ι → Type*} {pg : ∀ i, β i → Prop} {sg : ∀ i, β i → Set γ}
    {g : Set α → Filter γ} (hg : ∀ i, (g <| s i).HasBasis (pg i) (sg i)) (gm : Monotone g)
    {s : Set γ} : s ∈ f.lift g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s 
Arguments: {α : Type u_1} {γ : Type u_3} {ι : Sort u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α} (hf : f.HasBasis p s) {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ} (hg : ∀ (i : ι), (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g)
Goal: ∀ {s : Set γ}, s ∈ f.lift g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s
-- Filter.HasBasis.lift
theorem HasBasis.lift {ι} {p : ι → Prop} {s : ι → Set α} {f : Filter α} (hf : f.HasBasis p s)
    {β : ι → Type*} {pg : ∀ i, β i → Prop} {sg : ∀ i, β i → Set γ} {g : Set α → Filter γ}
    (hg : ∀ i, (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g) :
    (f.lift g).HasBasis (fun i : Σi, β i => p i.1 ∧ pg i.1 i.2) fun i : Σi, β i => sg i.1 i.2 
Arguments: {α : Type u_1} {γ : Type u_3} {ι : Type u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α} (hf : f.HasBasis p s) {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ} (hg : ∀ (i : ι), (g (s i)).HasBasis (pg i) (sg i)) (gm : Monotone g)
Goal: (f.lift g).HasBasis (fun i => p i.fst ∧ pg i.fst i.snd) fun i => sg i.fst i.snd
-- Filter.mem_lift_sets
theorem mem_lift_sets (hg : Monotone g) {s : Set β} : s ∈ f.lift g ↔ ∃ t ∈ f, s ∈ g t 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} (hg : Monotone g) {s : Set β}
Goal: s ∈ f.lift g ↔ ∃ t ∈ f, s ∈ g t
-- Filter.sInter_lift_sets
theorem sInter_lift_sets (hg : Monotone g) :
    ⋂₀ { s | s ∈ f.lift g } = ⋂ s ∈ f, ⋂₀ { t | t ∈ g s } 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} (hg : Monotone g)
Goal: ⋂₀ {s | s ∈ f.lift g} = ⋂ s ∈ f, ⋂₀ {t | t ∈ g s}
-- Filter.mem_lift
theorem mem_lift {s : Set β} {t : Set α} (ht : t ∈ f) (hs : s ∈ g t) : s ∈ f.lift g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} {s : Set β} {t : Set α} (ht : t ∈ f) (hs : s ∈ g t)
Goal: s ∈ f.lift g
-- Filter.lift_le
theorem lift_le {f : Filter α} {g : Set α → Filter β} {h : Filter β} {s : Set α} (hs : s ∈ f)
    (hg : g s ≤ h) : f.lift g ≤ h 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} {h : Filter β} {s : Set α} (hs : s ∈ f) (hg : g s ≤ h)
Goal: f.lift g ≤ h
-- Filter.le_lift
theorem le_lift {f : Filter α} {g : Set α → Filter β} {h : Filter β} :
    h ≤ f.lift g ↔ ∀ s ∈ f, h ≤ g s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} {h : Filter β}
Goal: h ≤ f.lift g ↔ ∀ s ∈ f, h ≤ g s
-- Filter.lift_mono
theorem lift_mono (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) : f₁.lift g₁ ≤ f₂.lift g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Set α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂)
Goal: f₁.lift g₁ ≤ f₂.lift g₂
-- Filter.lift_mono'
theorem lift_mono' (hg : ∀ s ∈ f, g₁ s ≤ g₂ s) : f.lift g₁ ≤ f.lift g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g₁ g₂ : Set α → Filter β} (hg : ∀ s ∈ f, g₁ s ≤ g₂ s)
Goal: f.lift g₁ ≤ f.lift g₂
-- Filter.tendsto_lift
theorem tendsto_lift {m : γ → β} {l : Filter γ} :
    Tendsto m l (f.lift g) ↔ ∀ s ∈ f, Tendsto m l (g s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β} {l : Filter γ}
Goal: Filter.Tendsto m l (f.lift g) ↔ ∀ s ∈ f, Filter.Tendsto m l (g s)
-- Filter.map_lift_eq
theorem map_lift_eq {m : β → γ} (hg : Monotone g) : map m (f.lift g) = f.lift (map m ∘ g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : β → γ} (hg : Monotone g)
Goal: Filter.map m (f.lift g) = f.lift (Filter.map m ∘ g)
-- Filter.comap_lift_eq
theorem comap_lift_eq {m : γ → β} : comap m (f.lift g) = f.lift (comap m ∘ g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β}
Goal: Filter.comap m (f.lift g) = f.lift (Filter.comap m ∘ g)
-- Filter.comap_lift_eq2
theorem comap_lift_eq2 {m : β → α} {g : Set β → Filter γ} (hg : Monotone g) :
    (comap m f).lift g = f.lift (g ∘ preimage m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : β → α} {g : Set β → Filter γ} (hg : Monotone g)
Goal: (Filter.comap m f).lift g = f.lift (g ∘ Set.preimage m)
-- Filter.lift_map_le
theorem lift_map_le {g : Set β → Filter γ} {m : α → β} : (map m f).lift g ≤ f.lift (g ∘ image m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set β → Filter γ} {m : α → β}
Goal: (Filter.map m f).lift g ≤ f.lift (g ∘ Set.image m)
-- Filter.map_lift_eq2
theorem map_lift_eq2 {g : Set β → Filter γ} {m : α → β} (hg : Monotone g) :
    (map m f).lift g = f.lift (g ∘ image m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set β → Filter γ} {m : α → β} (hg : Monotone g)
Goal: (Filter.map m f).lift g = f.lift (g ∘ Set.image m)
-- Filter.lift_comm
theorem lift_comm {g : Filter β} {h : Set α → Set β → Filter γ} :
    (f.lift fun s => g.lift (h s)) = g.lift fun t => f.lift fun s => h s t 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Filter β} {h : Set α → Set β → Filter γ}
Goal: (f.lift fun s => g.lift (h s)) = g.lift fun t => f.lift fun s => h s t
-- Filter.lift_assoc
theorem lift_assoc {h : Set β → Filter γ} (hg : Monotone g) :
    (f.lift g).lift h = f.lift fun s => (g s).lift h 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {h : Set β → Filter γ} (hg : Monotone g)
Goal: (f.lift g).lift h = f.lift fun s => (g s).lift h
-- Filter.lift_lift_same_le_lift
theorem lift_lift_same_le_lift {g : Set α → Set α → Filter β} :
    (f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β}
Goal: (f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s
-- Filter.lift_lift_same_eq_lift
theorem lift_lift_same_eq_lift {g : Set α → Set α → Filter β} (hg₁ : ∀ s, Monotone fun t => g s t)
    (hg₂ : ∀ t, Monotone fun s => g s t) : (f.lift fun s => f.lift (g s)) = f.lift fun s => g s s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β} (hg₁ : ∀ (s : Set α), Monotone fun t => g s t) (hg₂ : ∀ (t : Set α), Monotone fun s => g s t)
Goal: (f.lift fun s => f.lift (g s)) = f.lift fun s => g s s
-- Filter.lift_principal
theorem lift_principal {s : Set α} (hg : Monotone g) : (𝓟 s).lift g = g s 
Arguments: {α : Type u_1} {β : Type u_2} {g : Set α → Filter β} {s : Set α} (hg : Monotone g)
Goal: (𝓟 s).lift g = g s
-- Filter.monotone_lift
theorem monotone_lift [Preorder γ] {f : γ → Filter α} {g : γ → Set α → Filter β} (hf : Monotone f)
    (hg : Monotone g) : Monotone fun c => (f c).lift (g c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder γ] {f : γ → Filter α} {g : γ → Set α → Filter β} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun c => (f c).lift (g c)
-- Filter.lift_neBot_iff
theorem lift_neBot_iff (hm : Monotone g) : (NeBot (f.lift g)) ↔ ∀ s ∈ f, NeBot (g s) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Filter β} (hm : Monotone g)
Goal: (f.lift g).NeBot ↔ ∀ s ∈ f, (g s).NeBot
-- Filter.lift_const
@[simp]
theorem lift_const {f : Filter α} {g : Filter β} : (f.lift fun _ => g) = g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: (f.lift fun x => g) = g
-- Filter.lift_inf
@[simp]
theorem lift_inf {f : Filter α} {g h : Set α → Filter β} :
    (f.lift fun x => g x ⊓ h x) = f.lift g ⊓ f.lift h 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g h : Set α → Filter β}
Goal: (f.lift fun x => g x ⊓ h x) = f.lift g ⊓ f.lift h
-- Filter.lift_principal2
@[simp]
theorem lift_principal2 {f : Filter α} : f.lift 𝓟 = f 
Arguments: {α : Type u_1} {f : Filter α}
Goal: f.lift 𝓟 = f
-- Filter.lift_iInf_le
theorem lift_iInf_le {f : ι → Filter α} {g : Set α → Filter β} :
    (iInf f).lift g ≤ ⨅ i, (f i).lift g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → Filter α} {g : Set α → Filter β}
Goal: (iInf f).lift g ≤ ⨅ i, (f i).lift g
-- Filter.lift_iInf
theorem lift_iInf [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β}
    (hg : ∀ s t, g (s ∩ t) = g s ⊓ g t) : (iInf f).lift g = ⨅ i, (f i).lift g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β} (hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t)
Goal: (iInf f).lift g = ⨅ i, (f i).lift g
-- Filter.lift_iInf_of_directed
theorem lift_iInf_of_directed [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β}
    (hf : Directed (· ≥ ·) f) (hg : Monotone g) : (iInf f).lift g = ⨅ i, (f i).lift g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β} (hf : Directed (fun x x_1 => x ≥ x_1) f) (hg : Monotone g)
Goal: (iInf f).lift g = ⨅ i, (f i).lift g
-- Filter.lift_iInf_of_map_univ
theorem lift_iInf_of_map_univ {f : ι → Filter α} {g : Set α → Filter β}
    (hg : ∀ s t, g (s ∩ t) = g s ⊓ g t) (hg' : g univ = ⊤) :
    (iInf f).lift g = ⨅ i, (f i).lift g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → Filter α} {g : Set α → Filter β} (hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t) (hg' : g Set.univ = ⊤)
Goal: (iInf f).lift g = ⨅ i, (f i).lift g
-- Filter.lift'_top
@[simp]
theorem lift'_top (h : Set α → Set β) : (⊤ : Filter α).lift' h = 𝓟 (h univ) 
Arguments: {α : Type u_1} {β : Type u_2} (h : Set α → Set β)
Goal: ⊤.lift' h = 𝓟 (h Set.univ)
-- Filter.mem_lift'
theorem mem_lift' {t : Set α} (ht : t ∈ f) : h t ∈ f.lift' h 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {t : Set α} (ht : t ∈ f)
Goal: h t ∈ f.lift' h
-- Filter.tendsto_lift'
theorem tendsto_lift' {m : γ → β} {l : Filter γ} :
    Tendsto m l (f.lift' h) ↔ ∀ s ∈ f, ∀ᶠ a in l, m a ∈ h s 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {h : Set α → Set β} {m : γ → β} {l : Filter γ}
Goal: Filter.Tendsto m l (f.lift' h) ↔ ∀ s ∈ f, ∀ᶠ (a : γ) in l, m a ∈ h s
-- Filter.HasBasis.lift'
theorem HasBasis.lift' {ι} {p : ι → Prop} {s} (hf : f.HasBasis p s) (hh : Monotone h) :
    (f.lift' h).HasBasis p (h ∘ s) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {ι : Sort u_5} {p : ι → Prop} {s : ι → Set α} (hf : f.HasBasis p s) (hh : Monotone h)
Goal: (f.lift' h).HasBasis p (h ∘ s)
-- Filter.mem_lift'_sets
theorem mem_lift'_sets (hh : Monotone h) {s : Set β} : s ∈ f.lift' h ↔ ∃ t ∈ f, h t ⊆ s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} (hh : Monotone h) {s : Set β}
Goal: s ∈ f.lift' h ↔ ∃ t ∈ f, h t ⊆ s
-- Filter.eventually_lift'_iff
theorem eventually_lift'_iff (hh : Monotone h) {p : β → Prop} :
    (∀ᶠ y in f.lift' h, p y) ↔ ∃ t ∈ f, ∀ y ∈ h t, p y 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} (hh : Monotone h) {p : β → Prop}
Goal: (∀ᶠ (y : β) in f.lift' h, p y) ↔ ∃ t ∈ f, ∀ y ∈ h t, p y
-- Filter.sInter_lift'_sets
theorem sInter_lift'_sets (hh : Monotone h) : ⋂₀ { s | s ∈ f.lift' h } = ⋂ s ∈ f, h s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} (hh : Monotone h)
Goal: ⋂₀ {s | s ∈ f.lift' h} = ⋂ s ∈ f, h s
-- Filter.lift'_le
theorem lift'_le {f : Filter α} {g : Set α → Set β} {h : Filter β} {s : Set α} (hs : s ∈ f)
    (hg : 𝓟 (g s) ≤ h) : f.lift' g ≤ h 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set β} {h : Filter β} {s : Set α} (hs : s ∈ f) (hg : 𝓟 (g s) ≤ h)
Goal: f.lift' g ≤ h
-- Filter.lift'_mono
theorem lift'_mono (hf : f₁ ≤ f₂) (hh : h₁ ≤ h₂) : f₁.lift' h₁ ≤ f₂.lift' h₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {h₁ h₂ : Set α → Set β} (hf : f₁ ≤ f₂) (hh : h₁ ≤ h₂)
Goal: f₁.lift' h₁ ≤ f₂.lift' h₂
-- Filter.lift'_mono'
theorem lift'_mono' (hh : ∀ s ∈ f, h₁ s ⊆ h₂ s) : f.lift' h₁ ≤ f.lift' h₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h₁ h₂ : Set α → Set β} (hh : ∀ s ∈ f, h₁ s ⊆ h₂ s)
Goal: f.lift' h₁ ≤ f.lift' h₂
-- Filter.lift'_cong
theorem lift'_cong (hh : ∀ s ∈ f, h₁ s = h₂ s) : f.lift' h₁ = f.lift' h₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h₁ h₂ : Set α → Set β} (hh : ∀ s ∈ f, h₁ s = h₂ s)
Goal: f.lift' h₁ = f.lift' h₂
-- Filter.map_lift'_eq
theorem map_lift'_eq {m : β → γ} (hh : Monotone h) : map m (f.lift' h) = f.lift' (image m ∘ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {h : Set α → Set β} {m : β → γ} (hh : Monotone h)
Goal: Filter.map m (f.lift' h) = f.lift' (Set.image m ∘ h)
-- Filter.lift'_map_le
theorem lift'_map_le {g : Set β → Set γ} {m : α → β} : (map m f).lift' g ≤ f.lift' (g ∘ image m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set β → Set γ} {m : α → β}
Goal: (Filter.map m f).lift' g ≤ f.lift' (g ∘ Set.image m)
-- Filter.map_lift'_eq2
theorem map_lift'_eq2 {g : Set β → Set γ} {m : α → β} (hg : Monotone g) :
    (map m f).lift' g = f.lift' (g ∘ image m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set β → Set γ} {m : α → β} (hg : Monotone g)
Goal: (Filter.map m f).lift' g = f.lift' (g ∘ Set.image m)
-- Filter.comap_lift'_eq
theorem comap_lift'_eq {m : γ → β} : comap m (f.lift' h) = f.lift' (preimage m ∘ h) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {h : Set α → Set β} {m : γ → β}
Goal: Filter.comap m (f.lift' h) = f.lift' (Set.preimage m ∘ h)
-- Filter.comap_lift'_eq2
theorem comap_lift'_eq2 {m : β → α} {g : Set β → Set γ} (hg : Monotone g) :
    (comap m f).lift' g = f.lift' (g ∘ preimage m) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : β → α} {g : Set β → Set γ} (hg : Monotone g)
Goal: (Filter.comap m f).lift' g = f.lift' (g ∘ Set.preimage m)
-- Filter.lift'_principal
theorem lift'_principal {s : Set α} (hh : Monotone h) : (𝓟 s).lift' h = 𝓟 (h s) 
Arguments: {α : Type u_1} {β : Type u_2} {h : Set α → Set β} {s : Set α} (hh : Monotone h)
Goal: (𝓟 s).lift' h = 𝓟 (h s)
-- Filter.lift'_pure
theorem lift'_pure {a : α} (hh : Monotone h) : (pure a : Filter α).lift' h = 𝓟 (h {a}) 
Arguments: {α : Type u_1} {β : Type u_2} {h : Set α → Set β} {a : α} (hh : Monotone h)
Goal: (pure a).lift' h = 𝓟 (h {a})
-- Filter.lift'_bot
theorem lift'_bot (hh : Monotone h) : (⊥ : Filter α).lift' h = 𝓟 (h ∅) 
Arguments: {α : Type u_1} {β : Type u_2} {h : Set α → Set β} (hh : Monotone h)
Goal: ⊥.lift' h = 𝓟 (h ∅)
-- Filter.le_lift'
theorem le_lift' {f : Filter α} {h : Set α → Set β} {g : Filter β} :
    g ≤ f.lift' h ↔ ∀ s ∈ f, h s ∈ g 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {g : Filter β}
Goal: g ≤ f.lift' h ↔ ∀ s ∈ f, h s ∈ g
-- Filter.principal_le_lift'
theorem principal_le_lift' {t : Set β} : 𝓟 t ≤ f.lift' h ↔ ∀ s ∈ f, t ⊆ h s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {t : Set β}
Goal: 𝓟 t ≤ f.lift' h ↔ ∀ s ∈ f, t ⊆ h s
-- Filter.monotone_lift'
theorem monotone_lift' [Preorder γ] {f : γ → Filter α} {g : γ → Set α → Set β} (hf : Monotone f)
    (hg : Monotone g) : Monotone fun c => (f c).lift' (g c) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder γ] {f : γ → Filter α} {g : γ → Set α → Set β} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun c => (f c).lift' (g c)
-- Filter.lift_lift'_assoc
theorem lift_lift'_assoc {g : Set α → Set β} {h : Set β → Filter γ} (hg : Monotone g)
    (hh : Monotone h) : (f.lift' g).lift h = f.lift fun s => h (g s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Set β} {h : Set β → Filter γ} (hg : Monotone g) (hh : Monotone h)
Goal: (f.lift' g).lift h = f.lift fun s => h (g s)
-- Filter.lift'_lift'_assoc
theorem lift'_lift'_assoc {g : Set α → Set β} {h : Set β → Set γ} (hg : Monotone g)
    (hh : Monotone h) : (f.lift' g).lift' h = f.lift' fun s => h (g s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Set β} {h : Set β → Set γ} (hg : Monotone g) (hh : Monotone h)
Goal: (f.lift' g).lift' h = f.lift' fun s => h (g s)
-- Filter.lift'_lift_assoc
theorem lift'_lift_assoc {g : Set α → Filter β} {h : Set β → Set γ} (hg : Monotone g) :
    (f.lift g).lift' h = f.lift fun s => (g s).lift' h 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {h : Set β → Set γ} (hg : Monotone g)
Goal: (f.lift g).lift' h = f.lift fun s => (g s).lift' h
-- Filter.lift_lift'_same_le_lift'
theorem lift_lift'_same_le_lift' {g : Set α → Set α → Set β} :
    (f.lift fun s => f.lift' (g s)) ≤ f.lift' fun s => g s s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Set β}
Goal: (f.lift fun s => f.lift' (g s)) ≤ f.lift' fun s => g s s
-- Filter.lift_lift'_same_eq_lift'
theorem lift_lift'_same_eq_lift' {g : Set α → Set α → Set β} (hg₁ : ∀ s, Monotone fun t => g s t)
    (hg₂ : ∀ t, Monotone fun s => g s t) :
    (f.lift fun s => f.lift' (g s)) = f.lift' fun s => g s s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Set β} (hg₁ : ∀ (s : Set α), Monotone fun t => g s t) (hg₂ : ∀ (t : Set α), Monotone fun s => g s t)
Goal: (f.lift fun s => f.lift' (g s)) = f.lift' fun s => g s s
-- Filter.lift'_inf_principal_eq
theorem lift'_inf_principal_eq {h : Set α → Set β} {s : Set β} :
    f.lift' h ⊓ 𝓟 s = f.lift' fun t => h t ∩ s 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} {s : Set β}
Goal: f.lift' h ⊓ 𝓟 s = f.lift' fun t => h t ∩ s
-- Filter.lift'_neBot_iff
theorem lift'_neBot_iff (hh : Monotone h) : NeBot (f.lift' h) ↔ ∀ s ∈ f, (h s).Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {h : Set α → Set β} (hh : Monotone h)
Goal: (f.lift' h).NeBot ↔ ∀ s ∈ f, (h s).Nonempty
-- Filter.lift'_id
@[simp]
theorem lift'_id {f : Filter α} : f.lift' id = f 
Arguments: {α : Type u_1} {f : Filter α}
Goal: f.lift' id = f
-- Filter.lift'_iInf
theorem lift'_iInf [Nonempty ι] {f : ι → Filter α} {g : Set α → Set β}
    (hg : ∀ s t, g (s ∩ t) = g s ∩ g t) : (iInf f).lift' g = ⨅ i, (f i).lift' g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [Nonempty ι] {f : ι → Filter α} {g : Set α → Set β} (hg : ∀ (s t : Set α), g (s ∩ t) = g s ∩ g t)
Goal: (iInf f).lift' g = ⨅ i, (f i).lift' g
-- Filter.lift'_iInf_of_map_univ
theorem lift'_iInf_of_map_univ {f : ι → Filter α} {g : Set α → Set β}
    (hg : ∀ {s t}, g (s ∩ t) = g s ∩ g t) (hg' : g univ = univ) :
    (iInf f).lift' g = ⨅ i, (f i).lift' g 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {f : ι → Filter α} {g : Set α → Set β} (hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t) (hg' : g Set.univ = Set.univ)
Goal: (iInf f).lift' g = ⨅ i, (f i).lift' g
-- Filter.lift'_inf
theorem lift'_inf (f g : Filter α) {s : Set α → Set β} (hs : ∀ t₁ t₂, s (t₁ ∩ t₂) = s t₁ ∩ s t₂) :
    (f ⊓ g).lift' s = f.lift' s ⊓ g.lift' s 
Arguments: {α : Type u_1} {β : Type u_2} (f g : Filter α) {s : Set α → Set β} (hs : ∀ (t₁ t₂ : Set α), s (t₁ ∩ t₂) = s t₁ ∩ s t₂)
Goal: (f ⊓ g).lift' s = f.lift' s ⊓ g.lift' s
-- Filter.lift'_inf_le
theorem lift'_inf_le (f g : Filter α) (s : Set α → Set β) :
    (f ⊓ g).lift' s ≤ f.lift' s ⊓ g.lift' s 
Arguments: {α : Type u_1} {β : Type u_2} (f g : Filter α) (s : Set α → Set β)
Goal: (f ⊓ g).lift' s ≤ f.lift' s ⊓ g.lift' s
-- Filter.comap_eq_lift'
theorem comap_eq_lift' {f : Filter β} {m : α → β} : comap m f = f.lift' (preimage m) 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter β} {m : α → β}
Goal: Filter.comap m f = f.lift' (Set.preimage m)
-- Filter.prod_def
theorem prod_def {f : Filter α} {g : Filter β} :
    f ×ˢ g = f.lift fun s => g.lift' fun t => s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}
Goal: f ×ˢ g = f.lift fun s => g.lift' fun t => s ×ˢ t
-- Filter.prod_same_eq
theorem prod_same_eq : f ×ˢ f = f.lift' fun t : Set α => t ×ˢ t 
Arguments: {α : Type u_1} {f : Filter α}
Goal: f ×ˢ f = f.lift' fun t => t ×ˢ t
-- Filter.tendsto_prod_self_iff
theorem tendsto_prod_self_iff {f : α × α → β} {x : Filter α} {y : Filter β} :
    Filter.Tendsto f (x ×ˢ x) y ↔ ∀ W ∈ y, ∃ U ∈ x, ∀ x x' : α, x ∈ U → x' ∈ U → f (x, x') ∈ W 
Arguments: {α : Type u_1} {β : Type u_2} {f : α × α → β} {x : Filter α} {y : Filter β}
Goal: Filter.Tendsto f (x ×ˢ x) y ↔ ∀ W ∈ y, ∃ U ∈ x, ∀ (x x' : α), x ∈ U → x' ∈ U → f (x, x') ∈ W
-- Filter.prod_lift_lift
theorem prod_lift_lift {f₁ : Filter α₁} {f₂ : Filter α₂} {g₁ : Set α₁ → Filter β₁}
    {g₂ : Set α₂ → Filter β₂} (hg₁ : Monotone g₁) (hg₂ : Monotone g₂) :
    f₁.lift g₁ ×ˢ f₂.lift g₂ = f₁.lift fun s => f₂.lift fun t => g₁ s ×ˢ g₂ t 
Arguments: {α₁ : Type u_5} {α₂ : Type u_6} {β₁ : Type u_7} {β₂ : Type u_8} {f₁ : Filter α₁} {f₂ : Filter α₂} {g₁ : Set α₁ → Filter β₁} {g₂ : Set α₂ → Filter β₂} (hg₁ : Monotone g₁) (hg₂ : Monotone g₂)
Goal: f₁.lift g₁ ×ˢ f₂.lift g₂ = f₁.lift fun s => f₂.lift fun t => g₁ s ×ˢ g₂ t
-- Filter.prod_lift'_lift'
theorem prod_lift'_lift' {f₁ : Filter α₁} {f₂ : Filter α₂} {g₁ : Set α₁ → Set β₁}
    {g₂ : Set α₂ → Set β₂} (hg₁ : Monotone g₁) (hg₂ : Monotone g₂) :
    f₁.lift' g₁ ×ˢ f₂.lift' g₂ = f₁.lift fun s => f₂.lift' fun t => g₁ s ×ˢ g₂ t 
Arguments: {α₁ : Type u_5} {α₂ : Type u_6} {β₁ : Type u_7} {β₂ : Type u_8} {f₁ : Filter α₁} {f₂ : Filter α₂} {g₁ : Set α₁ → Set β₁} {g₂ : Set α₂ → Set β₂} (hg₁ : Monotone g₁) (hg₂ : Monotone g₂)
Goal: f₁.lift' g₁ ×ˢ f₂.lift' g₂ = f₁.lift fun s => f₂.lift' fun t => g₁ s ×ˢ g₂ t
-- Monotone.partBind
lemma Monotone.partBind (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x ↦ (f x).bind (g x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : α → Part β} {g : α → β → Part γ} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun x => (f x).bind (g x)
-- Antitone.partBind
lemma Antitone.partBind (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x ↦ (f x).bind (g x) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : α → Part β} {g : α → β → Part γ} (hf : Antitone f) (hg : Antitone g)
Goal: Antitone fun x => (f x).bind (g x)
-- Monotone.partMap
lemma Monotone.partMap (hg : Monotone g) : Monotone fun x ↦ (g x).map f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : β → γ} {g : α → Part β} (hg : Monotone g)
Goal: Monotone fun x => Part.map f (g x)
-- Antitone.partMap
lemma Antitone.partMap (hg : Antitone g) : Antitone fun x ↦ (g x).map f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : β → γ} {g : α → Part β} (hg : Antitone g)
Goal: Antitone fun x => Part.map f (g x)
-- Monotone.partSeq
lemma Monotone.partSeq (hf : Monotone f) (hg : Monotone g) : Monotone fun x ↦ f x <*> g x 
Arguments: {α : Type u_1} [Preorder α] {β γ : Type u_4} {f : α → Part (β → γ)} {g : α → Part β} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun x => Seq.seq (f x) fun x_1 => g x
-- Antitone.partSeq
lemma Antitone.partSeq (hf : Antitone f) (hg : Antitone g) : Antitone fun x ↦ f x <*> g x 
Arguments: {α : Type u_1} [Preorder α] {β γ : Type u_4} {f : α → Part (β → γ)} {g : α → Part β} (hf : Antitone f) (hg : Antitone g)
Goal: Antitone fun x => Seq.seq (f x) fun x_1 => g x
-- OrderHom.partBind_coe
@[simps]
def partBind (f : α →o Part β) (g : α →o β → Part γ) : α →o Part γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] (f : α →o Part β) (g : α →o β → Part γ) (x : α)
Goal: (f.partBind g) x = (f x).bind (g x)
-- OrderIso.to_galoisConnection
theorem OrderIso.to_galoisConnection [Preorder α] [Preorder β] (oi : α ≃o β) :
    GaloisConnection oi oi.symm 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] (oi : α ≃o β)
Goal: GaloisConnection ⇑oi ⇑oi.symm
-- GaloisConnection.monotone_intro
theorem monotone_intro (hu : Monotone u) (hl : Monotone l) (hul : ∀ a, a ≤ u (l a))
    (hlu : ∀ a, l (u a) ≤ a) : GaloisConnection l u 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {l : α → β} {u : β → α} (hu : Monotone u) (hl : Monotone l) (hul : ∀ (a : α), a ≤ u (l a)) (hlu : ∀ (a : β), l (u a) ≤ a)
Goal: GaloisConnection l u