ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.map_val_Ici_atTop
@[simp]
theorem map_val_Ici_atTop [SemilatticeSup α] (a : α) : map ((↑) : Ici a → α) atTop = atTop 
Arguments: {α : Type u_3} [SemilatticeSup α] (a : α)
Goal: Filter.map Subtype.val Filter.atTop = Filter.atTop
-- Filter.map_val_Ioi_atTop
@[simp]
theorem map_val_Ioi_atTop [SemilatticeSup α] [NoMaxOrder α] (a : α) :
    map ((↑) : Ioi a → α) atTop = atTop 
Arguments: {α : Type u_3} [SemilatticeSup α] [NoMaxOrder α] (a : α)
Goal: Filter.map Subtype.val Filter.atTop = Filter.atTop
-- Filter.atTop_Ioi_eq
theorem atTop_Ioi_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ioi a → α) atTop 
Arguments: {α : Type u_3} [SemilatticeSup α] (a : α)
Goal: Filter.atTop = Filter.comap Subtype.val Filter.atTop
-- Filter.atTop_Ici_eq
theorem atTop_Ici_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ici a → α) atTop 
Arguments: {α : Type u_3} [SemilatticeSup α] (a : α)
Goal: Filter.atTop = Filter.comap Subtype.val Filter.atTop
-- Filter.map_val_Iio_atBot
@[simp]
theorem map_val_Iio_atBot [SemilatticeInf α] [NoMinOrder α] (a : α) :
    map ((↑) : Iio a → α) atBot = atBot 
Arguments: {α : Type u_3} [SemilatticeInf α] [NoMinOrder α] (a : α)
Goal: Filter.map Subtype.val Filter.atBot = Filter.atBot
-- Filter.atBot_Iio_eq
theorem atBot_Iio_eq [SemilatticeInf α] (a : α) : atBot = comap ((↑) : Iio a → α) atBot 
Arguments: {α : Type u_3} [SemilatticeInf α] (a : α)
Goal: Filter.atBot = Filter.comap Subtype.val Filter.atBot
-- Filter.map_val_Iic_atBot
@[simp]
theorem map_val_Iic_atBot [SemilatticeInf α] (a : α) : map ((↑) : Iic a → α) atBot = atBot 
Arguments: {α : Type u_3} [SemilatticeInf α] (a : α)
Goal: Filter.map Subtype.val Filter.atBot = Filter.atBot
-- Filter.atBot_Iic_eq
theorem atBot_Iic_eq [SemilatticeInf α] (a : α) : atBot = comap ((↑) : Iic a → α) atBot 
Arguments: {α : Type u_3} [SemilatticeInf α] (a : α)
Goal: Filter.atBot = Filter.comap Subtype.val Filter.atBot
-- Filter.tendsto_Ioi_atTop
theorem tendsto_Ioi_atTop [SemilatticeSup α] {a : α} {f : β → Ioi a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] {a : α} {f : β → ↑(Set.Ioi a)} {l : Filter β}
Goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atTop
-- Filter.tendsto_Iio_atBot
theorem tendsto_Iio_atBot [SemilatticeInf α] {a : α} {f : β → Iio a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] {a : α} {f : β → ↑(Set.Iio a)} {l : Filter β}
Goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atBot
-- Filter.tendsto_Ici_atTop
theorem tendsto_Ici_atTop [SemilatticeSup α] {a : α} {f : β → Ici a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] {a : α} {f : β → ↑(Set.Ici a)} {l : Filter β}
Goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atTop
-- Filter.tendsto_Iic_atBot
theorem tendsto_Iic_atBot [SemilatticeInf α] {a : α} {f : β → Iic a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] {a : α} {f : β → ↑(Set.Iic a)} {l : Filter β}
Goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atBot
-- Filter.tendsto_comp_val_Ioi_atTop
@[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Ioi_atTop [SemilatticeSup α] [NoMaxOrder α] {a : α} {f : α → β}
    {l : Filter β} : Tendsto (fun x : Ioi a => f x) atTop l ↔ Tendsto f atTop l 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [NoMaxOrder α] {a : α} {f : α → β} {l : Filter β}
Goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l
-- Filter.tendsto_comp_val_Ici_atTop
@[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Ici_atTop [SemilatticeSup α] {a : α} {f : α → β} {l : Filter β} :
    Tendsto (fun x : Ici a => f x) atTop l ↔ Tendsto f atTop l 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] {a : α} {f : α → β} {l : Filter β}
Goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l
-- Filter.tendsto_comp_val_Iio_atBot
@[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Iio_atBot [SemilatticeInf α] [NoMinOrder α] {a : α} {f : α → β}
    {l : Filter β} : Tendsto (fun x : Iio a => f x) atBot l ↔ Tendsto f atBot l 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] [NoMinOrder α] {a : α} {f : α → β} {l : Filter β}
Goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f Filter.atBot l
-- Filter.tendsto_comp_val_Iic_atBot
@[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Iic_atBot [SemilatticeInf α] {a : α} {f : α → β} {l : Filter β} :
    Tendsto (fun x : Iic a => f x) atBot l ↔ Tendsto f atBot l 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] {a : α} {f : α → β} {l : Filter β}
Goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f Filter.atBot l
-- Filter.map_add_atTop_eq_nat
theorem map_add_atTop_eq_nat (k : ℕ) : map (fun a => a + k) atTop = atTop 
Arguments: (k : ℕ)
Goal: Filter.map (fun a => a + k) Filter.atTop = Filter.atTop
-- Filter.map_sub_atTop_eq_nat
theorem map_sub_atTop_eq_nat (k : ℕ) : map (fun a => a - k) atTop = atTop 
Arguments: (k : ℕ)
Goal: Filter.map (fun a => a - k) Filter.atTop = Filter.atTop
-- Filter.tendsto_add_atTop_nat
theorem tendsto_add_atTop_nat (k : ℕ) : Tendsto (fun a => a + k) atTop atTop 
Arguments: (k : ℕ)
Goal: Filter.Tendsto (fun a => a + k) Filter.atTop Filter.atTop
-- Filter.tendsto_sub_atTop_nat
theorem tendsto_sub_atTop_nat (k : ℕ) : Tendsto (fun a => a - k) atTop atTop 
Arguments: (k : ℕ)
Goal: Filter.Tendsto (fun a => a - k) Filter.atTop Filter.atTop
-- Filter.tendsto_add_atTop_iff_nat
theorem tendsto_add_atTop_iff_nat {f : ℕ → α} {l : Filter α} (k : ℕ) :
    Tendsto (fun n => f (n + k)) atTop l ↔ Tendsto f atTop l 
Arguments: {α : Type u_3} {f : ℕ → α} {l : Filter α} (k : ℕ)
Goal: Filter.Tendsto (fun n => f (n + k)) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l
-- Filter.map_div_atTop_eq_nat
theorem map_div_atTop_eq_nat (k : ℕ) (hk : 0 < k) : map (fun a => a / k) atTop = atTop 
Arguments: (k : ℕ) (hk : 0 < k)
Goal: Filter.map (fun a => a / k) Filter.atTop = Filter.atTop
-- Filter.tendsto_atTop_atTop_of_monotone'
theorem tendsto_atTop_atTop_of_monotone' [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u)
    (H : ¬BddAbove (range u)) : Tendsto u atTop atTop 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u) (H : ¬BddAbove (Set.range u))
Goal: Filter.Tendsto u Filter.atTop Filter.atTop
-- Filter.tendsto_atBot_atBot_of_monotone'
theorem tendsto_atBot_atBot_of_monotone' [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u)
    (H : ¬BddBelow (range u)) : Tendsto u atBot atBot 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u) (H : ¬BddBelow (Set.range u))
Goal: Filter.Tendsto u Filter.atBot Filter.atBot
-- Filter.unbounded_of_tendsto_atTop
theorem unbounded_of_tendsto_atTop [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMaxOrder β]
    {f : α → β} (h : Tendsto f atTop atTop) : ¬BddAbove (range f) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMaxOrder β] {f : α → β} (h : Filter.Tendsto f Filter.atTop Filter.atTop)
Goal: ¬BddAbove (Set.range f)
-- Filter.unbounded_of_tendsto_atBot
theorem unbounded_of_tendsto_atBot [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMinOrder β]
    {f : α → β} (h : Tendsto f atTop atBot) : ¬BddBelow (range f) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMinOrder β] {f : α → β} (h : Filter.Tendsto f Filter.atTop Filter.atBot)
Goal: ¬BddBelow (Set.range f)
-- Filter.unbounded_of_tendsto_atTop'
theorem unbounded_of_tendsto_atTop' [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMaxOrder β]
    {f : α → β} (h : Tendsto f atBot atTop) : ¬BddAbove (range f) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMaxOrder β] {f : α → β} (h : Filter.Tendsto f Filter.atBot Filter.atTop)
Goal: ¬BddAbove (Set.range f)
-- Filter.unbounded_of_tendsto_atBot'
theorem unbounded_of_tendsto_atBot' [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMinOrder β]
    {f : α → β} (h : Tendsto f atBot atBot) : ¬BddBelow (range f) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMinOrder β] {f : α → β} (h : Filter.Tendsto f Filter.atBot Filter.atBot)
Goal: ¬BddBelow (Set.range f)
-- Filter.tendsto_atTop_of_monotone_of_filter
theorem tendsto_atTop_of_monotone_of_filter [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α}
    (h : Monotone u) [NeBot l] (hu : Tendsto u l atTop) : Tendsto u atTop atTop 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α} (h : Monotone u) [l.NeBot] (hu : Filter.Tendsto u l Filter.atTop)
Goal: Filter.Tendsto u Filter.atTop Filter.atTop
-- Filter.tendsto_atBot_of_monotone_of_filter
theorem tendsto_atBot_of_monotone_of_filter [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α}
    (h : Monotone u) [NeBot l] (hu : Tendsto u l atBot) : Tendsto u atBot atBot 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α} (h : Monotone u) [l.NeBot] (hu : Filter.Tendsto u l Filter.atBot)
Goal: Filter.Tendsto u Filter.atBot Filter.atBot
-- Filter.tendsto_atTop_of_monotone_of_subseq
theorem tendsto_atTop_of_monotone_of_subseq [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι}
    (h : Monotone u) {l : Filter ι'} [NeBot l] (H : Tendsto (u ∘ φ) l atTop) :
    Tendsto u atTop atTop 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι} (h : Monotone u) {l : Filter ι'} [l.NeBot] (H : Filter.Tendsto (u ∘ φ) l Filter.atTop)
Goal: Filter.Tendsto u Filter.atTop Filter.atTop
-- Filter.tendsto_atBot_of_monotone_of_subseq
theorem tendsto_atBot_of_monotone_of_subseq [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι}
    (h : Monotone u) {l : Filter ι'} [NeBot l] (H : Tendsto (u ∘ φ) l atBot) :
    Tendsto u atBot atBot 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι} (h : Monotone u) {l : Filter ι'} [l.NeBot] (H : Filter.Tendsto (u ∘ φ) l Filter.atBot)
Goal: Filter.Tendsto u Filter.atBot Filter.atBot
-- Filter.map_atTop_finset_prod_le_of_prod_eq
@[to_additive "Let `f` and `g` be two maps to the same commutative additive monoid. This lemma gives
a sufficient condition for comparison of the filter `atTop.map (fun s ↦ ∑ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∑ b ∈ s, g b)`. This is useful to compare the set of limit points of
`∑ b ∈ s, f b` as `s → atTop` with the similar set for `g`."]
theorem map_atTop_finset_prod_le_of_prod_eq [CommMonoid α] {f : β → α} {g : γ → α}
    (h_eq : ∀ u : Finset γ,
      ∃ v : Finset β, ∀ v', v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b) :
    (atTop.map fun s : Finset β => ∏ b ∈ s, f b) ≤
      atTop.map fun s : Finset γ => ∏ x ∈ s, g x 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [CommMonoid α] {f : β → α} {g : γ → α} (h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b)
Goal: Filter.map (fun s => ∏ b ∈ s, f b) Filter.atTop ≤ Filter.map (fun s => ∏ x ∈ s, g x) Filter.atTop
-- Filter.map_atTop_finset_sum_le_of_sum_eq
@[to_additive "Let `f` and `g` be two maps to the same commutative additive monoid. This lemma gives
a sufficient condition for comparison of the filter `atTop.map (fun s ↦ ∑ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∑ b ∈ s, g b)`. This is useful to compare the set of limit points of
`∑ b ∈ s, f b` as `s → atTop` with the similar set for `g`."]
theorem map_atTop_finset_prod_le_of_prod_eq [CommMonoid α] {f : β → α} {g : γ → α}
    (h_eq : ∀ u : Finset γ,
      ∃ v : Finset β, ∀ v', v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b) :
    (atTop.map fun s : Finset β => ∏ b ∈ s, f b) ≤
      atTop.map fun s : Finset γ => ∏ x ∈ s, g x 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [AddCommMonoid α] {f : β → α} {g : γ → α} (h_eq : ∀ (u : Finset γ), ∃ v, ∀ (v' : Finset β), v ⊆ v' → ∃ u', u ⊆ u' ∧ ∑ x ∈ u', g x = ∑ b ∈ v', f b)
Goal: Filter.map (fun s => ∑ b ∈ s, f b) Filter.atTop ≤ Filter.map (fun s => ∑ x ∈ s, g x) Filter.atTop
-- Filter.HasAntitoneBasis.eventually_subset
theorem HasAntitoneBasis.eventually_subset [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hl : l.HasAntitoneBasis s) {t : Set α} (ht : t ∈ l) : ∀ᶠ i in atTop, s i ⊆ t 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] {l : Filter α} {s : ι → Set α} (hl : l.HasAntitoneBasis s) {t : Set α} (ht : t ∈ l)
Goal: ∀ᶠ (i : ι) in Filter.atTop, s i ⊆ t
-- Filter.HasAntitoneBasis.tendsto
protected theorem HasAntitoneBasis.tendsto [Preorder ι] {l : Filter α} {s : ι → Set α}
    (hl : l.HasAntitoneBasis s) {φ : ι → α} (h : ∀ i : ι, φ i ∈ s i) : Tendsto φ atTop l 
Arguments: {ι : Type u_1} {α : Type u_3} [Preorder ι] {l : Filter α} {s : ι → Set α} (hl : l.HasAntitoneBasis s) {φ : ι → α} (h : ∀ (i : ι), φ i ∈ s i)
Goal: Filter.Tendsto φ Filter.atTop l
-- Filter.HasAntitoneBasis.comp_mono
theorem HasAntitoneBasis.comp_mono [SemilatticeSup ι] [Nonempty ι] [Preorder ι'] {l : Filter α}
    {s : ι' → Set α} (hs : l.HasAntitoneBasis s) {φ : ι → ι'} (φ_mono : Monotone φ)
    (hφ : Tendsto φ atTop atTop) : l.HasAntitoneBasis (s ∘ φ) 
Arguments: {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [SemilatticeSup ι] [Nonempty ι] [Preorder ι'] {l : Filter α} {s : ι' → Set α} (hs : l.HasAntitoneBasis s) {φ : ι → ι'} (φ_mono : Monotone φ) (hφ : Filter.Tendsto φ Filter.atTop Filter.atTop)
Goal: l.HasAntitoneBasis (s ∘ φ)
-- Filter.HasAntitoneBasis.comp_strictMono
theorem HasAntitoneBasis.comp_strictMono {l : Filter α} {s : ℕ → Set α} (hs : l.HasAntitoneBasis s)
    {φ : ℕ → ℕ} (hφ : StrictMono φ) : l.HasAntitoneBasis (s ∘ φ) 
Arguments: {α : Type u_3} {l : Filter α} {s : ℕ → Set α} (hs : l.HasAntitoneBasis s) {φ : ℕ → ℕ} (hφ : StrictMono φ)
Goal: l.HasAntitoneBasis (s ∘ φ)
-- Filter.HasAntitoneBasis.subbasis_with_rel
theorem HasAntitoneBasis.subbasis_with_rel {f : Filter α} {s : ℕ → Set α}
    (hs : f.HasAntitoneBasis s) {r : ℕ → ℕ → Prop} (hr : ∀ m, ∀ᶠ n in atTop, r m n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ (∀ ⦃m n⦄, m < n → r (φ m) (φ n)) ∧ f.HasAntitoneBasis (s ∘ φ) 
Arguments: {α : Type u_3} {f : Filter α} {s : ℕ → Set α} (hs : f.HasAntitoneBasis s) {r : ℕ → ℕ → Prop} (hr : ∀ (m : ℕ), ∀ᶠ (n : ℕ) in Filter.atTop, r m n)
Goal: ∃ φ, StrictMono φ ∧ (∀ ⦃m n : ℕ⦄, m < n → r (φ m) (φ n)) ∧ f.HasAntitoneBasis (s ∘ φ)
-- Filter.exists_seq_tendsto
theorem exists_seq_tendsto (f : Filter α) [IsCountablyGenerated f] [NeBot f] :
    ∃ x : ℕ → α, Tendsto x atTop f 
Arguments: {α : Type u_3} (f : Filter α) [f.IsCountablyGenerated] [f.NeBot]
Goal: ∃ x, Filter.Tendsto x Filter.atTop f
-- Filter.exists_seq_monotone_tendsto_atTop_atTop
theorem exists_seq_monotone_tendsto_atTop_atTop (α : Type*) [SemilatticeSup α] [Nonempty α]
    [(atTop : Filter α).IsCountablyGenerated] :
    ∃ xs : ℕ → α, Monotone xs ∧ Tendsto xs atTop atTop 
Arguments: (α : Type u_6) [SemilatticeSup α] [Nonempty α] [Filter.atTop.IsCountablyGenerated]
Goal: ∃ xs, Monotone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atTop
-- Filter.exists_seq_antitone_tendsto_atTop_atBot
theorem exists_seq_antitone_tendsto_atTop_atBot (α : Type*) [SemilatticeInf α] [Nonempty α]
    [h2 : (atBot : Filter α).IsCountablyGenerated] :
    ∃ xs : ℕ → α, Antitone xs ∧ Tendsto xs atTop atBot 
Arguments: (α : Type u_6) [SemilatticeInf α] [Nonempty α] [h2 : Filter.atBot.IsCountablyGenerated]
Goal: ∃ xs, Antitone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atBot
-- Filter.tendsto_iff_seq_tendsto
theorem tendsto_iff_seq_tendsto {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated] :
    Tendsto f k l ↔ ∀ x : ℕ → α, Tendsto x atTop k → Tendsto (f ∘ x) atTop l 
Arguments: {α : Type u_3} {β : Type u_4} {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated]
Goal: Filter.Tendsto f k l ↔ ∀ (x : ℕ → α), Filter.Tendsto x Filter.atTop k → Filter.Tendsto (f ∘ x) Filter.atTop l
-- Filter.tendsto_of_seq_tendsto
theorem tendsto_of_seq_tendsto {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated] :
    (∀ x : ℕ → α, Tendsto x atTop k → Tendsto (f ∘ x) atTop l) → Tendsto f k l 
Arguments: {α : Type u_3} {β : Type u_4} {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated]
Goal: (∀ (x : ℕ → α), Filter.Tendsto x Filter.atTop k → Filter.Tendsto (f ∘ x) Filter.atTop l) → Filter.Tendsto f k l
-- Filter.eventually_iff_seq_eventually
theorem eventually_iff_seq_eventually {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∀ᶠ n in l, p n) ↔ ∀ x : ℕ → ι, Tendsto x atTop l → ∀ᶠ n : ℕ in atTop, p (x n) 
Arguments: {ι : Type u_6} {l : Filter ι} {p : ι → Prop} [l.IsCountablyGenerated]
Goal: (∀ᶠ (n : ι) in l, p n) ↔ ∀ (x : ℕ → ι), Filter.Tendsto x Filter.atTop l → ∀ᶠ (n : ℕ) in Filter.atTop, p (x n)
-- Filter.frequently_iff_seq_frequently
theorem frequently_iff_seq_frequently {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∃ᶠ n in l, p n) ↔ ∃ x : ℕ → ι, Tendsto x atTop l ∧ ∃ᶠ n : ℕ in atTop, p (x n) 
Arguments: {ι : Type u_6} {l : Filter ι} {p : ι → Prop} [l.IsCountablyGenerated]
Goal: (∃ᶠ (n : ι) in l, p n) ↔ ∃ x, Filter.Tendsto x Filter.atTop l ∧ ∃ᶠ (n : ℕ) in Filter.atTop, p (x n)
-- Filter.subseq_forall_of_frequently
theorem subseq_forall_of_frequently {ι : Type*} {x : ℕ → ι} {p : ι → Prop} {l : Filter ι}
    (h_tendsto : Tendsto x atTop l) (h : ∃ᶠ n in atTop, p (x n)) :
    ∃ ns : ℕ → ℕ, Tendsto (fun n => x (ns n)) atTop l ∧ ∀ n, p (x (ns n)) 
Arguments: {ι : Type u_6} {x : ℕ → ι} {p : ι → Prop} {l : Filter ι} (h_tendsto : Filter.Tendsto x Filter.atTop l) (h : ∃ᶠ (n : ℕ) in Filter.atTop, p (x n))
Goal: ∃ ns, Filter.Tendsto (fun n => x (ns n)) Filter.atTop l ∧ ∀ (n : ℕ), p (x (ns n))
-- Filter.exists_seq_forall_of_frequently
theorem exists_seq_forall_of_frequently {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] (h : ∃ᶠ n in l, p n) :
    ∃ ns : ℕ → ι, Tendsto ns atTop l ∧ ∀ n, p (ns n) 
Arguments: {ι : Type u_6} {l : Filter ι} {p : ι → Prop} [l.IsCountablyGenerated] (h : ∃ᶠ (n : ι) in l, p n)
Goal: ∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n)
-- Filter.frequently_iff_seq_forall
lemma frequently_iff_seq_forall {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∃ᶠ n in l, p n) ↔ ∃ ns : ℕ → ι, Tendsto ns atTop l ∧ ∀ n, p (ns n) 
Arguments: {ι : Type u_6} {l : Filter ι} {p : ι → Prop} [l.IsCountablyGenerated]
Goal: (∃ᶠ (n : ι) in l, p n) ↔ ∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n)
-- Filter.tendsto_of_subseq_tendsto
theorem tendsto_of_subseq_tendsto {ι : Type*} {x : ι → α} {f : Filter α} {l : Filter ι}
    [l.IsCountablyGenerated]
    (hxy : ∀ ns : ℕ → ι, Tendsto ns atTop l →
      ∃ ms : ℕ → ℕ, Tendsto (fun n => x (ns <| ms n)) atTop f) :
    Tendsto x l f 
Arguments: {α : Type u_3} {ι : Type u_6} {x : ι → α} {f : Filter α} {l : Filter ι} [l.IsCountablyGenerated] (hxy : ∀ (ns : ℕ → ι), Filter.Tendsto ns Filter.atTop l → ∃ ms, Filter.Tendsto (fun n => x (ns (ms n))) Filter.atTop f)
Goal: Filter.Tendsto x l f
-- Filter.subseq_tendsto_of_neBot
theorem subseq_tendsto_of_neBot {f : Filter α} [IsCountablyGenerated f] {u : ℕ → α}
    (hx : NeBot (f ⊓ map u atTop)) : ∃ θ : ℕ → ℕ, StrictMono θ ∧ Tendsto (u ∘ θ) atTop f 
Arguments: {α : Type u_3} {f : Filter α} [f.IsCountablyGenerated] {u : ℕ → α} (hx : (f ⊓ Filter.map u Filter.atTop).NeBot)
Goal: ∃ θ, StrictMono θ ∧ Filter.Tendsto (u ∘ θ) Filter.atTop f
-- exists_lt_mul_self
theorem exists_lt_mul_self (a : R) : ∃ x ≥ 0, a < x * x 
Arguments: {R : Type u_6} [LinearOrderedSemiring R] (a : R)
Goal: ∃ x ≥ 0, a < x * x
-- exists_le_mul_self
theorem exists_le_mul_self (a : R) : ∃ x ≥ 0, a ≤ x * x 
Arguments: {R : Type u_6} [LinearOrderedSemiring R] (a : R)
Goal: ∃ x ≥ 0, a ≤ x * x
-- Monotone.piecewise_eventually_eq_iUnion
theorem Monotone.piecewise_eventually_eq_iUnion {β : α → Type*} [Preorder ι] {s : ι → Set α}
    [∀ i, DecidablePred (· ∈ s i)] [DecidablePred (· ∈ ⋃ i, s i)]
    (hs : Monotone s) (f g : (a : α) → β a) (a : α) :
    ∀ᶠ i in atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a 
Arguments: {ι : Type u_1} {α : Type u_3} {β : α → Type u_6} [Preorder ι] {s : ι → Set α} [(i : ι) → DecidablePred fun x => x ∈ s i] [DecidablePred fun x => x ∈ ⋃ i, s i] (hs : Monotone s) (f g : (a : α) → β a) (a : α)
Goal: ∀ᶠ (i : ι) in Filter.atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a
-- Antitone.piecewise_eventually_eq_iInter
theorem Antitone.piecewise_eventually_eq_iInter {β : α → Type*} [Preorder ι] {s : ι → Set α}
    [∀ i, DecidablePred (· ∈ s i)] [DecidablePred (· ∈ ⋂ i, s i)]
    (hs : Antitone s) (f g : (a : α) → β a) (a : α) :
    ∀ᶠ i in atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a 
Arguments: {ι : Type u_1} {α : Type u_3} {β : α → Type u_6} [Preorder ι] {s : ι → Set α} [(i : ι) → DecidablePred fun x => x ∈ s i] [DecidablePred fun x => x ∈ ⋂ i, s i] (hs : Antitone s) (f g : (a : α) → β a) (a : α)
Goal: ∀ᶠ (i : ι) in Filter.atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a
-- Function.Injective.map_atTop_finset_sum_eq
@[to_additive]
theorem Function.Injective.map_atTop_finset_prod_eq [CommMonoid α] {g : γ → β}
    (hg : Function.Injective g) {f : β → α} (hf : ∀ x, x ∉ Set.range g → f x = 1) :
    map (fun s => ∏ i ∈ s, f (g i)) atTop = map (fun s => ∏ i ∈ s, f i) atTop 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [AddCommMonoid α] {g : γ → β} (hg : Function.Injective g) {f : β → α} (hf : ∀ x ∉ Set.range g, f x = 0)
Goal: Filter.map (fun s => ∑ i ∈ s, f (g i)) Filter.atTop = Filter.map (fun s => ∑ i ∈ s, f i) Filter.atTop
-- Function.Injective.map_atTop_finset_prod_eq
@[to_additive]
theorem Function.Injective.map_atTop_finset_prod_eq [CommMonoid α] {g : γ → β}
    (hg : Function.Injective g) {f : β → α} (hf : ∀ x, x ∉ Set.range g → f x = 1) :
    map (fun s => ∏ i ∈ s, f (g i)) atTop = map (fun s => ∏ i ∈ s, f i) atTop 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [CommMonoid α] {g : γ → β} (hg : Function.Injective g) {f : β → α} (hf : ∀ x ∉ Set.range g, f x = 1)
Goal: Filter.map (fun s => ∏ i ∈ s, f (g i)) Filter.atTop = Filter.map (fun s => ∏ i ∈ s, f i) Filter.atTop
-- Finset.SupIndep.subset
theorem SupIndep.subset (ht : t.SupIndep f) (h : s ⊆ t) : s.SupIndep f 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] {s t : Finset ι} {f : ι → α} (ht : t.SupIndep f) (h : s ⊆ t)
Goal: s.SupIndep f
-- Finset.supIndep_empty
@[simp]
theorem supIndep_empty (f : ι → α) : (∅ : Finset ι).SupIndep f 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] (f : ι → α)
Goal: ∅.SupIndep f
-- Finset.supIndep_singleton
theorem supIndep_singleton (i : ι) (f : ι → α) : ({i} : Finset ι).SupIndep f 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] (i : ι) (f : ι → α)
Goal: {i}.SupIndep f
-- Finset.SupIndep.pairwiseDisjoint
theorem SupIndep.pairwiseDisjoint (hs : s.SupIndep f) : (s : Set ι).PairwiseDisjoint f 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] {s : Finset ι} {f : ι → α} (hs : s.SupIndep f)
Goal: (↑s).PairwiseDisjoint f
-- Finset.SupIndep.le_sup_iff
theorem SupIndep.le_sup_iff (hs : s.SupIndep f) (hts : t ⊆ s) (hi : i ∈ s) (hf : ∀ i, f i ≠ ⊥) :
    f i ≤ t.sup f ↔ i ∈ t 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι} (hs : s.SupIndep f) (hts : t ⊆ s) (hi : i ∈ s) (hf : ∀ (i : ι), f i ≠ ⊥)
Goal: f i ≤ t.sup f ↔ i ∈ t
-- Finset.supIndep_iff_disjoint_erase
theorem supIndep_iff_disjoint_erase [DecidableEq ι] :
    s.SupIndep f ↔ ∀ i ∈ s, Disjoint (f i) ((s.erase i).sup f) 
Arguments: {α : Type u_1} {ι : Type u_3} [Lattice α] [OrderBot α] {s : Finset ι} {f : ι → α} [DecidableEq ι]
Goal: s.SupIndep f ↔ ∀ i ∈ s, Disjoint (f i) ((s.erase i).sup f)