ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.Eventually.intCast_atTop
theorem Filter.Eventually.intCast_atTop [StrictOrderedRing R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℤ) in atTop, p n 
Arguments: {R : Type u_2} [StrictOrderedRing R] [Archimedean R] {p : R → Prop} (h : ∀ᶠ (x : R) in Filter.atTop, p x)
Goal: ∀ᶠ (n : ℤ) in Filter.atTop, p ↑n
-- Filter.Eventually.intCast_atBot
theorem Filter.Eventually.intCast_atBot [StrictOrderedRing R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atBot, p x) : ∀ᶠ (n : ℤ) in atBot, p n 
Arguments: {R : Type u_2} [StrictOrderedRing R] [Archimedean R] {p : R → Prop} (h : ∀ᶠ (x : R) in Filter.atBot, p x)
Goal: ∀ᶠ (n : ℤ) in Filter.atBot, p ↑n
-- Rat.comap_cast_atTop
@[simp]
theorem Rat.comap_cast_atTop [LinearOrderedField R] [Archimedean R] :
    comap ((↑) : ℚ → R) atTop = atTop 
Arguments: {R : Type u_2} [LinearOrderedField R] [Archimedean R]
Goal: Filter.comap Rat.cast Filter.atTop = Filter.atTop
-- Rat.comap_cast_atBot
@[simp] theorem Rat.comap_cast_atBot [LinearOrderedField R] [Archimedean R] :
    comap ((↑) : ℚ → R) atBot = atBot 
Arguments: {R : Type u_2} [LinearOrderedField R] [Archimedean R]
Goal: Filter.comap Rat.cast Filter.atBot = Filter.atBot
-- tendsto_ratCast_atTop_iff
theorem tendsto_ratCast_atTop_iff [LinearOrderedField R] [Archimedean R] {f : α → ℚ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop 
Arguments: {α : Type u_1} {R : Type u_2} [LinearOrderedField R] [Archimedean R] {f : α → ℚ} {l : Filter α}
Goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop
-- tendsto_ratCast_atBot_iff
theorem tendsto_ratCast_atBot_iff [LinearOrderedField R] [Archimedean R] {f : α → ℚ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atBot ↔ Tendsto f l atBot 
Arguments: {α : Type u_1} {R : Type u_2} [LinearOrderedField R] [Archimedean R] {f : α → ℚ} {l : Filter α}
Goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot
-- Filter.Eventually.ratCast_atTop
theorem Filter.Eventually.ratCast_atTop [LinearOrderedField R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℚ) in atTop, p n 
Arguments: {R : Type u_2} [LinearOrderedField R] [Archimedean R] {p : R → Prop} (h : ∀ᶠ (x : R) in Filter.atTop, p x)
Goal: ∀ᶠ (n : ℚ) in Filter.atTop, p ↑n
-- Filter.Eventually.ratCast_atBot
theorem Filter.Eventually.ratCast_atBot [LinearOrderedField R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atBot, p x) : ∀ᶠ (n : ℚ) in atBot, p n 
Arguments: {R : Type u_2} [LinearOrderedField R] [Archimedean R] {p : R → Prop} (h : ∀ᶠ (x : R) in Filter.atBot, p x)
Goal: ∀ᶠ (n : ℚ) in Filter.atBot, p ↑n
-- atTop_hasAntitoneBasis_of_archimedean
theorem atTop_hasAntitoneBasis_of_archimedean [OrderedSemiring R] [Archimedean R] :
    (atTop : Filter R).HasAntitoneBasis fun n : ℕ => Ici n 
Arguments: {R : Type u_2} [OrderedSemiring R] [Archimedean R]
Goal: Filter.atTop.HasAntitoneBasis fun n => Set.Ici ↑n
-- atTop_hasCountableBasis_of_archimedean
theorem atTop_hasCountableBasis_of_archimedean [StrictOrderedSemiring R] [Archimedean R] :
    (atTop : Filter R).HasCountableBasis (fun _ : ℕ => True) fun n => Ici n 
Arguments: {R : Type u_2} [StrictOrderedSemiring R] [Archimedean R]
Goal: Filter.atTop.HasCountableBasis (fun x => True) fun n => Set.Ici ↑n
-- atBot_hasCountableBasis_of_archimedean
theorem atBot_hasCountableBasis_of_archimedean [LinearOrderedRing R] [Archimedean R] :
    (atBot : Filter R).HasCountableBasis (fun _ : ℤ => True) fun m => Iic m 
Arguments: {R : Type u_2} [LinearOrderedRing R] [Archimedean R]
Goal: Filter.atBot.HasCountableBasis (fun x => True) fun m => Set.Iic ↑m
-- Filter.Tendsto.const_mul_atTop'
theorem Tendsto.const_mul_atTop' (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {f : α → R} {r : R} [LinearOrderedSemiring R] [Archimedean R] (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop
-- Filter.Tendsto.atTop_mul_const'
theorem Tendsto.atTop_mul_const' (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {f : α → R} {r : R} [LinearOrderedSemiring R] [Archimedean R] (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop
-- Filter.Tendsto.atTop_mul_const_of_neg'
theorem Tendsto.atTop_mul_const_of_neg' (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atBot 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {f : α → R} {r : R} [LinearOrderedRing R] [Archimedean R] (hr : r < 0) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot
-- Filter.Tendsto.atBot_mul_const'
theorem Tendsto.atBot_mul_const' (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atBot 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {f : α → R} {r : R} [LinearOrderedRing R] [Archimedean R] (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot
-- Filter.Tendsto.atBot_mul_const_of_neg'
theorem Tendsto.atBot_mul_const_of_neg' (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {f : α → R} {r : R} [LinearOrderedRing R] [Archimedean R] (hr : r < 0) (hf : Filter.Tendsto f l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop
-- Filter.Tendsto.atTop_nsmul_const
theorem Tendsto.atTop_nsmul_const {f : α → ℕ} (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedCancelAddCommMonoid R] [Archimedean R] {f : α → ℕ} (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atTop
-- Filter.Tendsto.atTop_nsmul_neg_const
theorem Tendsto.atTop_nsmul_neg_const {f : α → ℕ} (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atBot 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedAddCommGroup R] [Archimedean R] {f : α → ℕ} (hr : r < 0) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atBot
-- Filter.Tendsto.atTop_zsmul_const
theorem Tendsto.atTop_zsmul_const {f : α → ℤ} (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedAddCommGroup R] [Archimedean R] {f : α → ℤ} (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atTop
-- Filter.Tendsto.atTop_zsmul_neg_const
theorem Tendsto.atTop_zsmul_neg_const {f : α → ℤ} (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x • r) l atBot 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedAddCommGroup R] [Archimedean R] {f : α → ℤ} (hr : r < 0) (hf : Filter.Tendsto f l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atBot
-- Filter.Tendsto.atBot_zsmul_const
theorem Tendsto.atBot_zsmul_const {f : α → ℤ} (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x • r) l atBot 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedAddCommGroup R] [Archimedean R] {f : α → ℤ} (hr : 0 < r) (hf : Filter.Tendsto f l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atBot
-- Filter.Tendsto.atBot_zsmul_neg_const
theorem Tendsto.atBot_zsmul_neg_const {f : α → ℤ} (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x • r) l atTop 
Arguments: {α : Type u_1} {R : Type u_2} {l : Filter α} {r : R} [LinearOrderedAddCommGroup R] [Archimedean R] {f : α → ℤ} (hr : r < 0) (hf : Filter.Tendsto f l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x • r) l Filter.atTop
-- Set.wellFoundedOn_empty
@[simp]
theorem wellFoundedOn_empty (r : α → α → Prop) : WellFoundedOn ∅ r 
Arguments: {α : Type u_2} (r : α → α → Prop)
Goal: ∅.WellFoundedOn r
-- Set.wellFoundedOn_iff
theorem wellFoundedOn_iff :
    s.WellFoundedOn r ↔ WellFounded fun a b : α => r a b ∧ a ∈ s ∧ b ∈ s 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α}
Goal: s.WellFoundedOn r ↔ WellFounded fun a b => r a b ∧ a ∈ s ∧ b ∈ s
-- Set.wellFoundedOn_univ
@[simp]
theorem wellFoundedOn_univ : (univ : Set α).WellFoundedOn r ↔ WellFounded r 
Arguments: {α : Type u_2} {r : α → α → Prop}
Goal: Set.univ.WellFoundedOn r ↔ WellFounded r
-- WellFounded.wellFoundedOn
theorem _root_.WellFounded.wellFoundedOn : WellFounded r → s.WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α}
Goal: WellFounded r → s.WellFoundedOn r
-- Set.wellFoundedOn_range
@[simp]
theorem wellFoundedOn_range : (range f).WellFoundedOn r ↔ WellFounded (r on f) 
Arguments: {α : Type u_2} {β : Type u_3} {r : α → α → Prop} {f : β → α}
Goal: (Set.range f).WellFoundedOn r ↔ WellFounded (r on f)
-- Set.wellFoundedOn_image
@[simp]
theorem wellFoundedOn_image {s : Set β} : (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f) 
Arguments: {α : Type u_2} {β : Type u_3} {r : α → α → Prop} {f : β → α} {s : Set β}
Goal: (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
-- Set.WellFoundedOn.induction
protected theorem induction (hs : s.WellFoundedOn r) (hx : x ∈ s) {P : α → Prop}
    (hP : ∀ y ∈ s, (∀ z ∈ s, r z y → P z) → P y) : P x 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} {x : α} (hs : s.WellFoundedOn r) (hx : x ∈ s) {P : α → Prop} (hP : ∀ y ∈ s, (∀ z ∈ s, r z y → P z) → P y)
Goal: P x
-- Set.WellFoundedOn.mono
protected theorem mono (h : t.WellFoundedOn r') (hle : r ≤ r') (hst : s ⊆ t) :
    s.WellFoundedOn r 
Arguments: {α : Type u_2} {r r' : α → α → Prop} {s t : Set α} (h : t.WellFoundedOn r') (hle : r ≤ r') (hst : s ⊆ t)
Goal: s.WellFoundedOn r
-- Set.WellFoundedOn.mono'
theorem mono' (h : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), r' a b → r a b) :
    s.WellFoundedOn r → s.WellFoundedOn r' 
Arguments: {α : Type u_2} {r r' : α → α → Prop} {s : Set α} (h : ∀ a ∈ s, ∀ b ∈ s, r' a b → r a b)
Goal: s.WellFoundedOn r → s.WellFoundedOn r'
-- Set.WellFoundedOn.subset
theorem subset (h : t.WellFoundedOn r) (hst : s ⊆ t) : s.WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s t : Set α} (h : t.WellFoundedOn r) (hst : s ⊆ t)
Goal: s.WellFoundedOn r
-- Set.WellFoundedOn.acc_iff_wellFoundedOn
theorem acc_iff_wellFoundedOn {α} {r : α → α → Prop} {a : α} :
    TFAE [Acc r a,
      WellFoundedOn { b | ReflTransGen r b a } r,
      WellFoundedOn { b | TransGen r b a } r] 
Arguments: {α : Type u_6} {r : α → α → Prop} {a : α}
Goal: [Acc r a, {b | Relation.ReflTransGen r b a}.WellFoundedOn r, {b | Relation.TransGen r b a}.WellFoundedOn r].TFAE
-- Set.wellFoundedOn_iff_no_descending_seq
theorem wellFoundedOn_iff_no_descending_seq :
    s.WellFoundedOn r ↔ ∀ f : ((· > ·) : ℕ → ℕ → Prop) ↪r r, ¬∀ n, f n ∈ s 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α}
Goal: s.WellFoundedOn r ↔ ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), f n ∈ s
-- Set.WellFoundedOn.union
theorem WellFoundedOn.union (hs : s.WellFoundedOn r) (ht : t.WellFoundedOn r) :
    (s ∪ t).WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s t : Set α} (hs : s.WellFoundedOn r) (ht : t.WellFoundedOn r)
Goal: (s ∪ t).WellFoundedOn r
-- Set.wellFoundedOn_union
@[simp]
theorem wellFoundedOn_union : (s ∪ t).WellFoundedOn r ↔ s.WellFoundedOn r ∧ t.WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s t : Set α}
Goal: (s ∪ t).WellFoundedOn r ↔ s.WellFoundedOn r ∧ t.WellFoundedOn r
-- Set.isWF_empty
@[simp]
theorem isWF_empty : IsWF (∅ : Set α) 
Arguments: {α : Type u_2} [LT α]
Goal: ∅.IsWF
-- Set.isWF_univ_iff
theorem isWF_univ_iff : IsWF (univ : Set α) ↔ WellFounded ((· < ·) : α → α → Prop) 
Arguments: {α : Type u_2} [LT α]
Goal: Set.univ.IsWF ↔ WellFounded fun x x_1 => x < x_1
-- Set.IsWF.mono
theorem IsWF.mono (h : IsWF t) (st : s ⊆ t) : IsWF s 
Arguments: {α : Type u_2} [LT α] {s t : Set α} (h : t.IsWF) (st : s ⊆ t)
Goal: s.IsWF
-- Set.IsWF.union
protected nonrec theorem IsWF.union (hs : IsWF s) (ht : IsWF t) : IsWF (s ∪ t) 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α} (hs : s.IsWF) (ht : t.IsWF)
Goal: (s ∪ t).IsWF
-- Set.isWF_union
@[simp] theorem isWF_union : IsWF (s ∪ t) ↔ IsWF s ∧ IsWF t 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α}
Goal: (s ∪ t).IsWF ↔ s.IsWF ∧ t.IsWF
-- Set.isWF_iff_no_descending_seq
theorem isWF_iff_no_descending_seq :
    IsWF s ↔ ∀ f : ℕ → α, StrictAnti f → ¬∀ n, f (OrderDual.toDual n) ∈ s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α}
Goal: s.IsWF ↔ ∀ (f : ℕ → α), StrictAnti f → ¬∀ (n : ℕ), f (OrderDual.toDual n) ∈ s
-- Set.PartiallyWellOrderedOn.mono
theorem PartiallyWellOrderedOn.mono (ht : t.PartiallyWellOrderedOn r) (h : s ⊆ t) :
    s.PartiallyWellOrderedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s t : Set α} (ht : t.PartiallyWellOrderedOn r) (h : s ⊆ t)
Goal: s.PartiallyWellOrderedOn r
-- Set.partiallyWellOrderedOn_empty
@[simp]
theorem partiallyWellOrderedOn_empty (r : α → α → Prop) : PartiallyWellOrderedOn ∅ r 
Arguments: {α : Type u_2} (r : α → α → Prop)
Goal: ∅.PartiallyWellOrderedOn r
-- Set.PartiallyWellOrderedOn.union
theorem PartiallyWellOrderedOn.union (hs : s.PartiallyWellOrderedOn r)
    (ht : t.PartiallyWellOrderedOn r) : (s ∪ t).PartiallyWellOrderedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s t : Set α} (hs : s.PartiallyWellOrderedOn r) (ht : t.PartiallyWellOrderedOn r)
Goal: (s ∪ t).PartiallyWellOrderedOn r
-- Set.partiallyWellOrderedOn_union
@[simp]
theorem partiallyWellOrderedOn_union :
    (s ∪ t).PartiallyWellOrderedOn r ↔ s.PartiallyWellOrderedOn r ∧ t.PartiallyWellOrderedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s t : Set α}
Goal: (s ∪ t).PartiallyWellOrderedOn r ↔ s.PartiallyWellOrderedOn r ∧ t.PartiallyWellOrderedOn r
-- Set.PartiallyWellOrderedOn.image_of_monotone_on
theorem PartiallyWellOrderedOn.image_of_monotone_on (hs : s.PartiallyWellOrderedOn r)
    (hf : ∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂)) : (f '' s).PartiallyWellOrderedOn r' 
Arguments: {α : Type u_2} {β : Type u_3} {r : α → α → Prop} {r' : β → β → Prop} {f : α → β} {s : Set α} (hs : s.PartiallyWellOrderedOn r) (hf : ∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂))
Goal: (f '' s).PartiallyWellOrderedOn r'
-- IsAntichain.finite_of_partiallyWellOrderedOn
theorem _root_.IsAntichain.finite_of_partiallyWellOrderedOn (ha : IsAntichain r s)
    (hp : s.PartiallyWellOrderedOn r) : s.Finite 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} (ha : IsAntichain r s) (hp : s.PartiallyWellOrderedOn r)
Goal: s.Finite
-- Set.Finite.partiallyWellOrderedOn
protected theorem Finite.partiallyWellOrderedOn (hs : s.Finite) : s.PartiallyWellOrderedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] (hs : s.Finite)
Goal: s.PartiallyWellOrderedOn r
-- IsAntichain.partiallyWellOrderedOn_iff
theorem _root_.IsAntichain.partiallyWellOrderedOn_iff (hs : IsAntichain r s) :
    s.PartiallyWellOrderedOn r ↔ s.Finite 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] (hs : IsAntichain r s)
Goal: s.PartiallyWellOrderedOn r ↔ s.Finite
-- Set.partiallyWellOrderedOn_singleton
@[simp]
theorem partiallyWellOrderedOn_singleton (a : α) : PartiallyWellOrderedOn {a} r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsRefl α r] (a : α)
Goal: {a}.PartiallyWellOrderedOn r
-- Set.Subsingleton.partiallyWellOrderedOn
@[nontriviality]
theorem Subsingleton.partiallyWellOrderedOn (hs : s.Subsingleton) : PartiallyWellOrderedOn s r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] (hs : s.Subsingleton)
Goal: s.PartiallyWellOrderedOn r
-- Set.partiallyWellOrderedOn_insert
@[simp]
theorem partiallyWellOrderedOn_insert :
    PartiallyWellOrderedOn (insert a s) r ↔ PartiallyWellOrderedOn s r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} {a : α} [IsRefl α r]
Goal: (insert a s).PartiallyWellOrderedOn r ↔ s.PartiallyWellOrderedOn r
-- Set.PartiallyWellOrderedOn.insert
protected theorem PartiallyWellOrderedOn.insert (h : PartiallyWellOrderedOn s r) (a : α) :
    PartiallyWellOrderedOn (insert a s) r 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] (h : s.PartiallyWellOrderedOn r) (a : α)
Goal: (insert a s).PartiallyWellOrderedOn r
-- Set.partiallyWellOrderedOn_iff_finite_antichains
theorem partiallyWellOrderedOn_iff_finite_antichains [IsSymm α r] :
    s.PartiallyWellOrderedOn r ↔ ∀ t, t ⊆ s → IsAntichain r t → t.Finite 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] [IsSymm α r]
Goal: s.PartiallyWellOrderedOn r ↔ ∀ t ⊆ s, IsAntichain r t → t.Finite
-- Set.PartiallyWellOrderedOn.exists_monotone_subseq
theorem PartiallyWellOrderedOn.exists_monotone_subseq (h : s.PartiallyWellOrderedOn r) (f : ℕ → α)
    (hf : ∀ n, f n ∈ s) : ∃ g : ℕ ↪o ℕ, ∀ m n : ℕ, m ≤ n → r (f (g m)) (f (g n)) 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] [IsTrans α r] (h : s.PartiallyWellOrderedOn r) (f : ℕ → α) (hf : ∀ (n : ℕ), f n ∈ s)
Goal: ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n))
-- Set.partiallyWellOrderedOn_iff_exists_monotone_subseq
theorem partiallyWellOrderedOn_iff_exists_monotone_subseq :
    s.PartiallyWellOrderedOn r ↔
      ∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ g : ℕ ↪o ℕ, ∀ m n : ℕ, m ≤ n → r (f (g m)) (f (g n)) 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsRefl α r] [IsTrans α r]
Goal: s.PartiallyWellOrderedOn r ↔ ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (g m)) (f (g n))
-- Set.PartiallyWellOrderedOn.prod
protected theorem PartiallyWellOrderedOn.prod {t : Set β} (hs : PartiallyWellOrderedOn s r)
    (ht : PartiallyWellOrderedOn t r') :
    PartiallyWellOrderedOn (s ×ˢ t) fun x y : α × β => r x.1 y.1 ∧ r' x.2 y.2 
Arguments: {α : Type u_2} {β : Type u_3} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} [IsRefl α r] [IsTrans α r] {t : Set β} (hs : s.PartiallyWellOrderedOn r) (ht : t.PartiallyWellOrderedOn r')
Goal: (s ×ˢ t).PartiallyWellOrderedOn fun x y => r x.1 y.1 ∧ r' x.2 y.2
-- Set.PartiallyWellOrderedOn.wellFoundedOn
theorem PartiallyWellOrderedOn.wellFoundedOn [IsPreorder α r] (h : s.PartiallyWellOrderedOn r) :
    s.WellFoundedOn fun a b => r a b ∧ ¬r b a 
Arguments: {α : Type u_2} {r : α → α → Prop} {s : Set α} [IsPreorder α r] (h : s.PartiallyWellOrderedOn r)
Goal: s.WellFoundedOn fun a b => r a b ∧ ¬r b a
-- Set.IsPWO.mono
nonrec theorem IsPWO.mono (ht : t.IsPWO) : s ⊆ t → s.IsPWO 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α} (ht : t.IsPWO)
Goal: s ⊆ t → s.IsPWO
-- Set.IsPWO.exists_monotone_subseq
nonrec theorem IsPWO.exists_monotone_subseq (h : s.IsPWO) (f : ℕ → α) (hf : ∀ n, f n ∈ s) :
    ∃ g : ℕ ↪o ℕ, Monotone (f ∘ g) 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (h : s.IsPWO) (f : ℕ → α) (hf : ∀ (n : ℕ), f n ∈ s)
Goal: ∃ g, Monotone (f ∘ ⇑g)
-- Set.isPWO_iff_exists_monotone_subseq
theorem isPWO_iff_exists_monotone_subseq :
    s.IsPWO ↔ ∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ g : ℕ ↪o ℕ, Monotone (f ∘ g) 
Arguments: {α : Type u_2} [Preorder α] {s : Set α}
Goal: s.IsPWO ↔ ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, Monotone (f ∘ ⇑g)
-- Set.IsPWO.isWF
protected theorem IsPWO.isWF (h : s.IsPWO) : s.IsWF 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (h : s.IsPWO)
Goal: s.IsWF
-- Set.IsPWO.prod
nonrec theorem IsPWO.prod {t : Set β} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s ×ˢ t) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {s : Set α} {t : Set β} (hs : s.IsPWO) (ht : t.IsPWO)
Goal: (s ×ˢ t).IsPWO
-- Set.IsPWO.image_of_monotoneOn
theorem IsPWO.image_of_monotoneOn (hs : s.IsPWO) {f : α → β} (hf : MonotoneOn f s) :
    IsPWO (f '' s) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {s : Set α} (hs : s.IsPWO) {f : α → β} (hf : MonotoneOn f s)
Goal: (f '' s).IsPWO
-- Set.IsPWO.image_of_monotone
theorem IsPWO.image_of_monotone (hs : s.IsPWO) {f : α → β} (hf : Monotone f) : IsPWO (f '' s) 
Arguments: {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] {s : Set α} (hs : s.IsPWO) {f : α → β} (hf : Monotone f)
Goal: (f '' s).IsPWO
-- Set.IsPWO.union
protected nonrec theorem IsPWO.union (hs : IsPWO s) (ht : IsPWO t) : IsPWO (s ∪ t) 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α} (hs : s.IsPWO) (ht : t.IsPWO)
Goal: (s ∪ t).IsPWO
-- Set.isPWO_union
@[simp]
theorem isPWO_union : IsPWO (s ∪ t) ↔ IsPWO s ∧ IsPWO t 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α}
Goal: (s ∪ t).IsPWO ↔ s.IsPWO ∧ t.IsPWO
-- Set.Finite.isPWO
protected theorem Finite.isPWO (hs : s.Finite) : IsPWO s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (hs : s.Finite)
Goal: s.IsPWO
-- Set.isPWO_of_finite
@[simp] theorem isPWO_of_finite [Finite α] : s.IsPWO 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} [Finite α]
Goal: s.IsPWO
-- Set.isPWO_singleton
@[simp] theorem isPWO_singleton (a : α) : IsPWO ({a} : Set α) 
Arguments: {α : Type u_2} [Preorder α] (a : α)
Goal: {a}.IsPWO
-- Set.isPWO_empty
@[simp] theorem isPWO_empty : IsPWO (∅ : Set α) 
Arguments: {α : Type u_2} [Preorder α]
Goal: ∅.IsPWO
-- Set.Subsingleton.isPWO
protected theorem Subsingleton.isPWO (hs : s.Subsingleton) : IsPWO s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (hs : s.Subsingleton)
Goal: s.IsPWO
-- Set.isPWO_insert
@[simp]
theorem isPWO_insert {a} : IsPWO (insert a s) ↔ IsPWO s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} {a : α}
Goal: (insert a s).IsPWO ↔ s.IsPWO
-- Set.IsPWO.insert
protected theorem IsPWO.insert (h : IsPWO s) (a : α) : IsPWO (insert a s) 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (h : s.IsPWO) (a : α)
Goal: (insert a s).IsPWO
-- Set.Finite.isWF
protected theorem Finite.isWF (hs : s.Finite) : IsWF s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (hs : s.Finite)
Goal: s.IsWF
-- Set.isWF_singleton
@[simp] theorem isWF_singleton {a : α} : IsWF ({a} : Set α) 
Arguments: {α : Type u_2} [Preorder α] {a : α}
Goal: {a}.IsWF
-- Set.Subsingleton.isWF
protected theorem Subsingleton.isWF (hs : s.Subsingleton) : IsWF s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (hs : s.Subsingleton)
Goal: s.IsWF
-- Set.isWF_insert
@[simp]
theorem isWF_insert {a} : IsWF (insert a s) ↔ IsWF s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} {a : α}
Goal: (insert a s).IsWF ↔ s.IsWF
-- Set.IsWF.insert
protected theorem IsWF.insert (h : IsWF s) (a : α) : IsWF (insert a s) 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (h : s.IsWF) (a : α)
Goal: (insert a s).IsWF
-- Set.Finite.wellFoundedOn
protected theorem Finite.wellFoundedOn (hs : s.Finite) : s.WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α} (hs : s.Finite)
Goal: s.WellFoundedOn r
-- Set.wellFoundedOn_singleton
@[simp]
theorem wellFoundedOn_singleton : WellFoundedOn ({a} : Set α) r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {a : α}
Goal: {a}.WellFoundedOn r
-- Set.Subsingleton.wellFoundedOn
protected theorem Subsingleton.wellFoundedOn (hs : s.Subsingleton) : s.WellFoundedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α} (hs : s.Subsingleton)
Goal: s.WellFoundedOn r
-- Set.wellFoundedOn_insert
@[simp]
theorem wellFoundedOn_insert : WellFoundedOn (insert a s) r ↔ WellFoundedOn s r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α} {a : α}
Goal: (insert a s).WellFoundedOn r ↔ s.WellFoundedOn r
-- Set.WellFoundedOn.insert
protected theorem WellFoundedOn.insert (h : WellFoundedOn s r) (a : α) :
    WellFoundedOn (insert a s) r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α} (h : s.WellFoundedOn r) (a : α)
Goal: (insert a s).WellFoundedOn r
-- Set.IsWF.isPWO
protected theorem IsWF.isPWO (hs : s.IsWF) : s.IsPWO 
Arguments: {α : Type u_2} [LinearOrder α] {s : Set α} (hs : s.IsWF)
Goal: s.IsPWO
-- Set.isWF_iff_isPWO
theorem isWF_iff_isPWO : s.IsWF ↔ s.IsPWO 
Arguments: {α : Type u_2} [LinearOrder α] {s : Set α}
Goal: s.IsWF ↔ s.IsPWO
-- Finset.partiallyWellOrderedOn
@[simp]
protected theorem partiallyWellOrderedOn [IsRefl α r] (s : Finset α) :
    (s : Set α).PartiallyWellOrderedOn r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsRefl α r] (s : Finset α)
Goal: (↑s).PartiallyWellOrderedOn r