ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.isPWO
@[simp]
protected theorem isPWO [Preorder α] (s : Finset α) : Set.IsPWO (↑s : Set α) 
Arguments: {α : Type u_2} [Preorder α] (s : Finset α)
Goal: (↑s).IsPWO
-- Finset.isWF
@[simp]
protected theorem isWF [Preorder α] (s : Finset α) : Set.IsWF (↑s : Set α) 
Arguments: {α : Type u_2} [Preorder α] (s : Finset α)
Goal: (↑s).IsWF
-- Finset.wellFoundedOn
@[simp]
protected theorem wellFoundedOn [IsStrictOrder α r] (s : Finset α) :
    Set.WellFoundedOn (↑s : Set α) r 
Arguments: {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] (s : Finset α)
Goal: (↑s).WellFoundedOn r
-- Finset.wellFoundedOn_sup
theorem wellFoundedOn_sup [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α} :
    (s.sup f).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r 
Arguments: {ι : Type u_1} {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α}
Goal: (s.sup f).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r
-- Finset.partiallyWellOrderedOn_sup
theorem partiallyWellOrderedOn_sup (s : Finset ι) {f : ι → Set α} :
    (s.sup f).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r 
Arguments: {ι : Type u_1} {α : Type u_2} {r : α → α → Prop} (s : Finset ι) {f : ι → Set α}
Goal: (s.sup f).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r
-- Finset.isWF_sup
theorem isWF_sup [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (s.sup f).IsWF ↔ ∀ i ∈ s, (f i).IsWF 
Arguments: {ι : Type u_1} {α : Type u_2} [Preorder α] (s : Finset ι) {f : ι → Set α}
Goal: (s.sup f).IsWF ↔ ∀ i ∈ s, (f i).IsWF
-- Finset.isPWO_sup
theorem isPWO_sup [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO 
Arguments: {ι : Type u_1} {α : Type u_2} [Preorder α] (s : Finset ι) {f : ι → Set α}
Goal: (s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO
-- Finset.wellFoundedOn_bUnion
@[simp]
theorem wellFoundedOn_bUnion [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r 
Arguments: {ι : Type u_1} {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α}
Goal: (⋃ i ∈ s, f i).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r
-- Finset.partiallyWellOrderedOn_bUnion
@[simp]
theorem partiallyWellOrderedOn_bUnion (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r 
Arguments: {ι : Type u_1} {α : Type u_2} {r : α → α → Prop} (s : Finset ι) {f : ι → Set α}
Goal: (⋃ i ∈ s, f i).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r
-- Finset.isWF_bUnion
@[simp]
theorem isWF_bUnion [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).IsWF ↔ ∀ i ∈ s, (f i).IsWF 
Arguments: {ι : Type u_1} {α : Type u_2} [Preorder α] (s : Finset ι) {f : ι → Set α}
Goal: (⋃ i ∈ s, f i).IsWF ↔ ∀ i ∈ s, (f i).IsWF
-- Finset.isPWO_bUnion
@[simp]
theorem isPWO_bUnion [Preorder α] (s : Finset ι) {f : ι → Set α} :
    (⋃ i ∈ s, f i).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO 
Arguments: {ι : Type u_1} {α : Type u_2} [Preorder α] (s : Finset ι) {f : ι → Set α}
Goal: (⋃ i ∈ s, f i).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO
-- Set.IsWF.min_mem
theorem IsWF.min_mem (hs : IsWF s) (hn : s.Nonempty) : hs.min hn ∈ s 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} (hs : s.IsWF) (hn : s.Nonempty)
Goal: hs.min hn ∈ s
-- Set.IsWF.not_lt_min
nonrec theorem IsWF.not_lt_min (hs : IsWF s) (hn : s.Nonempty) (ha : a ∈ s) : ¬a < hs.min hn 
Arguments: {α : Type u_2} [Preorder α] {s : Set α} {a : α} (hs : s.IsWF) (hn : s.Nonempty) (ha : a ∈ s)
Goal: ¬a < hs.min hn
-- Set.IsWF.min_of_subset_not_lt_min
theorem IsWF.min_of_subset_not_lt_min {hs : s.IsWF} {hsn : s.Nonempty} {ht : t.IsWF}
    {htn : t.Nonempty} (hst : s ⊆ t) : ¬hs.min hsn < ht.min htn 
Arguments: {α : Type u_2} [Preorder α] {s t : Set α} {hs : s.IsWF} {hsn : s.Nonempty} {ht : t.IsWF} {htn : t.Nonempty} (hst : s ⊆ t)
Goal: ¬hs.min hsn < ht.min htn
-- Set.isWF_min_singleton
@[simp]
theorem isWF_min_singleton (a) {hs : IsWF ({a} : Set α)} {hn : ({a} : Set α).Nonempty} :
    hs.min hn = a 
Arguments: {α : Type u_2} [Preorder α] (a : α) {hs : {a}.IsWF} {hn : {a}.Nonempty}
Goal: hs.min hn = a
-- Set.IsWF.min_le
theorem IsWF.min_le (hs : s.IsWF) (hn : s.Nonempty) (ha : a ∈ s) : hs.min hn ≤ a 
Arguments: {α : Type u_2} [LinearOrder α] {s : Set α} {a : α} (hs : s.IsWF) (hn : s.Nonempty) (ha : a ∈ s)
Goal: hs.min hn ≤ a
-- Set.IsWF.le_min_iff
theorem IsWF.le_min_iff (hs : s.IsWF) (hn : s.Nonempty) : a ≤ hs.min hn ↔ ∀ b, b ∈ s → a ≤ b 
Arguments: {α : Type u_2} [LinearOrder α] {s : Set α} {a : α} (hs : s.IsWF) (hn : s.Nonempty)
Goal: a ≤ hs.min hn ↔ ∀ b ∈ s, a ≤ b
-- Set.IsWF.min_le_min_of_subset
theorem IsWF.min_le_min_of_subset {hs : s.IsWF} {hsn : s.Nonempty} {ht : t.IsWF} {htn : t.Nonempty}
    (hst : s ⊆ t) : ht.min htn ≤ hs.min hsn 
Arguments: {α : Type u_2} [LinearOrder α] {s t : Set α} {hs : s.IsWF} {hsn : s.Nonempty} {ht : t.IsWF} {htn : t.Nonempty} (hst : s ⊆ t)
Goal: ht.min htn ≤ hs.min hsn
-- Set.IsWF.min_union
theorem IsWF.min_union (hs : s.IsWF) (hsn : s.Nonempty) (ht : t.IsWF) (htn : t.Nonempty) :
    (hs.union ht).min (union_nonempty.2 (Or.intro_left _ hsn)) =
      Min.min (hs.min hsn) (ht.min htn) 
Arguments: {α : Type u_2} [LinearOrder α] {s t : Set α} (hs : s.IsWF) (hsn : s.Nonempty) (ht : t.IsWF) (htn : t.Nonempty)
Goal: ⋯.min ⋯ = min (hs.min hsn) (ht.min htn)
-- BddBelow.wellFoundedOn_lt
theorem BddBelow.wellFoundedOn_lt : BddBelow s → s.WellFoundedOn (· < ·) 
Arguments: {α : Type u_2} {s : Set α} [Preorder α] [LocallyFiniteOrder α]
Goal: BddBelow s → s.WellFoundedOn fun x x_1 => x < x_1
-- BddAbove.wellFoundedOn_gt
theorem BddAbove.wellFoundedOn_gt : BddAbove s → s.WellFoundedOn (· > ·) 
Arguments: {α : Type u_2} {s : Set α} [Preorder α] [LocallyFiniteOrder α]
Goal: BddAbove s → s.WellFoundedOn fun x x_1 => x > x_1
-- Set.PartiallyWellOrderedOn.iff_forall_not_isBadSeq
theorem iff_forall_not_isBadSeq (r : α → α → Prop) (s : Set α) :
    s.PartiallyWellOrderedOn r ↔ ∀ f, ¬IsBadSeq r s f 
Arguments: {α : Type u_2} (r : α → α → Prop) (s : Set α)
Goal: s.PartiallyWellOrderedOn r ↔ ∀ (f : ℕ → α), ¬Set.PartiallyWellOrderedOn.IsBadSeq r s f
-- Set.PartiallyWellOrderedOn.exists_min_bad_of_exists_bad
theorem exists_min_bad_of_exists_bad (r : α → α → Prop) (rk : α → ℕ) (s : Set α) :
    (∃ f, IsBadSeq r s f) → ∃ f, IsBadSeq r s f ∧ ∀ n, IsMinBadSeq r rk s n f 
Arguments: {α : Type u_2} (r : α → α → Prop) (rk : α → ℕ) (s : Set α)
Goal: (∃ f, Set.PartiallyWellOrderedOn.IsBadSeq r s f) →
  ∃ f, Set.PartiallyWellOrderedOn.IsBadSeq r s f ∧ ∀ (n : ℕ), Set.PartiallyWellOrderedOn.IsMinBadSeq r rk s n f
-- Set.PartiallyWellOrderedOn.iff_not_exists_isMinBadSeq
theorem iff_not_exists_isMinBadSeq (rk : α → ℕ) {s : Set α} :
    s.PartiallyWellOrderedOn r ↔ ¬∃ f, IsBadSeq r s f ∧ ∀ n, IsMinBadSeq r rk s n f 
Arguments: {α : Type u_2} {r : α → α → Prop} (rk : α → ℕ) {s : Set α}
Goal: s.PartiallyWellOrderedOn r ↔
  ¬∃ f, Set.PartiallyWellOrderedOn.IsBadSeq r s f ∧ ∀ (n : ℕ), Set.PartiallyWellOrderedOn.IsMinBadSeq r rk s n f
-- Set.PartiallyWellOrderedOn.partiallyWellOrderedOn_sublistForall₂
theorem partiallyWellOrderedOn_sublistForall₂ (r : α → α → Prop) [IsRefl α r] [IsTrans α r]
    {s : Set α} (h : s.PartiallyWellOrderedOn r) :
    { l : List α | ∀ x, x ∈ l → x ∈ s }.PartiallyWellOrderedOn (List.SublistForall₂ r) 
Arguments: {α : Type u_2} (r : α → α → Prop) [IsRefl α r] [IsTrans α r] {s : Set α} (h : s.PartiallyWellOrderedOn r)
Goal: {l | ∀ x ∈ l, x ∈ s}.PartiallyWellOrderedOn (List.SublistForall₂ r)
-- Set.PartiallyWellOrderedOn.subsetProdLex
theorem subsetProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hα : ((fun (x : α ×ₗ β) => (ofLex x).1)'' s).IsPWO)
    (hβ : ∀ a, {y | toLex (a, y) ∈ s}.IsPWO) : s.IsPWO 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [Preorder β] {s : Set (Lex (α × β))} (hα : ((fun x => (ofLex x).1) '' s).IsPWO) (hβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO)
Goal: s.IsPWO
-- Set.PartiallyWellOrderedOn.imageProdLex
theorem imageProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hαβ : s.IsPWO) : ((fun (x : α ×ₗ β) => (ofLex x).1)'' s).IsPWO 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [Preorder β] {s : Set (Lex (α × β))} (hαβ : s.IsPWO)
Goal: ((fun x => (ofLex x).1) '' s).IsPWO
-- Set.PartiallyWellOrderedOn.fiberProdLex
theorem fiberProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hαβ : s.IsPWO) (a : α) : {y | toLex (a, y) ∈ s}.IsPWO 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [Preorder β] {s : Set (Lex (α × β))} (hαβ : s.IsPWO) (a : α)
Goal: {y | toLex (a, y) ∈ s}.IsPWO
-- Set.PartiallyWellOrderedOn.ProdLex_iff
theorem ProdLex_iff [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)} :
    s.IsPWO ↔
      ((fun (x : α ×ₗ β) ↦ (ofLex x).1) '' s).IsPWO ∧ ∀ a, {y | toLex (a, y) ∈ s}.IsPWO 
Arguments: {α : Type u_2} {β : Type u_3} [PartialOrder α] [Preorder β] {s : Set (Lex (α × β))}
Goal: s.IsPWO ↔ ((fun x => (ofLex x).1) '' s).IsPWO ∧ ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO
-- WellFounded.isWF
theorem WellFounded.isWF [LT α] (h : WellFounded ((· < ·) : α → α → Prop)) (s : Set α) : s.IsWF 
Arguments: {α : Type u_2} [LT α] (h : WellFounded fun x x_1 => x < x_1) (s : Set α)
Goal: s.IsWF
-- Pi.isPWO
theorem Pi.isPWO {α : ι → Type*} [∀ i, LinearOrder (α i)] [∀ i, IsWellOrder (α i) (· < ·)]
    [Finite ι] (s : Set (∀ i, α i)) : s.IsPWO 
Arguments: {ι : Type u_1} {α : ι → Type u_6} [(i : ι) → LinearOrder (α i)] [∀ (i : ι), IsWellOrder (α i) fun x x_1 => x < x_1] [Finite ι] (s : Set ((i : ι) → α i))
Goal: s.IsPWO
-- WellFounded.prod_lex_of_wellFoundedOn_fiber
theorem WellFounded.prod_lex_of_wellFoundedOn_fiber (hα : WellFounded (rα on f))
    (hβ : ∀ a, (f ⁻¹' {a}).WellFoundedOn (rβ on g)) :
    WellFounded (Prod.Lex rα rβ on fun c => (f c, g c)) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {rα : α → α → Prop} {rβ : β → β → Prop} {f : γ → α} {g : γ → β} (hα : WellFounded (rα on f)) (hβ : ∀ (a : α), (f ⁻¹' {a}).WellFoundedOn (rβ on g))
Goal: WellFounded (Prod.Lex rα rβ on fun c => (f c, g c))
-- Set.WellFoundedOn.prod_lex_of_wellFoundedOn_fiber
theorem Set.WellFoundedOn.prod_lex_of_wellFoundedOn_fiber (hα : s.WellFoundedOn (rα on f))
    (hβ : ∀ a, (s ∩ f ⁻¹' {a}).WellFoundedOn (rβ on g)) :
    s.WellFoundedOn (Prod.Lex rα rβ on fun c => (f c, g c)) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {rα : α → α → Prop} {rβ : β → β → Prop} {f : γ → α} {g : γ → β} {s : Set γ} (hα : s.WellFoundedOn (rα on f)) (hβ : ∀ (a : α), (s ∩ f ⁻¹' {a}).WellFoundedOn (rβ on g))
Goal: s.WellFoundedOn (Prod.Lex rα rβ on fun c => (f c, g c))
-- WellFounded.sigma_lex_of_wellFoundedOn_fiber
theorem WellFounded.sigma_lex_of_wellFoundedOn_fiber (hι : WellFounded (rι on f))
    (hπ : ∀ i, (f ⁻¹' {i}).WellFoundedOn (rπ i on g i)) :
    WellFounded (Sigma.Lex rι rπ on fun c => ⟨f c, g (f c) c⟩) 
Arguments: {ι : Type u_1} {γ : Type u_4} {π : ι → Type u_5} {rι : ι → ι → Prop} {rπ : (i : ι) → π i → π i → Prop} {f : γ → ι} {g : (i : ι) → γ → π i} (hι : WellFounded (rι on f)) (hπ : ∀ (i : ι), (f ⁻¹' {i}).WellFoundedOn (rπ i on g i))
Goal: WellFounded (Sigma.Lex rι rπ on fun c => ⟨f c, g (f c) c⟩)
-- Set.WellFoundedOn.sigma_lex_of_wellFoundedOn_fiber
theorem Set.WellFoundedOn.sigma_lex_of_wellFoundedOn_fiber (hι : s.WellFoundedOn (rι on f))
    (hπ : ∀ i, (s ∩ f ⁻¹' {i}).WellFoundedOn (rπ i on g i)) :
    s.WellFoundedOn (Sigma.Lex rι rπ on fun c => ⟨f c, g (f c) c⟩) 
Arguments: {ι : Type u_1} {γ : Type u_4} {π : ι → Type u_5} {rι : ι → ι → Prop} {rπ : (i : ι) → π i → π i → Prop} {f : γ → ι} {g : (i : ι) → γ → π i} {s : Set γ} (hι : s.WellFoundedOn (rι on f)) (hπ : ∀ (i : ι), (s ∩ f ⁻¹' {i}).WellFoundedOn (rπ i on g i))
Goal: s.WellFoundedOn (Sigma.Lex rι rπ on fun c => ⟨f c, g (f c) c⟩)
-- Prop.bot_eq_false
@[simp]
theorem Prop.bot_eq_false : (⊥ : Prop) = False 
Goal: ⊥ = False
-- Prop.top_eq_true
@[simp]
theorem Prop.top_eq_true : (⊤ : Prop) = True 
Goal: ⊤ = True
-- sup_Prop_eq
@[simp]
theorem sup_Prop_eq : (· ⊔ ·) = (· ∨ ·) 
Goal: (fun x x_1 => x ⊔ x_1) = fun x x_1 => x ∨ x_1
-- inf_Prop_eq
@[simp]
theorem inf_Prop_eq : (· ⊓ ·) = (· ∧ ·) 
Goal: (fun x x_1 => x ⊓ x_1) = fun x x_1 => x ∧ x_1
-- Pi.disjoint_iff
theorem disjoint_iff [∀ i, OrderBot (α' i)] {f g : ∀ i, α' i} :
    Disjoint f g ↔ ∀ i, Disjoint (f i) (g i) 
Arguments: {ι : Type u_1} {α' : ι → Type u_2} [(i : ι) → PartialOrder (α' i)] [(i : ι) → OrderBot (α' i)] {f g : (i : ι) → α' i}
Goal: Disjoint f g ↔ ∀ (i : ι), Disjoint (f i) (g i)
-- Pi.codisjoint_iff
theorem codisjoint_iff [∀ i, OrderTop (α' i)] {f g : ∀ i, α' i} :
    Codisjoint f g ↔ ∀ i, Codisjoint (f i) (g i) 
Arguments: {ι : Type u_1} {α' : ι → Type u_2} [(i : ι) → PartialOrder (α' i)] [(i : ι) → OrderTop (α' i)] {f g : (i : ι) → α' i}
Goal: Codisjoint f g ↔ ∀ (i : ι), Codisjoint (f i) (g i)
-- Pi.isCompl_iff
theorem isCompl_iff [∀ i, BoundedOrder (α' i)] {f g : ∀ i, α' i} :
    IsCompl f g ↔ ∀ i, IsCompl (f i) (g i) 
Arguments: {ι : Type u_1} {α' : ι → Type u_2} [(i : ι) → PartialOrder (α' i)] [(i : ι) → BoundedOrder (α' i)] {f g : (i : ι) → α' i}
Goal: IsCompl f g ↔ ∀ (i : ι), IsCompl (f i) (g i)
-- Prop.disjoint_iff
@[simp]
theorem Prop.disjoint_iff {P Q : Prop} : Disjoint P Q ↔ ¬(P ∧ Q) 
Arguments: {P Q : Prop}
Goal: Disjoint P Q ↔ ¬(P ∧ Q)
-- Prop.codisjoint_iff
@[simp]
theorem Prop.codisjoint_iff {P Q : Prop} : Codisjoint P Q ↔ P ∨ Q 
Arguments: {P Q : Prop}
Goal: Codisjoint P Q ↔ P ∨ Q
-- Prop.isCompl_iff
@[simp]
theorem Prop.isCompl_iff {P Q : Prop} : IsCompl P Q ↔ ¬(P ↔ Q) 
Arguments: {P Q : Prop}
Goal: IsCompl P Q ↔ ¬(P ↔ Q)
-- Order.Ideal.directed'
structure Ideal (P) [LE P] extends LowerSet P where
    nonempty' : carrier.Nonempty
    directed' : DirectedOn (· ≤ ·) carrier
Arguments: {P : Type u_2} [LE P] (self : Order.Ideal P)
Goal: DirectedOn (fun x x_1 => x ≤ x_1) self.carrier
-- Order.Ideal.nonempty'
structure Ideal (P) [LE P] extends LowerSet P where
    nonempty' : carrier.Nonempty
    directed' : DirectedOn (· ≤ ·) carrier
Arguments: {P : Type u_2} [LE P] (self : Order.Ideal P)
Goal: self.carrier.Nonempty
-- Order.IsIdeal.Nonempty
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
    IsLowerSet : IsLowerSet I
    Nonempty : I.Nonempty
    Directed : DirectedOn (· ≤ ·) I
Arguments: {P : Type u_2} [LE P] {I : Set P} (self : Order.IsIdeal I)
Goal: I.Nonempty
-- Order.IsIdeal.IsLowerSet
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
    IsLowerSet : IsLowerSet I
    Nonempty : I.Nonempty
    Directed : DirectedOn (· ≤ ·) I
Arguments: {P : Type u_2} [LE P] {I : Set P} (self : Order.IsIdeal I)
Goal: IsLowerSet I
-- Order.IsIdeal.Directed
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
    IsLowerSet : IsLowerSet I
    Nonempty : I.Nonempty
    Directed : DirectedOn (· ≤ ·) I
Arguments: {P : Type u_2} [LE P] {I : Set P} (self : Order.IsIdeal I)
Goal: DirectedOn (fun x x_1 => x ≤ x_1) I
-- Order.isIdeal_iff
@[mk_iff]
structure IsIdeal {P} [LE P] (I : Set P) : Prop where
    IsLowerSet : IsLowerSet I
    Nonempty : I.Nonempty
    Directed : DirectedOn (· ≤ ·) I
Arguments: {P : Type u_2} [LE P] (I : Set P)
Goal: Order.IsIdeal I ↔ IsLowerSet I ∧ I.Nonempty ∧ DirectedOn (fun x x_1 => x ≤ x_1) I
-- Order.Ideal.toLowerSet_injective
theorem toLowerSet_injective : Injective (toLowerSet : Ideal P → LowerSet P) 
Arguments: {P : Type u_1} [LE P]
Goal: Function.Injective Order.Ideal.toLowerSet
-- Order.Ideal.ext
@[ext]
theorem ext {s t : Ideal P} : (s : Set P) = t → s = t 
Arguments: {P : Type u_1} [LE P] {s t : Order.Ideal P}
Goal: ↑s = ↑t → s = t
-- Order.Ideal.carrier_eq_coe
@[simp]
theorem carrier_eq_coe (s : Ideal P) : s.carrier = s 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: s.carrier = ↑s
-- Order.Ideal.coe_toLowerSet
@[simp]
theorem coe_toLowerSet (s : Ideal P) : (s.toLowerSet : Set P) = s 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: ↑s.toLowerSet = ↑s
-- Order.Ideal.lower
protected theorem lower (s : Ideal P) : IsLowerSet (s : Set P) 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: IsLowerSet ↑s
-- Order.Ideal.nonempty
protected theorem nonempty (s : Ideal P) : (s : Set P).Nonempty 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: (↑s).Nonempty
-- Order.Ideal.directed
protected theorem directed (s : Ideal P) : DirectedOn (· ≤ ·) (s : Set P) 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: DirectedOn (fun x x_1 => x ≤ x_1) ↑s
-- Order.Ideal.isIdeal
protected theorem isIdeal (s : Ideal P) : IsIdeal (s : Set P) 
Arguments: {P : Type u_1} [LE P] (s : Order.Ideal P)
Goal: Order.IsIdeal ↑s
-- Order.Ideal.mem_compl_of_ge
theorem mem_compl_of_ge {x y : P} : x ≤ y → x ∈ (I : Set P)ᶜ → y ∈ (I : Set P)ᶜ 
Arguments: {P : Type u_1} [LE P] {I : Order.Ideal P} {x y : P}
Goal: x ≤ y → x ∈ (↑I)ᶜ → y ∈ (↑I)ᶜ
-- Order.Ideal.coe_subset_coe
theorem coe_subset_coe : (s : Set P) ⊆ t ↔ s ≤ t 
Arguments: {P : Type u_1} [LE P] {s t : Order.Ideal P}
Goal: ↑s ⊆ ↑t ↔ s ≤ t
-- Order.Ideal.coe_ssubset_coe
theorem coe_ssubset_coe : (s : Set P) ⊂ t ↔ s < t 
Arguments: {P : Type u_1} [LE P] {s t : Order.Ideal P}
Goal: ↑s ⊂ ↑t ↔ s < t
-- Order.Ideal.mem_of_mem_of_le
@[trans]
theorem mem_of_mem_of_le {x : P} {I J : Ideal P} : x ∈ I → I ≤ J → x ∈ J 
Arguments: {P : Type u_1} [LE P] {x : P} {I J : Order.Ideal P}
Goal: x ∈ I → I ≤ J → x ∈ J
-- Order.Ideal.isProper_iff
@[mk_iff]
class IsProper (I : Ideal P) : Prop where
    ne_univ : (I : Set P) ≠ univ
Arguments: {P : Type u_1} [LE P] (I : Order.Ideal P)
Goal: I.IsProper ↔ ↑I ≠ Set.univ
-- Order.Ideal.IsProper.ne_univ
@[mk_iff]
class IsProper (I : Ideal P) : Prop where
    ne_univ : (I : Set P) ≠ univ
Arguments: {P : Type u_1} [LE P] {I : Order.Ideal P} [self : I.IsProper]
Goal: ↑I ≠ Set.univ
-- Order.Ideal.isProper_of_not_mem
theorem isProper_of_not_mem {I : Ideal P} {p : P} (nmem : p ∉ I) : IsProper I 
Arguments: {P : Type u_1} [LE P] {I : Order.Ideal P} {p : P} (nmem : p ∉ I)
Goal: I.IsProper
-- Order.Ideal.isMaximal_iff
@[mk_iff]
class IsMaximal (I : Ideal P) extends IsProper I : Prop where
    maximal_proper : ∀ ⦃J : Ideal P⦄, I < J → (J : Set P) = univ
Arguments: {P : Type u_1} [LE P] (I : Order.Ideal P)
Goal: I.IsMaximal ↔ I.IsProper ∧ ∀ ⦃J : Order.Ideal P⦄, I < J → ↑J = Set.univ
-- Order.Ideal.IsMaximal.maximal_proper
@[mk_iff]
class IsMaximal (I : Ideal P) extends IsProper I : Prop where
    maximal_proper : ∀ ⦃J : Ideal P⦄, I < J → (J : Set P) = univ
Arguments: {P : Type u_1} [LE P] {I : Order.Ideal P} [self : I.IsMaximal] ⦃J : Order.Ideal P⦄
Goal: I < J → ↑J = Set.univ
-- Order.Ideal.inter_nonempty
theorem inter_nonempty [IsDirected P (· ≥ ·)] (I J : Ideal P) : (I ∩ J : Set P).Nonempty 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≥ x_1] (I J : Order.Ideal P)
Goal: (↑I ∩ ↑J).Nonempty
-- Order.Ideal.top_toLowerSet
@[simp]
theorem top_toLowerSet : (⊤ : Ideal P).toLowerSet = ⊤ 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P]
Goal: ⊤.toLowerSet = ⊤
-- Order.Ideal.coe_top
@[simp]
theorem coe_top : ((⊤ : Ideal P) : Set P) = univ 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P]
Goal: ↑⊤ = Set.univ
-- Order.Ideal.isProper_of_ne_top
theorem isProper_of_ne_top (ne_top : I ≠ ⊤) : IsProper I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P} (ne_top : I ≠ ⊤)
Goal: I.IsProper
-- Order.Ideal.IsProper.ne_top
theorem IsProper.ne_top (_ : IsProper I) : I ≠ ⊤ 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P}
Goal: I.IsProper → I ≠ ⊤
-- IsCoatom.isProper
theorem _root_.IsCoatom.isProper (hI : IsCoatom I) : IsProper I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P} (hI : IsCoatom I)
Goal: I.IsProper
-- Order.Ideal.isProper_iff_ne_top
theorem isProper_iff_ne_top : IsProper I ↔ I ≠ ⊤ 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P}
Goal: I.IsProper ↔ I ≠ ⊤
-- Order.Ideal.IsMaximal.isCoatom
theorem IsMaximal.isCoatom (_ : IsMaximal I) : IsCoatom I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P}
Goal: I.IsMaximal → IsCoatom I
-- Order.Ideal.IsMaximal.isCoatom'
theorem IsMaximal.isCoatom' [IsMaximal I] : IsCoatom I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P} [I.IsMaximal]
Goal: IsCoatom I
-- IsCoatom.isMaximal
theorem _root_.IsCoatom.isMaximal (hI : IsCoatom I) : IsMaximal I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P} (hI : IsCoatom I)
Goal: I.IsMaximal
-- Order.Ideal.isMaximal_iff_isCoatom
theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I 
Arguments: {P : Type u_1} [LE P] [IsDirected P fun x x_1 => x ≤ x_1] [Nonempty P] {I : Order.Ideal P}
Goal: I.IsMaximal ↔ IsCoatom I
-- Order.Ideal.bot_mem
@[simp]
theorem bot_mem (s : Ideal P) : ⊥ ∈ s 
Arguments: {P : Type u_1} [LE P] [OrderBot P] (s : Order.Ideal P)
Goal: ⊥ ∈ s
-- Order.Ideal.top_of_top_mem
theorem top_of_top_mem (h : ⊤ ∈ I) : I = ⊤ 
Arguments: {P : Type u_1} [LE P] [OrderTop P] {I : Order.Ideal P} (h : ⊤ ∈ I)
Goal: I = ⊤
-- Order.Ideal.IsProper.top_not_mem
theorem IsProper.top_not_mem (hI : IsProper I) : ⊤ ∉ I 
Arguments: {P : Type u_1} [LE P] [OrderTop P] {I : Order.Ideal P} (hI : I.IsProper)
Goal: ⊤ ∉ I
-- Order.Ideal.principal_toLowerSet
@[simps]
def principal (p : P) : Ideal P 
Arguments: {P : Type u_1} [Preorder P] (p : P)
Goal: (Order.Ideal.principal p).toLowerSet = LowerSet.Iic p
-- Order.Ideal.principal_le_iff
@[simp]
theorem principal_le_iff : principal x ≤ I ↔ x ∈ I 
Arguments: {P : Type u_1} [Preorder P] {I : Order.Ideal P} {x : P}
Goal: Order.Ideal.principal x ≤ I ↔ x ∈ I
-- Order.Ideal.mem_principal
@[simp]
theorem mem_principal : x ∈ principal y ↔ x ≤ y 
Arguments: {P : Type u_1} [Preorder P] {x y : P}
Goal: x ∈ Order.Ideal.principal y ↔ x ≤ y
-- Order.Ideal.mem_principal_self
lemma mem_principal_self : x ∈ principal x 
Arguments: {P : Type u_1} [Preorder P] {x : P}
Goal: x ∈ Order.Ideal.principal x
-- Order.Ideal.principal_bot
@[simp]
theorem principal_bot : principal (⊥ : P) = ⊥ 
Arguments: {P : Type u_1} [Preorder P] [OrderBot P]
Goal: Order.Ideal.principal ⊥ = ⊥
-- Order.Ideal.principal_top
@[simp]
theorem principal_top : principal (⊤ : P) = ⊤ 
Arguments: {P : Type u_1} [Preorder P] [OrderTop P]
Goal: Order.Ideal.principal ⊤ = ⊤
-- Order.Ideal.sup_mem
theorem sup_mem (hx : x ∈ s) (hy : y ∈ s) : x ⊔ y ∈ s 
Arguments: {P : Type u_1} [SemilatticeSup P] {x y : P} {s : Order.Ideal P} (hx : x ∈ s) (hy : y ∈ s)
Goal: x ⊔ y ∈ s
-- Order.Ideal.sup_mem_iff
@[simp]
theorem sup_mem_iff : x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I 
Arguments: {P : Type u_1} [SemilatticeSup P] {x y : P} {I : Order.Ideal P}
Goal: x ⊔ y ∈ I ↔ x ∈ I ∧ y ∈ I
-- Order.Ideal.coe_sup
@[simp]
theorem coe_sup : ↑(s ⊔ t) = { x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b } 
Arguments: {P : Type u_1} [SemilatticeSup P] [IsDirected P fun x x_1 => x ≥ x_1] {s t : Order.Ideal P}
Goal: ↑(s ⊔ t) = {x | ∃ a ∈ s, ∃ b ∈ t, x ≤ a ⊔ b}
-- Order.Ideal.coe_inf
@[simp]
theorem coe_inf : (↑(s ⊓ t) : Set P) = ↑s ∩ ↑t 
Arguments: {P : Type u_1} [SemilatticeSup P] [IsDirected P fun x x_1 => x ≥ x_1] {s t : Order.Ideal P}
Goal: ↑(s ⊓ t) = ↑s ∩ ↑t
-- Order.Ideal.mem_inf
@[simp]
theorem mem_inf : x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J 
Arguments: {P : Type u_1} [SemilatticeSup P] [IsDirected P fun x x_1 => x ≥ x_1] {x : P} {I J : Order.Ideal P}
Goal: x ∈ I ⊓ J ↔ x ∈ I ∧ x ∈ J
-- Order.Ideal.mem_sup
@[simp]
theorem mem_sup : x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j 
Arguments: {P : Type u_1} [SemilatticeSup P] [IsDirected P fun x x_1 => x ≥ x_1] {x : P} {I J : Order.Ideal P}
Goal: x ∈ I ⊔ J ↔ ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j
-- Order.Ideal.lt_sup_principal_of_not_mem
theorem lt_sup_principal_of_not_mem (hx : x ∉ I) : I < I ⊔ principal x 
Arguments: {P : Type u_1} [SemilatticeSup P] [IsDirected P fun x x_1 => x ≥ x_1] {x : P} {I : Order.Ideal P} (hx : x ∉ I)
Goal: I < I ⊔ Order.Ideal.principal x
-- Order.Ideal.coe_sInf
@[simp]
theorem coe_sInf : (↑(sInf S) : Set P) = ⋂ s ∈ S, ↑s 
Arguments: {P : Type u_1} [SemilatticeSup P] [OrderBot P] {S : Set (Order.Ideal P)}
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s