ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Monotone.isBoundedUnder_le_comp
theorem _root_.Monotone.isBoundedUnder_le_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Monotone v) (hl : l.IsBoundedUnder (· ≤ ·) u) :
    l.IsBoundedUnder (· ≤ ·) (v ∘ u) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α} {v : α → β} (hv : Monotone v) (hl : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (v ∘ u)
-- Monotone.isBoundedUnder_ge_comp
theorem _root_.Monotone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Monotone v) (hl : l.IsBoundedUnder (· ≥ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α} {v : α → β} (hv : Monotone v) (hl : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (v ∘ u)
-- Antitone.isBoundedUnder_le_comp
theorem _root_.Antitone.isBoundedUnder_le_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Antitone v) (hl : l.IsBoundedUnder (· ≥ ·) u) :
    l.IsBoundedUnder (· ≤ ·) (v ∘ u) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α} {v : α → β} (hv : Antitone v) (hl : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (v ∘ u)
-- Antitone.isBoundedUnder_ge_comp
theorem _root_.Antitone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Antitone v) (hl : l.IsBoundedUnder (· ≤ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α} {v : α → β} (hv : Antitone v) (hl : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (v ∘ u)
-- Filter.not_isBoundedUnder_of_tendsto_atTop
theorem not_isBoundedUnder_of_tendsto_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atTop) : ¬IsBoundedUnder (· ≤ ·) l f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α} [l.NeBot] (hf : Filter.Tendsto f l Filter.atTop)
Goal: ¬Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f
-- Filter.not_isBoundedUnder_of_tendsto_atBot
theorem not_isBoundedUnder_of_tendsto_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atBot) : ¬IsBoundedUnder (· ≥ ·) l f 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α} [l.NeBot] (hf : Filter.Tendsto f l Filter.atBot)
Goal: ¬Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f
-- Filter.IsBoundedUnder.bddAbove_range_of_cofinite
theorem IsBoundedUnder.bddAbove_range_of_cofinite [Preorder β] [IsDirected β (· ≤ ·)] {f : α → β}
    (hf : IsBoundedUnder (· ≤ ·) cofinite f) : BddAbove (range f) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [IsDirected β fun x x_1 => x ≤ x_1] {f : α → β} (hf : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) Filter.cofinite f)
Goal: BddAbove (Set.range f)
-- Filter.IsBoundedUnder.bddBelow_range_of_cofinite
theorem IsBoundedUnder.bddBelow_range_of_cofinite [Preorder β] [IsDirected β (· ≥ ·)] {f : α → β}
    (hf : IsBoundedUnder (· ≥ ·) cofinite f) : BddBelow (range f) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] [IsDirected β fun x x_1 => x ≥ x_1] {f : α → β} (hf : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) Filter.cofinite f)
Goal: BddBelow (Set.range f)
-- Filter.IsBoundedUnder.bddAbove_range
theorem IsBoundedUnder.bddAbove_range [Preorder β] [IsDirected β (· ≤ ·)] {f : ℕ → β}
    (hf : IsBoundedUnder (· ≤ ·) atTop f) : BddAbove (range f) 
Arguments: {β : Type u_2} [Preorder β] [IsDirected β fun x x_1 => x ≤ x_1] {f : ℕ → β} (hf : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) Filter.atTop f)
Goal: BddAbove (Set.range f)
-- Filter.IsBoundedUnder.bddBelow_range
theorem IsBoundedUnder.bddBelow_range [Preorder β] [IsDirected β (· ≥ ·)] {f : ℕ → β}
    (hf : IsBoundedUnder (· ≥ ·) atTop f) : BddBelow (range f) 
Arguments: {β : Type u_2} [Preorder β] [IsDirected β fun x x_1 => x ≥ x_1] {f : ℕ → β} (hf : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) Filter.atTop f)
Goal: BddBelow (Set.range f)
-- Filter.IsCobounded.mk
theorem IsCobounded.mk [IsTrans α r] (a : α) (h : ∀ s ∈ f, ∃ x ∈ s, r a x) : f.IsCobounded r 
Arguments: {α : Type u_1} {r : α → α → Prop} {f : Filter α} [IsTrans α r] (a : α) (h : ∀ s ∈ f, ∃ x ∈ s, r a x)
Goal: Filter.IsCobounded r f
-- Filter.IsBounded.isCobounded_flip
theorem IsBounded.isCobounded_flip [IsTrans α r] [NeBot f] : f.IsBounded r → f.IsCobounded (flip r)
  
Arguments: {α : Type u_1} {r : α → α → Prop} {f : Filter α} [IsTrans α r] [f.NeBot]
Goal: Filter.IsBounded r f → Filter.IsCobounded (flip r) f
-- Filter.IsBounded.isCobounded_ge
theorem IsBounded.isCobounded_ge [Preorder α] [NeBot f] (h : f.IsBounded (· ≤ ·)) :
    f.IsCobounded (· ≥ ·) 
Arguments: {α : Type u_1} {f : Filter α} [Preorder α] [f.NeBot] (h : Filter.IsBounded (fun x x_1 => x ≤ x_1) f)
Goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) f
-- Filter.IsBounded.isCobounded_le
theorem IsBounded.isCobounded_le [Preorder α] [NeBot f] (h : f.IsBounded (· ≥ ·)) :
    f.IsCobounded (· ≤ ·) 
Arguments: {α : Type u_1} {f : Filter α} [Preorder α] [f.NeBot] (h : Filter.IsBounded (fun x x_1 => x ≥ x_1) f)
Goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) f
-- Filter.IsBoundedUnder.isCoboundedUnder_flip
theorem IsBoundedUnder.isCoboundedUnder_flip {u : γ → α} {l : Filter γ} [IsTrans α r] [NeBot l]
    (h : l.IsBoundedUnder r u) : l.IsCoboundedUnder (flip r) u 
Arguments: {α : Type u_1} {γ : Type u_3} {r : α → α → Prop} {u : γ → α} {l : Filter γ} [IsTrans α r] [l.NeBot] (h : Filter.IsBoundedUnder r l u)
Goal: Filter.IsCoboundedUnder (flip r) l u
-- Filter.IsBoundedUnder.isCoboundedUnder_le
theorem IsBoundedUnder.isCoboundedUnder_le {u : γ → α} {l : Filter γ} [Preorder α] [NeBot l]
    (h : l.IsBoundedUnder (· ≥ ·) u) : l.IsCoboundedUnder (· ≤ ·) u 
Arguments: {α : Type u_1} {γ : Type u_3} {u : γ → α} {l : Filter γ} [Preorder α] [l.NeBot] (h : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l u
-- Filter.IsBoundedUnder.isCoboundedUnder_ge
theorem IsBoundedUnder.isCoboundedUnder_ge {u : γ → α} {l : Filter γ} [Preorder α] [NeBot l]
    (h : l.IsBoundedUnder (· ≤ ·) u) : l.IsCoboundedUnder (· ≥ ·) u 
Arguments: {α : Type u_1} {γ : Type u_3} {u : γ → α} {l : Filter γ} [Preorder α] [l.NeBot] (h : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l u
-- Filter.isCoboundedUnder_le_of_eventually_le
lemma isCoboundedUnder_le_of_eventually_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ᶠ i in l, x ≤ f i) :
    IsCoboundedUnder (· ≤ ·) l f 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ι → α} {x : α} (hf : ∀ᶠ (i : ι) in l, x ≤ f i)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l f
-- Filter.isCoboundedUnder_ge_of_eventually_le
lemma isCoboundedUnder_ge_of_eventually_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ᶠ i in l, f i ≤ x) :
    IsCoboundedUnder (· ≥ ·) l f 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ι → α} {x : α} (hf : ∀ᶠ (i : ι) in l, f i ≤ x)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l f
-- Filter.isCoboundedUnder_le_of_le
lemma isCoboundedUnder_le_of_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ i, x ≤ f i) :
    IsCoboundedUnder (· ≤ ·) l f 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ι → α} {x : α} (hf : ∀ (i : ι), x ≤ f i)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l f
-- Filter.isCoboundedUnder_ge_of_le
lemma isCoboundedUnder_ge_of_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ i, f i ≤ x) :
    IsCoboundedUnder (· ≥ ·) l f 
Arguments: {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ι → α} {x : α} (hf : ∀ (i : ι), f i ≤ x)
Goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l f
-- Filter.isCobounded_bot
theorem isCobounded_bot : IsCobounded r ⊥ ↔ ∃ b, ∀ x, r b x 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: Filter.IsCobounded r ⊥ ↔ ∃ b, ∀ (x : α), r b x
-- Filter.isCobounded_top
theorem isCobounded_top : IsCobounded r ⊤ ↔ Nonempty α 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: Filter.IsCobounded r ⊤ ↔ Nonempty α
-- Filter.isCobounded_principal
theorem isCobounded_principal (s : Set α) :
    (𝓟 s).IsCobounded r ↔ ∃ b, ∀ a, (∀ x ∈ s, r x a) → r b a 
Arguments: {α : Type u_1} {r : α → α → Prop} (s : Set α)
Goal: Filter.IsCobounded r (𝓟 s) ↔ ∃ b, ∀ (a : α), (∀ x ∈ s, r x a) → r b a
-- Filter.IsCobounded.mono
theorem IsCobounded.mono (h : f ≤ g) : f.IsCobounded r → g.IsCobounded r
  
Arguments: {α : Type u_1} {r : α → α → Prop} {f g : Filter α} (h : f ≤ g)
Goal: Filter.IsCobounded r f → Filter.IsCobounded r g
-- Filter.isBoundedUnder_ge_add
lemma isBoundedUnder_ge_add [Add R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u v : α → R} (u_bdd_ge : f.IsBoundedUnder (· ≥ ·) u) (v_bdd_ge : f.IsBoundedUnder (· ≥ ·) v) :
    f.IsBoundedUnder (· ≥ ·) (u + v) 
Arguments: {α : Type u_6} {f : Filter α} {R : Type u_7} [Preorder R] [Add R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] {u v : α → R} (u_bdd_ge : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) (v_bdd_ge : Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f v)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u + v)
-- Filter.isBoundedUnder_le_add
lemma isBoundedUnder_le_add [Add R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u v : α → R} (u_bdd_le : f.IsBoundedUnder (· ≤ ·) u) (v_bdd_le : f.IsBoundedUnder (· ≤ ·) v) :
    f.IsBoundedUnder (· ≤ ·) (u + v) 
Arguments: {α : Type u_6} {f : Filter α} {R : Type u_7} [Preorder R] [Add R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] {u v : α → R} (u_bdd_le : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) (v_bdd_le : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (u + v)
-- Filter.isBoundedUnder_sum
lemma isBoundedUnder_sum {κ : Type*} [AddCommMonoid R] {r : R → R → Prop}
    (hr : ∀ (v₁ v₂ : α → R), f.IsBoundedUnder r v₁ → f.IsBoundedUnder r v₂
      → f.IsBoundedUnder r (v₁ + v₂)) (hr₀ : r 0 0)
    {u : κ → α → R} (s : Finset κ) (h : ∀ k ∈ s, f.IsBoundedUnder r (u k)) :
    f.IsBoundedUnder r (∑ k ∈ s, u k) 
Arguments: {α : Type u_6} {f : Filter α} {R : Type u_7} {κ : Type u_8} [AddCommMonoid R] {r : R → R → Prop} (hr :
  ∀ (v₁ v₂ : α → R), Filter.IsBoundedUnder r f v₁ → Filter.IsBoundedUnder r f v₂ → Filter.IsBoundedUnder r f (v₁ + v₂)) (hr₀ : r 0 0) {u : κ → α → R} (s : Finset κ) (h : ∀ k ∈ s, Filter.IsBoundedUnder r f (u k))
Goal: Filter.IsBoundedUnder r f (∑ k ∈ s, u k)
-- Filter.isBoundedUnder_le_sum
lemma isBoundedUnder_le_sum {κ : Type*} [AddCommMonoid R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u : κ → α → R} (s : Finset κ) :
    (∀ k ∈ s, f.IsBoundedUnder (· ≤ ·) (u k)) → f.IsBoundedUnder (· ≤ ·) (∑ k ∈ s, u k) 
Arguments: {α : Type u_6} {f : Filter α} {R : Type u_7} [Preorder R] {κ : Type u_8} [AddCommMonoid R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] {u : κ → α → R} (s : Finset κ)
Goal: (∀ k ∈ s, Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (u k)) →
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (∑ k ∈ s, u k)
-- Filter.isBoundedUnder_ge_sum
lemma isBoundedUnder_ge_sum {κ : Type*} [AddCommMonoid R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u : κ → α → R} (s : Finset κ) :
    (∀ k ∈ s, f.IsBoundedUnder (· ≥ ·) (u k)) →
      f.IsBoundedUnder (· ≥ ·) (∑ k ∈ s, u k) 
Arguments: {α : Type u_6} {f : Filter α} {R : Type u_7} [Preorder R] {κ : Type u_8} [AddCommMonoid R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] {u : κ → α → R} (s : Finset κ)
Goal: (∀ k ∈ s, Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) →
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k)
-- Filter.isBounded_le_atBot
theorem isBounded_le_atBot : (atBot : Filter α).IsBounded (· ≤ ·) 
Arguments: {α : Type u_1} [Preorder α] [Nonempty α]
Goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) Filter.atBot
-- Filter.isBounded_ge_atTop
theorem isBounded_ge_atTop : (atTop : Filter α).IsBounded (· ≥ ·) 
Arguments: {α : Type u_1} [Preorder α] [Nonempty α]
Goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) Filter.atTop
-- Filter.Tendsto.isBoundedUnder_le_atBot
theorem Tendsto.isBoundedUnder_le_atBot (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Nonempty α] {f : Filter β} {u : β → α} (h : Filter.Tendsto u f Filter.atBot)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u
-- Filter.Tendsto.isBoundedUnder_ge_atTop
theorem Tendsto.isBoundedUnder_ge_atTop (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Nonempty α] {f : Filter β} {u : β → α} (h : Filter.Tendsto u f Filter.atTop)
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u
-- Filter.bddAbove_range_of_tendsto_atTop_atBot
theorem bddAbove_range_of_tendsto_atTop_atBot [IsDirected α (· ≤ ·)] {u : ℕ → α}
    (hx : Tendsto u atTop atBot) : BddAbove (Set.range u) 
Arguments: {α : Type u_1} [Preorder α] [Nonempty α] [IsDirected α fun x x_1 => x ≤ x_1] {u : ℕ → α} (hx : Filter.Tendsto u Filter.atTop Filter.atBot)
Goal: BddAbove (Set.range u)
-- Filter.bddBelow_range_of_tendsto_atTop_atTop
theorem bddBelow_range_of_tendsto_atTop_atTop [IsDirected α (· ≥ ·)] {u : ℕ → α}
    (hx : Tendsto u atTop atTop) : BddBelow (Set.range u) 
Arguments: {α : Type u_1} [Preorder α] [Nonempty α] [IsDirected α fun x x_1 => x ≥ x_1] {u : ℕ → α} (hx : Filter.Tendsto u Filter.atTop Filter.atTop)
Goal: BddBelow (Set.range u)
-- Filter.isCobounded_le_of_bot
theorem isCobounded_le_of_bot [Preorder α] [OrderBot α] {f : Filter α} : f.IsCobounded (· ≤ ·) 
Arguments: {α : Type u_1} [Preorder α] [OrderBot α] {f : Filter α}
Goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) f
-- Filter.isCobounded_ge_of_top
theorem isCobounded_ge_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsCobounded (· ≥ ·) 
Arguments: {α : Type u_1} [Preorder α] [OrderTop α] {f : Filter α}
Goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) f
-- Filter.isBounded_le_of_top
theorem isBounded_le_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsBounded (· ≤ ·) 
Arguments: {α : Type u_1} [Preorder α] [OrderTop α] {f : Filter α}
Goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) f
-- Filter.isBounded_ge_of_bot
theorem isBounded_ge_of_bot [Preorder α] [OrderBot α] {f : Filter α} : f.IsBounded (· ≥ ·) 
Arguments: {α : Type u_1} [Preorder α] [OrderBot α] {f : Filter α}
Goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) f
-- OrderIso.isBoundedUnder_le_comp
@[simp]
theorem _root_.OrderIso.isBoundedUnder_le_comp [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ}
    {u : γ → α} : (IsBoundedUnder (· ≤ ·) l fun x => e (u x)) ↔ IsBoundedUnder (· ≤ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ} {u : γ → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
-- OrderIso.isBoundedUnder_ge_comp
@[simp]
theorem _root_.OrderIso.isBoundedUnder_ge_comp [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ}
    {u : γ → α} : (IsBoundedUnder (· ≥ ·) l fun x => e (u x)) ↔ IsBoundedUnder (· ≥ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ} {u : γ → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u
-- Filter.isBoundedUnder_le_inv
@[to_additive (attr := simp)]
theorem isBoundedUnder_le_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≤ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≥ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedCommGroup α] {l : Filter β} {u : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => (u x)⁻¹) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u
-- Filter.isBoundedUnder_le_neg
@[to_additive (attr := simp)]
theorem isBoundedUnder_le_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≤ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≥ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedAddCommGroup α] {l : Filter β} {u : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => -u x) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u
-- Filter.isBoundedUnder_ge_neg
@[to_additive (attr := simp)]
theorem isBoundedUnder_ge_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≥ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≤ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedAddCommGroup α] {l : Filter β} {u : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => -u x) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
-- Filter.isBoundedUnder_ge_inv
@[to_additive (attr := simp)]
theorem isBoundedUnder_ge_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≥ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≤ ·) l u 
Arguments: {α : Type u_1} {β : Type u_2} [OrderedCommGroup α] {l : Filter β} {u : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => (u x)⁻¹) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u
-- Filter.IsBoundedUnder.sup
theorem IsBoundedUnder.sup [SemilatticeSup α] {f : Filter β} {u v : β → α} :
    f.IsBoundedUnder (· ≤ ·) u →
      f.IsBoundedUnder (· ≤ ·) v → f.IsBoundedUnder (· ≤ ·) fun a => u a ⊔ v a
  
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeSup α] {f : Filter β} {u v : β → α}
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u →
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v → Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => u a ⊔ v a
-- Filter.isBoundedUnder_le_sup
@[simp]
theorem isBoundedUnder_le_sup [SemilatticeSup α] {f : Filter β} {u v : β → α} :
    (f.IsBoundedUnder (· ≤ ·) fun a => u a ⊔ v a) ↔
      f.IsBoundedUnder (· ≤ ·) u ∧ f.IsBoundedUnder (· ≤ ·) v 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeSup α] {f : Filter β} {u v : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => u a ⊔ v a) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v
-- Filter.IsBoundedUnder.inf
theorem IsBoundedUnder.inf [SemilatticeInf α] {f : Filter β} {u v : β → α} :
    f.IsBoundedUnder (· ≥ ·) u →
      f.IsBoundedUnder (· ≥ ·) v → f.IsBoundedUnder (· ≥ ·) fun a => u a ⊓ v a 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeInf α] {f : Filter β} {u v : β → α}
Goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u →
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f v → Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => u a ⊓ v a
-- Filter.isBoundedUnder_ge_inf
@[simp]
theorem isBoundedUnder_ge_inf [SemilatticeInf α] {f : Filter β} {u v : β → α} :
    (f.IsBoundedUnder (· ≥ ·) fun a => u a ⊓ v a) ↔
      f.IsBoundedUnder (· ≥ ·) u ∧ f.IsBoundedUnder (· ≥ ·) v 
Arguments: {α : Type u_1} {β : Type u_2} [SemilatticeInf α] {f : Filter β} {u v : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => u a ⊓ v a) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f v
-- Filter.isBoundedUnder_le_abs
theorem isBoundedUnder_le_abs [LinearOrderedAddCommGroup α] {f : Filter β} {u : β → α} :
    (f.IsBoundedUnder (· ≤ ·) fun a => |u a|) ↔
      f.IsBoundedUnder (· ≤ ·) u ∧ f.IsBoundedUnder (· ≥ ·) u 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrderedAddCommGroup α] {f : Filter β} {u : β → α}
Goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => |u a|) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u
-- Filter.limsup_eq
theorem limsup_eq : limsup u f = sInf { a | ∀ᶠ n in f, u n ≤ a } 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α}
Goal: Filter.limsup u f = sInf {a | ∀ᶠ (n : β) in f, u n ≤ a}
-- Filter.liminf_eq
theorem liminf_eq : liminf u f = sSup { a | ∀ᶠ n in f, a ≤ u n } 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α}
Goal: Filter.liminf u f = sSup {a | ∀ᶠ (n : β) in f, a ≤ u n}
-- Filter.blimsup_eq
theorem blimsup_eq : blimsup u f p = sInf { a | ∀ᶠ x in f, p x → u x ≤ a } 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.blimsup u f p = sInf {a | ∀ᶠ (x : β) in f, p x → u x ≤ a}
-- Filter.bliminf_eq
theorem bliminf_eq : bliminf u f p = sSup { a | ∀ᶠ x in f, p x → a ≤ u x } 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.bliminf u f p = sSup {a | ∀ᶠ (x : β) in f, p x → a ≤ u x}
-- Filter.liminf_comp
lemma liminf_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    liminf (u ∘ v) f = liminf u (map v f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [ConditionallyCompleteLattice α] (u : β → α) (v : γ → β) (f : Filter γ)
Goal: Filter.liminf (u ∘ v) f = Filter.liminf u (Filter.map v f)
-- Filter.limsup_comp
lemma limsup_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    limsup (u ∘ v) f = limsup u (map v f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [ConditionallyCompleteLattice α] (u : β → α) (v : γ → β) (f : Filter γ)
Goal: Filter.limsup (u ∘ v) f = Filter.limsup u (Filter.map v f)
-- Filter.blimsup_true
@[simp]
theorem blimsup_true (f : Filter β) (u : β → α) : (blimsup u f fun _ => True) = limsup u f 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (f : Filter β) (u : β → α)
Goal: (Filter.blimsup u f fun x => True) = Filter.limsup u f
-- Filter.bliminf_true
@[simp]
theorem bliminf_true (f : Filter β) (u : β → α) : (bliminf u f fun _ => True) = liminf u f 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (f : Filter β) (u : β → α)
Goal: (Filter.bliminf u f fun x => True) = Filter.liminf u f
-- Filter.blimsup_eq_limsup
lemma blimsup_eq_limsup {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup u (f ⊓ 𝓟 {x | p x}) 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.blimsup u f p = Filter.limsup u (f ⊓ 𝓟 {x | p x})
-- Filter.bliminf_eq_liminf
lemma bliminf_eq_liminf {f : Filter β} {u : β → α} {p : β → Prop} :
    bliminf u f p = liminf u (f ⊓ 𝓟 {x | p x}) 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.bliminf u f p = Filter.liminf u (f ⊓ 𝓟 {x | p x})
-- Filter.blimsup_eq_limsup_subtype
theorem blimsup_eq_limsup_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f) 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.blimsup u f p = Filter.limsup (u ∘ Subtype.val) (Filter.comap Subtype.val f)
-- Filter.bliminf_eq_liminf_subtype
theorem bliminf_eq_liminf_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    bliminf u f p = liminf (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f) 
Arguments: {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : β → α} {p : β → Prop}
Goal: Filter.bliminf u f p = Filter.liminf (u ∘ Subtype.val) (Filter.comap Subtype.val f)