ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finpartition.IsEquipartition.card_large_parts_eq_mod
theorem IsEquipartition.card_large_parts_eq_mod (hP : P.IsEquipartition) :
    (P.parts.filter fun p ↦ p.card = s.card / P.parts.card + 1).card = s.card % P.parts.card 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {P : Finpartition s} (hP : P.IsEquipartition)
Goal: (Finset.filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
-- Finpartition.IsEquipartition.card_small_parts_eq_mod
theorem IsEquipartition.card_small_parts_eq_mod (hP : P.IsEquipartition) :
    (P.parts.filter fun p ↦ p.card = s.card / P.parts.card).card =
    P.parts.card - s.card % P.parts.card 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {P : Finpartition s} (hP : P.IsEquipartition)
Goal: (Finset.filter (fun p => p.card = s.card / P.parts.card) P.parts).card = P.parts.card - s.card % P.parts.card
-- Finpartition.IsEquipartition.exists_partsEquiv
theorem IsEquipartition.exists_partsEquiv (hP : P.IsEquipartition) :
    ∃ f : P.parts ≃ Fin P.parts.card,
      ∀ t, t.1.card = s.card / P.parts.card + 1 ↔ f t < s.card % P.parts.card 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {P : Finpartition s} (hP : P.IsEquipartition)
Goal: ∃ f, ∀ (t : { x // x ∈ P.parts }), (↑t).card = s.card / P.parts.card + 1 ↔ ↑(f t) < s.card % P.parts.card
-- Finpartition.IsEquipartition.exists_partPreservingEquiv
theorem IsEquipartition.exists_partPreservingEquiv (hP : P.IsEquipartition) : ∃ f : s ≃ Fin s.card,
    ∀ a b : s, P.part a = P.part b ↔ f a % P.parts.card = f b % P.parts.card 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {P : Finpartition s} (hP : P.IsEquipartition)
Goal: ∃ f, ∀ (a b : { x // x ∈ s }), P.part ↑a = P.part ↑b ↔ ↑(f a) % P.parts.card = ↑(f b) % P.parts.card
-- Finpartition.bot_isEquipartition
theorem bot_isEquipartition : (⊥ : Finpartition s).IsEquipartition 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: ⊥.IsEquipartition
-- Finpartition.top_isEquipartition
theorem top_isEquipartition [Decidable (s = ⊥)] : (⊤ : Finpartition s).IsEquipartition 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) [Decidable (s = ⊥)]
Goal: ⊤.IsEquipartition
-- Finpartition.indiscrete_isEquipartition
theorem indiscrete_isEquipartition {hs : s ≠ ∅} : (indiscrete hs).IsEquipartition 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) {hs : s ≠ ∅}
Goal: (Finpartition.indiscrete hs).IsEquipartition
-- Filter.EventuallyLE.mul_le_mul
theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
    {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
    (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
Arguments: {α : Type u} {β : Type v} [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁) (hf₀ : 0 ≤ᶠ[l] f₂)
Goal: f₁ * g₁ ≤ᶠ[l] f₂ * g₂
-- Filter.EventuallyLE.mul_le_mul'
@[to_additive EventuallyLE.add_le_add]
theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
    [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
    (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
Arguments: {α : Type u} {β : Type v} [Mul β] [Preorder β] [CovariantClass β β (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass β β (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂)
Goal: f₁ * g₁ ≤ᶠ[l] f₂ * g₂
-- Filter.EventuallyLE.add_le_add
@[to_additive EventuallyLE.add_le_add]
theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
    [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
    (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ 
Arguments: {α : Type u} {β : Type v} [Add β] [Preorder β] [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass β β (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂)
Goal: f₁ + g₁ ≤ᶠ[l] f₂ + g₂
-- Filter.EventuallyLE.mul_nonneg
theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
    (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g 
Arguments: {α : Type u} {β : Type v} [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f) (hg : 0 ≤ᶠ[l] g)
Goal: 0 ≤ᶠ[l] f * g
-- Filter.eventually_sub_nonneg
theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
    0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g 
Arguments: {α : Type u} {β : Type v} [OrderedRing β] {l : Filter α} {f g : α → β}
Goal: 0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g
-- HasCountableSeparatingOn.exists_countable_separating
class HasCountableSeparatingOn (α : Type*) (p : Set α → Prop) (t : Set α) : Prop where
  exists_countable_separating : ∃ S : Set (Set α), S.Countable ∧ (∀ s ∈ S, p s) ∧
    ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
Arguments: {α : Type u_1} {p : Set α → Prop} {t : Set α} [self : HasCountableSeparatingOn α p t]
Goal: ∃ S, S.Countable ∧ (∀ s ∈ S, p s) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
-- exists_countable_separating
theorem exists_countable_separating (α : Type*) (p : Set α → Prop) (t : Set α)
    [h : HasCountableSeparatingOn α p t] :
    ∃ S : Set (Set α), S.Countable ∧ (∀ s ∈ S, p s) ∧
      ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y 
Arguments: (α : Type u_1) (p : Set α → Prop) (t : Set α) [h : HasCountableSeparatingOn α p t]
Goal: ∃ S, S.Countable ∧ (∀ s ∈ S, p s) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
-- exists_nonempty_countable_separating
theorem exists_nonempty_countable_separating (α : Type*) {p : Set α → Prop} {s₀} (hp : p s₀)
    (t : Set α) [HasCountableSeparatingOn α p t] :
    ∃ S : Set (Set α), S.Nonempty ∧ S.Countable ∧ (∀ s ∈ S, p s) ∧
      ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y 
Arguments: (α : Type u_1) {p : Set α → Prop} {s₀ : Set α} (hp : p s₀) (t : Set α) [HasCountableSeparatingOn α p t]
Goal: ∃ S, S.Nonempty ∧ S.Countable ∧ (∀ s ∈ S, p s) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
-- exists_seq_separating
theorem exists_seq_separating (α : Type*) {p : Set α → Prop} {s₀} (hp : p s₀) (t : Set α)
    [HasCountableSeparatingOn α p t] :
    ∃ S : ℕ → Set α, (∀ n, p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ n, x ∈ S n ↔ y ∈ S n) → x = y 
Arguments: (α : Type u_1) {p : Set α → Prop} {s₀ : Set α} (hp : p s₀) (t : Set α) [HasCountableSeparatingOn α p t]
Goal: ∃ S, (∀ (n : ℕ), p (S n)) ∧ ∀ x ∈ t, ∀ y ∈ t, (∀ (n : ℕ), x ∈ S n ↔ y ∈ S n) → x = y
-- HasCountableSeparatingOn.mono
theorem HasCountableSeparatingOn.mono {α} {p₁ p₂ : Set α → Prop} {t₁ t₂ : Set α}
    [h : HasCountableSeparatingOn α p₁ t₁] (hp : ∀ s, p₁ s → p₂ s) (ht : t₂ ⊆ t₁) :
    HasCountableSeparatingOn α p₂ t₂ 
Arguments: {α : Type u_1} {p₁ p₂ : Set α → Prop} {t₁ t₂ : Set α} [h : HasCountableSeparatingOn α p₁ t₁] (hp : ∀ (s : Set α), p₁ s → p₂ s) (ht : t₂ ⊆ t₁)
Goal: HasCountableSeparatingOn α p₂ t₂
-- HasCountableSeparatingOn.of_subtype
theorem HasCountableSeparatingOn.of_subtype {α : Type*} {p : Set α → Prop} {t : Set α}
    {q : Set t → Prop} [h : HasCountableSeparatingOn t q univ]
    (hpq : ∀ U, q U → ∃ V, p V ∧ (↑) ⁻¹' V = U) : HasCountableSeparatingOn α p t 
Arguments: {α : Type u_1} {p : Set α → Prop} {t : Set α} {q : Set ↑t → Prop} [h : HasCountableSeparatingOn (↑t) q Set.univ] (hpq : ∀ (U : Set ↑t), q U → ∃ V, p V ∧ Subtype.val ⁻¹' V = U)
Goal: HasCountableSeparatingOn α p t
-- HasCountableSeparatingOn.subtype_iff
theorem HasCountableSeparatingOn.subtype_iff {α : Type*} {p : Set α → Prop} {t : Set α} :
    HasCountableSeparatingOn t (fun u ↦ ∃ v, p v ∧ (↑) ⁻¹' v = u) univ ↔
    HasCountableSeparatingOn α p t 
Arguments: {α : Type u_1} {p : Set α → Prop} {t : Set α}
Goal: HasCountableSeparatingOn (↑t) (fun u => ∃ v, p v ∧ Subtype.val ⁻¹' v = u) Set.univ ↔ HasCountableSeparatingOn α p t
-- Filter.exists_subset_subsingleton_mem_of_forall_separating
theorem exists_subset_subsingleton_mem_of_forall_separating (p : Set α → Prop)
    {s : Set α} [h : HasCountableSeparatingOn α p s] (hs : s ∈ l)
    (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) : ∃ t, t ⊆ s ∧ t.Subsingleton ∧ t ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [CountableInterFilter l] (p : Set α → Prop) {s : Set α} [h : HasCountableSeparatingOn α p s] (hs : s ∈ l) (hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l)
Goal: ∃ t ⊆ s, t.Subsingleton ∧ t ∈ l
-- Filter.exists_mem_singleton_mem_of_mem_of_nonempty_of_forall_separating
theorem exists_mem_singleton_mem_of_mem_of_nonempty_of_forall_separating (p : Set α → Prop)
    {s : Set α} [HasCountableSeparatingOn α p s] (hs : s ∈ l) (hne : s.Nonempty)
    (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) : ∃ a ∈ s, {a} ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [CountableInterFilter l] (p : Set α → Prop) {s : Set α} [HasCountableSeparatingOn α p s] (hs : s ∈ l) (hne : s.Nonempty) (hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l)
Goal: ∃ a ∈ s, {a} ∈ l
-- Filter.exists_singleton_mem_of_mem_of_forall_separating
theorem exists_singleton_mem_of_mem_of_forall_separating [Nonempty α] (p : Set α → Prop)
    {s : Set α} [HasCountableSeparatingOn α p s] (hs : s ∈ l) (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) :
    ∃ a, {a} ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [CountableInterFilter l] [Nonempty α] (p : Set α → Prop) {s : Set α} [HasCountableSeparatingOn α p s] (hs : s ∈ l) (hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l)
Goal: ∃ a, {a} ∈ l
-- Filter.exists_subsingleton_mem_of_forall_separating
theorem exists_subsingleton_mem_of_forall_separating (p : Set α → Prop)
    [HasCountableSeparatingOn α p univ] (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) :
    ∃ s : Set α, s.Subsingleton ∧ s ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [CountableInterFilter l] (p : Set α → Prop) [HasCountableSeparatingOn α p Set.univ] (hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l)
Goal: ∃ s, s.Subsingleton ∧ s ∈ l
-- Filter.exists_singleton_mem_of_forall_separating
theorem exists_singleton_mem_of_forall_separating [Nonempty α] (p : Set α → Prop)
    [HasCountableSeparatingOn α p univ] (hl : ∀ U, p U → U ∈ l ∨ Uᶜ ∈ l) :
    ∃ x : α, {x} ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [CountableInterFilter l] [Nonempty α] (p : Set α → Prop) [HasCountableSeparatingOn α p Set.univ] (hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l)
Goal: ∃ x, {x} ∈ l
-- Filter.exists_mem_eventuallyEq_const_of_eventually_mem_of_forall_separating
theorem exists_mem_eventuallyEq_const_of_eventually_mem_of_forall_separating (p : Set β → Prop)
    {s : Set β} [HasCountableSeparatingOn β p s] (hs : ∀ᶠ x in l, f x ∈ s) (hne : s.Nonempty)
    (h : ∀ U, p U → (∀ᶠ x in l, f x ∈ U) ∨ (∀ᶠ x in l, f x ∉ U)) :
    ∃ a ∈ s, f =ᶠ[l] const α a 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f : α → β} (p : Set β → Prop) {s : Set β} [HasCountableSeparatingOn β p s] (hs : ∀ᶠ (x : α) in l, f x ∈ s) (hne : s.Nonempty) (h : ∀ (U : Set β), p U → (∀ᶠ (x : α) in l, f x ∈ U) ∨ ∀ᶠ (x : α) in l, f x ∉ U)
Goal: ∃ a ∈ s, f =ᶠ[l] Function.const α a
-- Filter.exists_eventuallyEq_const_of_eventually_mem_of_forall_separating
theorem exists_eventuallyEq_const_of_eventually_mem_of_forall_separating [Nonempty β]
    (p : Set β → Prop) {s : Set β} [HasCountableSeparatingOn β p s] (hs : ∀ᶠ x in l, f x ∈ s)
    (h : ∀ U, p U → (∀ᶠ x in l, f x ∈ U) ∨ (∀ᶠ x in l, f x ∉ U)) :
    ∃ a, f =ᶠ[l] const α a 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f : α → β} [Nonempty β] (p : Set β → Prop) {s : Set β} [HasCountableSeparatingOn β p s] (hs : ∀ᶠ (x : α) in l, f x ∈ s) (h : ∀ (U : Set β), p U → (∀ᶠ (x : α) in l, f x ∈ U) ∨ ∀ᶠ (x : α) in l, f x ∉ U)
Goal: ∃ a, f =ᶠ[l] Function.const α a
-- Filter.exists_eventuallyEq_const_of_forall_separating
theorem exists_eventuallyEq_const_of_forall_separating [Nonempty β] (p : Set β → Prop)
    [HasCountableSeparatingOn β p univ]
    (h : ∀ U, p U → (∀ᶠ x in l, f x ∈ U) ∨ (∀ᶠ x in l, f x ∉ U)) :
    ∃ a, f =ᶠ[l] const α a 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f : α → β} [Nonempty β] (p : Set β → Prop) [HasCountableSeparatingOn β p Set.univ] (h : ∀ (U : Set β), p U → (∀ᶠ (x : α) in l, f x ∈ U) ∨ ∀ᶠ (x : α) in l, f x ∉ U)
Goal: ∃ a, f =ᶠ[l] Function.const α a
-- Filter.EventuallyEq.of_eventually_mem_of_forall_separating_mem_iff
theorem of_eventually_mem_of_forall_separating_mem_iff (p : Set β → Prop) {s : Set β}
    [h' : HasCountableSeparatingOn β p s] (hf : ∀ᶠ x in l, f x ∈ s) (hg : ∀ᶠ x in l, g x ∈ s)
    (h : ∀ U : Set β, p U → ∀ᶠ x in l, f x ∈ U ↔ g x ∈ U) : f =ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) {s : Set β} [h' : HasCountableSeparatingOn β p s] (hf : ∀ᶠ (x : α) in l, f x ∈ s) (hg : ∀ᶠ (x : α) in l, g x ∈ s) (h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U)
Goal: f =ᶠ[l] g
-- Filter.EventuallyEq.of_forall_separating_mem_iff
theorem of_forall_separating_mem_iff (p : Set β → Prop)
    [HasCountableSeparatingOn β p univ] (h : ∀ U : Set β, p U → ∀ᶠ x in l, f x ∈ U ↔ g x ∈ U) :
    f =ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) [HasCountableSeparatingOn β p Set.univ] (h : ∀ (U : Set β), p U → ∀ᶠ (x : α) in l, f x ∈ U ↔ g x ∈ U)
Goal: f =ᶠ[l] g
-- Filter.EventuallyEq.of_eventually_mem_of_forall_separating_preimage
theorem of_eventually_mem_of_forall_separating_preimage (p : Set β → Prop) {s : Set β}
    [HasCountableSeparatingOn β p s] (hf : ∀ᶠ x in l, f x ∈ s) (hg : ∀ᶠ x in l, g x ∈ s)
    (h : ∀ U : Set β, p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) : f =ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) {s : Set β} [HasCountableSeparatingOn β p s] (hf : ∀ᶠ (x : α) in l, f x ∈ s) (hg : ∀ᶠ (x : α) in l, g x ∈ s) (h : ∀ (U : Set β), p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U)
Goal: f =ᶠ[l] g
-- Filter.EventuallyEq.of_forall_separating_preimage
theorem of_forall_separating_preimage (p : Set β → Prop) [HasCountableSeparatingOn β p univ]
    (h : ∀ U : Set β, p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) : f =ᶠ[l] g 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop) [HasCountableSeparatingOn β p Set.univ] (h : ∀ (U : Set β), p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U)
Goal: f =ᶠ[l] g
-- Filter.rmap_sets
theorem rmap_sets (r : Rel α β) (l : Filter α) : (l.rmap r).sets = r.core ⁻¹' l.sets 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l : Filter α)
Goal: (Filter.rmap r l).sets = r.core ⁻¹' l.sets
-- Filter.mem_rmap
@[simp]
theorem mem_rmap (r : Rel α β) (l : Filter α) (s : Set β) : s ∈ l.rmap r ↔ r.core s ∈ l 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l : Filter α) (s : Set β)
Goal: s ∈ Filter.rmap r l ↔ r.core s ∈ l
-- Filter.rmap_rmap
@[simp]
theorem rmap_rmap (r : Rel α β) (s : Rel β γ) (l : Filter α) :
    rmap s (rmap r l) = rmap (r.comp s) l 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ) (l : Filter α)
Goal: Filter.rmap s (Filter.rmap r l) = Filter.rmap (r.comp s) l
-- Filter.rmap_compose
@[simp]
theorem rmap_compose (r : Rel α β) (s : Rel β γ) : rmap s ∘ rmap r = rmap (r.comp s) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ)
Goal: Filter.rmap s ∘ Filter.rmap r = Filter.rmap (r.comp s)
-- Filter.rtendsto_def
theorem rtendsto_def (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β) :
    RTendsto r l₁ l₂ ↔ ∀ s ∈ l₂, r.core s ∈ l₁ 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β)
Goal: Filter.RTendsto r l₁ l₂ ↔ ∀ s ∈ l₂, r.core s ∈ l₁
-- Filter.rcomap_sets
theorem rcomap_sets (r : Rel α β) (f : Filter β) :
    (rcomap r f).sets = Rel.image (fun s t => r.core s ⊆ t) f.sets 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (f : Filter β)
Goal: (Filter.rcomap r f).sets = Rel.image (fun s t => r.core s ⊆ t) f.sets
-- Filter.rcomap_rcomap
theorem rcomap_rcomap (r : Rel α β) (s : Rel β γ) (l : Filter γ) :
    rcomap r (rcomap s l) = rcomap (r.comp s) l 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ) (l : Filter γ)
Goal: Filter.rcomap r (Filter.rcomap s l) = Filter.rcomap (r.comp s) l
-- Filter.rcomap_compose
@[simp]
theorem rcomap_compose (r : Rel α β) (s : Rel β γ) : rcomap r ∘ rcomap s = rcomap (r.comp s) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ)
Goal: Filter.rcomap r ∘ Filter.rcomap s = Filter.rcomap (r.comp s)
-- Filter.rtendsto_iff_le_rcomap
theorem rtendsto_iff_le_rcomap (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β) :
    RTendsto r l₁ l₂ ↔ l₁ ≤ l₂.rcomap r 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β)
Goal: Filter.RTendsto r l₁ l₂ ↔ l₁ ≤ Filter.rcomap r l₂
-- Filter.mem_rcomap'
@[simp]
theorem mem_rcomap' (r : Rel α β) (l : Filter β) (s : Set α) :
    s ∈ l.rcomap' r ↔ ∃ t ∈ l, r.preimage t ⊆ s 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l : Filter β) (s : Set α)
Goal: s ∈ Filter.rcomap' r l ↔ ∃ t ∈ l, r.preimage t ⊆ s
-- Filter.rcomap'_sets
theorem rcomap'_sets (r : Rel α β) (f : Filter β) :
    (rcomap' r f).sets = Rel.image (fun s t => r.preimage s ⊆ t) f.sets 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (f : Filter β)
Goal: (Filter.rcomap' r f).sets = Rel.image (fun s t => r.preimage s ⊆ t) f.sets
-- Filter.rcomap'_rcomap'
@[simp]
theorem rcomap'_rcomap' (r : Rel α β) (s : Rel β γ) (l : Filter γ) :
    rcomap' r (rcomap' s l) = rcomap' (r.comp s) l 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ) (l : Filter γ)
Goal: Filter.rcomap' r (Filter.rcomap' s l) = Filter.rcomap' (r.comp s) l
-- Filter.rcomap'_compose
@[simp]
theorem rcomap'_compose (r : Rel α β) (s : Rel β γ) : rcomap' r ∘ rcomap' s = rcomap' (r.comp s) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (r : Rel α β) (s : Rel β γ)
Goal: Filter.rcomap' r ∘ Filter.rcomap' s = Filter.rcomap' (r.comp s)
-- Filter.rtendsto'_def
theorem rtendsto'_def (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β) :
    RTendsto' r l₁ l₂ ↔ ∀ s ∈ l₂, r.preimage s ∈ l₁ 
Arguments: {α : Type u} {β : Type v} (r : Rel α β) (l₁ : Filter α) (l₂ : Filter β)
Goal: Filter.RTendsto' r l₁ l₂ ↔ ∀ s ∈ l₂, r.preimage s ∈ l₁
-- Filter.tendsto_iff_rtendsto
theorem tendsto_iff_rtendsto (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ RTendsto (Function.graph f) l₁ l₂ 
Arguments: {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (f : α → β)
Goal: Filter.Tendsto f l₁ l₂ ↔ Filter.RTendsto (Function.graph f) l₁ l₂
-- Filter.tendsto_iff_rtendsto'
theorem tendsto_iff_rtendsto' (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ RTendsto' (Function.graph f) l₁ l₂ 
Arguments: {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (f : α → β)
Goal: Filter.Tendsto f l₁ l₂ ↔ Filter.RTendsto' (Function.graph f) l₁ l₂
-- Filter.mem_pmap
@[simp]
theorem mem_pmap (f : α →. β) (l : Filter α) (s : Set β) : s ∈ l.pmap f ↔ f.core s ∈ l 
Arguments: {α : Type u} {β : Type v} (f : α →. β) (l : Filter α) (s : Set β)
Goal: s ∈ Filter.pmap f l ↔ f.core s ∈ l
-- Filter.ptendsto_def
theorem ptendsto_def (f : α →. β) (l₁ : Filter α) (l₂ : Filter β) :
    PTendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f.core s ∈ l₁ 
Arguments: {α : Type u} {β : Type v} (f : α →. β) (l₁ : Filter α) (l₂ : Filter β)
Goal: Filter.PTendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f.core s ∈ l₁
-- Filter.ptendsto_iff_rtendsto
theorem ptendsto_iff_rtendsto (l₁ : Filter α) (l₂ : Filter β) (f : α →. β) :
    PTendsto f l₁ l₂ ↔ RTendsto f.graph' l₁ l₂ 
Arguments: {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (f : α →. β)
Goal: Filter.PTendsto f l₁ l₂ ↔ Filter.RTendsto f.graph' l₁ l₂
-- Filter.pmap_res
theorem pmap_res (l : Filter α) (s : Set α) (f : α → β) :
    pmap (PFun.res f s) l = map f (l ⊓ 𝓟 s) 
Arguments: {α : Type u} {β : Type v} (l : Filter α) (s : Set α) (f : α → β)
Goal: Filter.pmap (PFun.res f s) l = Filter.map f (l ⊓ Filter.principal s)
-- Filter.tendsto_iff_ptendsto
theorem tendsto_iff_ptendsto (l₁ : Filter α) (l₂ : Filter β) (s : Set α) (f : α → β) :
    Tendsto f (l₁ ⊓ 𝓟 s) l₂ ↔ PTendsto (PFun.res f s) l₁ l₂ 
Arguments: {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (s : Set α) (f : α → β)
Goal: Filter.Tendsto f (l₁ ⊓ Filter.principal s) l₂ ↔ Filter.PTendsto (PFun.res f s) l₁ l₂
-- Filter.tendsto_iff_ptendsto_univ
theorem tendsto_iff_ptendsto_univ (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ PTendsto (PFun.res f Set.univ) l₁ l₂ 
Arguments: {α : Type u} {β : Type v} (l₁ : Filter α) (l₂ : Filter β) (f : α → β)
Goal: Filter.Tendsto f l₁ l₂ ↔ Filter.PTendsto (PFun.res f Set.univ) l₁ l₂
-- Filter.ptendsto'_def
theorem ptendsto'_def (f : α →. β) (l₁ : Filter α) (l₂ : Filter β) :
    PTendsto' f l₁ l₂ ↔ ∀ s ∈ l₂, f.preimage s ∈ l₁ 
Arguments: {α : Type u} {β : Type v} (f : α →. β) (l₁ : Filter α) (l₂ : Filter β)
Goal: Filter.PTendsto' f l₁ l₂ ↔ ∀ s ∈ l₂, f.preimage s ∈ l₁
-- Filter.ptendsto_of_ptendsto'
theorem ptendsto_of_ptendsto' {f : α →. β} {l₁ : Filter α} {l₂ : Filter β} :
    PTendsto' f l₁ l₂ → PTendsto f l₁ l₂ 
Arguments: {α : Type u} {β : Type v} {f : α →. β} {l₁ : Filter α} {l₂ : Filter β}
Goal: Filter.PTendsto' f l₁ l₂ → Filter.PTendsto f l₁ l₂
-- Filter.ptendsto'_of_ptendsto
theorem ptendsto'_of_ptendsto {f : α →. β} {l₁ : Filter α} {l₂ : Filter β} (h : f.Dom ∈ l₁) :
    PTendsto f l₁ l₂ → PTendsto' f l₁ l₂ 
Arguments: {α : Type u} {β : Type v} {f : α →. β} {l₁ : Filter α} {l₂ : Filter β} (h : f.Dom ∈ l₁)
Goal: Filter.PTendsto f l₁ l₂ → Filter.PTendsto' f l₁ l₂
-- Filter.HasBasis.subsingleton_iff
theorem HasBasis.subsingleton_iff {ι : Sort*} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s) :
    l.Subsingleton ↔ ∃ i, p i ∧ (s i).Subsingleton 
Arguments: {α : Type u_1} {l : Filter α} {ι : Sort u_3} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p s)
Goal: l.Subsingleton ↔ ∃ i, p i ∧ (s i).Subsingleton
-- Filter.Subsingleton.anti
theorem Subsingleton.anti {l'} (hl : l.Subsingleton) (hl' : l' ≤ l) : l'.Subsingleton 
Arguments: {α : Type u_1} {l l' : Filter α} (hl : l.Subsingleton) (hl' : l' ≤ l)
Goal: l'.Subsingleton
-- Filter.Subsingleton.of_subsingleton
@[nontriviality]
theorem Subsingleton.of_subsingleton [Subsingleton α] : l.Subsingleton 
Arguments: {α : Type u_1} {l : Filter α} [Subsingleton α]
Goal: l.Subsingleton
-- Filter.Subsingleton.map
theorem Subsingleton.map (hl : l.Subsingleton) (f : α → β) : (map f l).Subsingleton 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} (hl : l.Subsingleton) (f : α → β)
Goal: (Filter.map f l).Subsingleton
-- Filter.Subsingleton.prod
theorem Subsingleton.prod (hl : l.Subsingleton) {l' : Filter β} (hl' : l'.Subsingleton) :
    (l ×ˢ l').Subsingleton 
Arguments: {α : Type u_1} {β : Type u_2} {l : Filter α} (hl : l.Subsingleton) {l' : Filter β} (hl' : l'.Subsingleton)
Goal: (l ×ˢ l').Subsingleton
-- Filter.subsingleton_pure
@[simp]
theorem subsingleton_pure {a : α} : Filter.Subsingleton (pure a) 
Arguments: {α : Type u_1} {a : α}
Goal: (pure a).Subsingleton
-- Filter.subsingleton_bot
@[simp]
theorem subsingleton_bot : Filter.Subsingleton (⊥ : Filter α) 
Arguments: {α : Type u_1}
Goal: ⊥.Subsingleton
-- Filter.Subsingleton.exists_eq_pure
theorem Subsingleton.exists_eq_pure [l.NeBot] (hl : l.Subsingleton) : ∃ a, l = pure a 
Arguments: {α : Type u_1} {l : Filter α} [l.NeBot] (hl : l.Subsingleton)
Goal: ∃ a, l = pure a
-- Filter.subsingleton_iff_bot_or_pure
theorem subsingleton_iff_bot_or_pure : l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a 
Arguments: {α : Type u_1} {l : Filter α}
Goal: l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a
-- Filter.subsingleton_iff_exists_le_pure
theorem subsingleton_iff_exists_le_pure [Nonempty α] : l.Subsingleton ↔ ∃ a, l ≤ pure a 
Arguments: {α : Type u_1} {l : Filter α} [Nonempty α]
Goal: l.Subsingleton ↔ ∃ a, l ≤ pure a
-- Filter.subsingleton_iff_exists_singleton_mem
theorem subsingleton_iff_exists_singleton_mem [Nonempty α] : l.Subsingleton ↔ ∃ a, {a} ∈ l 
Arguments: {α : Type u_1} {l : Filter α} [Nonempty α]
Goal: l.Subsingleton ↔ ∃ a, {a} ∈ l
-- Filter.Subsingleton.isCountablyGenerated
lemma Subsingleton.isCountablyGenerated (hl : l.Subsingleton) : IsCountablyGenerated l 
Arguments: {α : Type u_1} {l : Filter α} (hl : l.Subsingleton)
Goal: l.IsCountablyGenerated