ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- le_ciInf_add_ciInf
@[to_additive]
theorem le_ciInf_mul_ciInf [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, a ≤ g i * h j) : a ≤ iInf g * iInf h 
Arguments: {α : Type u_1} {ι : Sort u_2} {ι' : Sort u_3} [Nonempty ι] [Nonempty ι'] [ConditionallyCompleteLattice α] [AddGroup α] [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] {a : α} {g : ι → α} {h : ι' → α} (H : ∀ (i : ι) (j : ι'), a ≤ g i + h j)
Goal: a ≤ iInf g + iInf h
-- ciSup_mul_ciSup_le
@[to_additive]
theorem ciSup_mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, g i * h j ≤ a) : iSup g * iSup h ≤ a 
Arguments: {α : Type u_1} {ι : Sort u_2} {ι' : Sort u_3} [Nonempty ι] [Nonempty ι'] [ConditionallyCompleteLattice α] [Group α] [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] {a : α} {g : ι → α} {h : ι' → α} (H : ∀ (i : ι) (j : ι'), g i * h j ≤ a)
Goal: iSup g * iSup h ≤ a
-- ciSup_add_ciSup_le
@[to_additive]
theorem ciSup_mul_ciSup_le [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a : α} {g : ι → α} {h : ι' → α}
    (H : ∀ i j, g i * h j ≤ a) : iSup g * iSup h ≤ a 
Arguments: {α : Type u_1} {ι : Sort u_2} {ι' : Sort u_3} [Nonempty ι] [Nonempty ι'] [ConditionallyCompleteLattice α] [AddGroup α] [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] {a : α} {g : ι → α} {h : ι' → α} (H : ∀ (i : ι) (j : ι'), g i + h j ≤ a)
Goal: iSup g + iSup h ≤ a
-- Finset.Nonempty.csSup_eq_max'
theorem Finset.Nonempty.csSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Finset α} (h : s.Nonempty)
Goal: sSup ↑s = s.max' h
-- Finset.Nonempty.csInf_eq_min'
theorem Finset.Nonempty.csInf_eq_min' {s : Finset α} (h : s.Nonempty) : sInf ↑s = s.min' h 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Finset α} (h : s.Nonempty)
Goal: sInf ↑s = s.min' h
-- Finset.Nonempty.csSup_mem
theorem Finset.Nonempty.csSup_mem {s : Finset α} (h : s.Nonempty) : sSup (s : Set α) ∈ s 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Finset α} (h : s.Nonempty)
Goal: sSup ↑s ∈ s
-- Finset.Nonempty.csInf_mem
theorem Finset.Nonempty.csInf_mem {s : Finset α} (h : s.Nonempty) : sInf (s : Set α) ∈ s 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Finset α} (h : s.Nonempty)
Goal: sInf ↑s ∈ s
-- Set.Nonempty.csSup_mem
theorem Set.Nonempty.csSup_mem (h : s.Nonempty) (hs : s.Finite) : sSup s ∈ s 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Set α} (h : s.Nonempty) (hs : s.Finite)
Goal: sSup s ∈ s
-- Set.Nonempty.csInf_mem
theorem Set.Nonempty.csInf_mem (h : s.Nonempty) (hs : s.Finite) : sInf s ∈ s 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Set α} (h : s.Nonempty) (hs : s.Finite)
Goal: sInf s ∈ s
-- Set.Finite.csSup_lt_iff
theorem Set.Finite.csSup_lt_iff (hs : s.Finite) (h : s.Nonempty) : sSup s < a ↔ ∀ x ∈ s, x < a 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Set α} {a : α} (hs : s.Finite) (h : s.Nonempty)
Goal: sSup s < a ↔ ∀ x ∈ s, x < a
-- Set.Finite.lt_csInf_iff
theorem Set.Finite.lt_csInf_iff (hs : s.Finite) (h : s.Nonempty) : a < sInf s ↔ ∀ x ∈ s, a < x 
Arguments: {α : Type u_2} [ConditionallyCompleteLinearOrder α] {s : Set α} {a : α} (hs : s.Finite) (h : s.Nonempty)
Goal: a < sInf s ↔ ∀ x ∈ s, a < x
-- Finset.sup'_eq_csSup_image
theorem sup'_eq_csSup_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
    s.sup' H f = sSup (f '' s) 
Arguments: {ι : Type u_1} {α : Type u_2} [ConditionallyCompleteLattice α] (s : Finset ι) (H : s.Nonempty) (f : ι → α)
Goal: s.sup' H f = sSup (f '' ↑s)
-- Finset.inf'_eq_csInf_image
theorem inf'_eq_csInf_image (s : Finset ι) (H : s.Nonempty) (f : ι → α) :
    s.inf' H f = sInf (f '' s) 
Arguments: {ι : Type u_1} {α : Type u_2} [ConditionallyCompleteLattice α] (s : Finset ι) (H : s.Nonempty) (f : ι → α)
Goal: s.inf' H f = sInf (f '' ↑s)
-- Finset.sup'_id_eq_csSup
theorem sup'_id_eq_csSup (s : Finset α) (hs) : s.sup' hs id = sSup s 
Arguments: {α : Type u_2} [ConditionallyCompleteLattice α] (s : Finset α) (hs : s.Nonempty)
Goal: s.sup' hs id = sSup ↑s
-- Finset.inf'_id_eq_csInf
theorem inf'_id_eq_csInf (s : Finset α) (hs) : s.inf' hs id = sInf s 
Arguments: {α : Type u_2} [ConditionallyCompleteLattice α] (s : Finset α) (hs : s.Nonempty)
Goal: s.inf' hs id = sInf ↑s
-- Finset.sup'_univ_eq_ciSup
lemma sup'_univ_eq_ciSup (f : ι → α) : univ.sup' univ_nonempty f = ⨆ i, f i 
Arguments: {ι : Type u_1} {α : Type u_2} [ConditionallyCompleteLattice α] [Fintype ι] [Nonempty ι] (f : ι → α)
Goal: Finset.univ.sup' ⋯ f = ⨆ i, f i
-- Finset.inf'_univ_eq_ciInf
lemma inf'_univ_eq_ciInf (f : ι → α) : univ.inf' univ_nonempty f = ⨅ i, f i 
Arguments: {ι : Type u_1} {α : Type u_2} [ConditionallyCompleteLattice α] [Fintype ι] [Nonempty ι] (f : ι → α)
Goal: Finset.univ.inf' ⋯ f = ⨅ i, f i
-- Finset.sup_univ_eq_ciSup
lemma sup_univ_eq_ciSup [Fintype ι] (f : ι → α) : univ.sup f = ⨆ i, f i 
Arguments: {ι : Type u_1} {α : Type u_2} [ConditionallyCompleteLinearOrderBot α] [Fintype ι] (f : ι → α)
Goal: Finset.univ.sup f = ⨆ i, f i
-- OrderHom.lfp_le
theorem lfp_le {a : α} (h : f a ≤ a) : lfp f ≤ a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (h : f a ≤ a)
Goal: OrderHom.lfp f ≤ a
-- OrderHom.lfp_le_fixed
theorem lfp_le_fixed {a : α} (h : f a = a) : lfp f ≤ a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (h : f a = a)
Goal: OrderHom.lfp f ≤ a
-- OrderHom.le_lfp
theorem le_lfp {a : α} (h : ∀ b, f b ≤ b → a ≤ b) : a ≤ lfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (h : ∀ (b : α), f b ≤ b → a ≤ b)
Goal: a ≤ OrderHom.lfp f
-- OrderHom.map_le_lfp
theorem map_le_lfp {a : α} (ha : a ≤ lfp f) : f a ≤ lfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (ha : a ≤ OrderHom.lfp f)
Goal: f a ≤ OrderHom.lfp f
-- OrderHom.map_lfp
@[simp]
theorem map_lfp : f (lfp f) = lfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: f (OrderHom.lfp f) = OrderHom.lfp f
-- OrderHom.isFixedPt_lfp
theorem isFixedPt_lfp : IsFixedPt f (lfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: Function.IsFixedPt (⇑f) (OrderHom.lfp f)
-- OrderHom.lfp_le_map
theorem lfp_le_map {a : α} (ha : lfp f ≤ a) : lfp f ≤ f a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (ha : OrderHom.lfp f ≤ a)
Goal: OrderHom.lfp f ≤ f a
-- OrderHom.isLeast_lfp_le
theorem isLeast_lfp_le : IsLeast { a | f a ≤ a } (lfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: IsLeast {a | f a ≤ a} (OrderHom.lfp f)
-- OrderHom.isLeast_lfp
theorem isLeast_lfp : IsLeast (fixedPoints f) (lfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: IsLeast (Function.fixedPoints ⇑f) (OrderHom.lfp f)
-- OrderHom.lfp_induction
theorem lfp_induction {p : α → Prop} (step : ∀ a, p a → a ≤ lfp f → p (f a))
    (hSup : ∀ s, (∀ a ∈ s, p a) → p (sSup s)) : p (lfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {p : α → Prop} (step : ∀ (a : α), p a → a ≤ OrderHom.lfp f → p (f a)) (hSup : ∀ (s : Set α), (∀ a ∈ s, p a) → p (sSup s))
Goal: p (OrderHom.lfp f)
-- OrderHom.le_gfp
theorem le_gfp {a : α} (h : a ≤ f a) : a ≤ gfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (h : a ≤ f a)
Goal: a ≤ OrderHom.gfp f
-- OrderHom.gfp_le
theorem gfp_le {a : α} (h : ∀ b, b ≤ f b → b ≤ a) : gfp f ≤ a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (h : ∀ b ≤ f b, b ≤ a)
Goal: OrderHom.gfp f ≤ a
-- OrderHom.isFixedPt_gfp
theorem isFixedPt_gfp : IsFixedPt f (gfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: Function.IsFixedPt (⇑f) (OrderHom.gfp f)
-- OrderHom.map_gfp
@[simp]
theorem map_gfp : f (gfp f) = gfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: f (OrderHom.gfp f) = OrderHom.gfp f
-- OrderHom.map_le_gfp
theorem map_le_gfp {a : α} (ha : a ≤ gfp f) : f a ≤ gfp f 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (ha : a ≤ OrderHom.gfp f)
Goal: f a ≤ OrderHom.gfp f
-- OrderHom.gfp_le_map
theorem gfp_le_map {a : α} (ha : gfp f ≤ a) : gfp f ≤ f a 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {a : α} (ha : OrderHom.gfp f ≤ a)
Goal: OrderHom.gfp f ≤ f a
-- OrderHom.isGreatest_gfp_le
theorem isGreatest_gfp_le : IsGreatest { a | a ≤ f a } (gfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: IsGreatest {a | a ≤ f a} (OrderHom.gfp f)
-- OrderHom.isGreatest_gfp
theorem isGreatest_gfp : IsGreatest (fixedPoints f) (gfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α)
Goal: IsGreatest (Function.fixedPoints ⇑f) (OrderHom.gfp f)
-- OrderHom.gfp_induction
theorem gfp_induction {p : α → Prop} (step : ∀ a, p a → gfp f ≤ a → p (f a))
    (hInf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : p (gfp f) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {p : α → Prop} (step : ∀ (a : α), p a → OrderHom.gfp f ≤ a → p (f a)) (hInf : ∀ (s : Set α), (∀ a ∈ s, p a) → p (sInf s))
Goal: p (OrderHom.gfp f)
-- OrderHom.map_lfp_comp
theorem map_lfp_comp : f (lfp (g.comp f)) = lfp (f.comp g) 
Arguments: {α : Type u} {β : Type v} [CompleteLattice α] [CompleteLattice β] (f : β →o α) (g : α →o β)
Goal: f (OrderHom.lfp (g.comp f)) = OrderHom.lfp (f.comp g)
-- OrderHom.map_gfp_comp
theorem map_gfp_comp : f (gfp (g.comp f)) = gfp (f.comp g) 
Arguments: {α : Type u} {β : Type v} [CompleteLattice α] [CompleteLattice β] (f : β →o α) (g : α →o β)
Goal: f (OrderHom.gfp (g.comp f)) = OrderHom.gfp (f.comp g)
-- OrderHom.lfp_lfp
theorem lfp_lfp (h : α →o α →o α) : lfp (lfp.comp h) = lfp h.onDiag 
Arguments: {α : Type u} [CompleteLattice α] (h : α →o α →o α)
Goal: OrderHom.lfp (OrderHom.lfp.comp h) = OrderHom.lfp h.onDiag
-- OrderHom.gfp_gfp
theorem gfp_gfp (h : α →o α →o α) : gfp (gfp.comp h) = gfp h.onDiag 
Arguments: {α : Type u} [CompleteLattice α] (h : α →o α →o α)
Goal: OrderHom.gfp (OrderHom.gfp.comp h) = OrderHom.gfp h.onDiag
-- OrderHom.gfp_const_inf_le
theorem gfp_const_inf_le (x : α) : gfp (const α x ⊓ f) ≤ x 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x : α)
Goal: OrderHom.gfp ((OrderHom.const α) x ⊓ f) ≤ x
-- OrderHom.prevFixed_le
theorem prevFixed_le {x : α} (hx : f x ≤ x) : ↑(f.prevFixed x hx) ≤ x 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x)
Goal: ↑(f.prevFixed x hx) ≤ x
-- OrderHom.le_nextFixed
theorem le_nextFixed {x : α} (hx : x ≤ f x) : x ≤ f.nextFixed x hx 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : x ≤ f x)
Goal: x ≤ ↑(f.nextFixed x hx)
-- OrderHom.nextFixed_le
theorem nextFixed_le {x : α} (hx : x ≤ f x) {y : fixedPoints f} (h : x ≤ y) :
    f.nextFixed x hx ≤ y 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : x ≤ f x) {y : ↑(Function.fixedPoints ⇑f)} (h : x ≤ ↑y)
Goal: f.nextFixed x hx ≤ y
-- OrderHom.nextFixed_le_iff
@[simp]
theorem nextFixed_le_iff {x : α} (hx : x ≤ f x) {y : fixedPoints f} :
    f.nextFixed x hx ≤ y ↔ x ≤ y 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : x ≤ f x) {y : ↑(Function.fixedPoints ⇑f)}
Goal: f.nextFixed x hx ≤ y ↔ x ≤ ↑y
-- OrderHom.le_prevFixed_iff
@[simp]
theorem le_prevFixed_iff {x : α} (hx : f x ≤ x) {y : fixedPoints f} :
    y ≤ f.prevFixed x hx ↔ ↑y ≤ x 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)}
Goal: y ≤ f.prevFixed x hx ↔ ↑y ≤ x
-- OrderHom.le_prevFixed
theorem le_prevFixed {x : α} (hx : f x ≤ x) {y : fixedPoints f} (h : ↑y ≤ x) :
    y ≤ f.prevFixed x hx 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)} (h : ↑y ≤ x)
Goal: y ≤ f.prevFixed x hx
-- OrderHom.le_map_sup_fixedPoints
theorem le_map_sup_fixedPoints (x y : fixedPoints f) : (x ⊔ y : α) ≤ f (x ⊔ y) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x y : ↑(Function.fixedPoints ⇑f))
Goal: ↑x ⊔ ↑y ≤ f (↑x ⊔ ↑y)
-- OrderHom.map_inf_fixedPoints_le
theorem map_inf_fixedPoints_le (x y : fixedPoints f) : f (x ⊓ y) ≤ x.val ⊓ y.val 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (x y : ↑(Function.fixedPoints ⇑f))
Goal: f (↑x ⊓ ↑y) ≤ ↑x ⊓ ↑y
-- OrderHom.le_map_sSup_subset_fixedPoints
theorem le_map_sSup_subset_fixedPoints (A : Set α) (hA : A ⊆ fixedPoints f) :
    sSup A ≤ f (sSup A) 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (A : Set α) (hA : A ⊆ Function.fixedPoints ⇑f)
Goal: sSup A ≤ f (sSup A)
-- OrderHom.map_sInf_subset_fixedPoints_le
theorem map_sInf_subset_fixedPoints_le (A : Set α) (hA : A ⊆ fixedPoints f) :
    f (sInf A) ≤ sInf A 
Arguments: {α : Type u} [CompleteLattice α] (f : α →o α) (A : Set α) (hA : A ⊆ Function.fixedPoints ⇑f)
Goal: f (sInf A) ≤ sInf A
-- Order.Ideal.PrimePair.isCompl_I_F
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure PrimePair (P : Type*) [Preorder P] where
  I : Ideal P
  F : PFilter P
  isCompl_I_F : IsCompl (I : Set P) F
Arguments: {P : Type u_2} [Preorder P] (self : Order.Ideal.PrimePair P)
Goal: IsCompl ↑self.I ↑self.F
-- Order.Ideal.PrimePair.compl_I_eq_F
theorem compl_I_eq_F : (IF.I : Set P)ᶜ = IF.F 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: (↑IF.I)ᶜ = ↑IF.F
-- Order.Ideal.PrimePair.compl_F_eq_I
theorem compl_F_eq_I : (IF.F : Set P)ᶜ = IF.I 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: (↑IF.F)ᶜ = ↑IF.I
-- Order.Ideal.PrimePair.I_isProper
theorem I_isProper : IsProper IF.I 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: IF.I.IsProper
-- Order.Ideal.PrimePair.disjoint
protected theorem disjoint : Disjoint (IF.I : Set P) IF.F 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: Disjoint ↑IF.I ↑IF.F
-- Order.Ideal.PrimePair.I_union_F
theorem I_union_F : (IF.I : Set P) ∪ IF.F = Set.univ 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: ↑IF.I ∪ ↑IF.F = Set.univ
-- Order.Ideal.PrimePair.F_union_I
theorem F_union_I : (IF.F : Set P) ∪ IF.I = Set.univ 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: ↑IF.F ∪ ↑IF.I = Set.univ
-- Order.Ideal.IsPrime.compl_filter
@[mk_iff]
class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
  compl_filter : IsPFilter (I : Set P)ᶜ
Arguments: {P : Type u_1} [Preorder P] {I : Order.Ideal P} [self : I.IsPrime]
Goal: Order.IsPFilter (↑I)ᶜ
-- Order.Ideal.isPrime_iff
@[mk_iff]
class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
  compl_filter : IsPFilter (I : Set P)ᶜ
Arguments: {P : Type u_1} [Preorder P] (I : Order.Ideal P)
Goal: I.IsPrime ↔ I.IsProper ∧ Order.IsPFilter (↑I)ᶜ
-- Order.Ideal.PrimePair.I_isPrime
theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.I 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: IF.I.IsPrime
-- Order.Ideal.IsPrime.mem_or_mem
theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I 
Arguments: {P : Type u_1} [SemilatticeInf P] {I : Order.Ideal P} (hI : I.IsPrime) {x y : P}
Goal: x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
-- Order.Ideal.IsPrime.of_mem_or_mem
theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
    IsPrime I 
Arguments: {P : Type u_1} [SemilatticeInf P] {I : Order.Ideal P} [I.IsProper] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I)
Goal: I.IsPrime
-- Order.Ideal.isPrime_iff_mem_or_mem
theorem isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I 
Arguments: {P : Type u_1} [SemilatticeInf P] {I : Order.Ideal P} [I.IsProper]
Goal: I.IsPrime ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
-- Order.Ideal.IsPrime.mem_or_compl_mem
theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I 
Arguments: {P : Type u_1} [BooleanAlgebra P] {x : P} {I : Order.Ideal P} (hI : I.IsPrime)
Goal: x ∈ I ∨ xᶜ ∈ I
-- Order.Ideal.IsPrime.mem_compl_of_not_mem
theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I 
Arguments: {P : Type u_1} [BooleanAlgebra P] {x : P} {I : Order.Ideal P} (hI : I.IsPrime) (hxnI : x ∉ I)
Goal: xᶜ ∈ I
-- Order.Ideal.isPrime_of_mem_or_compl_mem
theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I 
Arguments: {P : Type u_1} [BooleanAlgebra P] {I : Order.Ideal P} [I.IsProper] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I)
Goal: I.IsPrime
-- Order.Ideal.isPrime_iff_mem_or_compl_mem
theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I 
Arguments: {P : Type u_1} [BooleanAlgebra P] {I : Order.Ideal P} [I.IsProper]
Goal: I.IsPrime ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I
-- Order.PFilter.isPrime_iff
@[mk_iff]
class IsPrime (F : PFilter P) : Prop where
  compl_ideal : IsIdeal (F : Set P)ᶜ
Arguments: {P : Type u_1} [Preorder P] (F : Order.PFilter P)
Goal: F.IsPrime ↔ Order.IsIdeal (↑F)ᶜ
-- Order.PFilter.IsPrime.compl_ideal
@[mk_iff]
class IsPrime (F : PFilter P) : Prop where
  compl_ideal : IsIdeal (F : Set P)ᶜ
Arguments: {P : Type u_1} [Preorder P] {F : Order.PFilter P} [self : F.IsPrime]
Goal: Order.IsIdeal (↑F)ᶜ
-- Order.Ideal.PrimePair.F_isPrime
theorem _root_.Order.Ideal.PrimePair.F_isPrime (IF : Ideal.PrimePair P) : IsPrime IF.F 
Arguments: {P : Type u_1} [Preorder P] (IF : Order.Ideal.PrimePair P)
Goal: IF.F.IsPrime
-- Preorder.le_refl
class Preorder (α : Type u) extends LE α, LT α where
  le_refl : ∀ a : α, a ≤ a
  le_trans : ∀ a b c : α, a ≤ b → b ≤ c → a ≤ c
  lt := fun a b => a ≤ b ∧ ¬b ≤ a
  lt_iff_le_not_le : ∀ a b : α, a < b ↔ a ≤ b ∧ ¬b ≤ a := by intros; rfl
Arguments: {α : Type u} [self : Preorder α] (a : α)
Goal: a ≤ a
-- Preorder.lt_iff_le_not_le
class Preorder (α : Type u) extends LE α, LT α where
  le_refl : ∀ a : α, a ≤ a
  le_trans : ∀ a b c : α, a ≤ b → b ≤ c → a ≤ c
  lt := fun a b => a ≤ b ∧ ¬b ≤ a
  lt_iff_le_not_le : ∀ a b : α, a < b ↔ a ≤ b ∧ ¬b ≤ a := by intros; rfl
Arguments: {α : Type u} [self : Preorder α] (a b : α)
Goal: a < b ↔ a ≤ b ∧ ¬b ≤ a
-- Preorder.le_trans
class Preorder (α : Type u) extends LE α, LT α where
  le_refl : ∀ a : α, a ≤ a
  le_trans : ∀ a b c : α, a ≤ b → b ≤ c → a ≤ c
  lt := fun a b => a ≤ b ∧ ¬b ≤ a
  lt_iff_le_not_le : ∀ a b : α, a < b ↔ a ≤ b ∧ ¬b ≤ a := by intros; rfl
Arguments: {α : Type u} [self : Preorder α] (a b c : α)
Goal: a ≤ b → b ≤ c → a ≤ c
-- le_refl
@[refl]
theorem le_refl : ∀ a : α, a ≤ a 
Arguments: {α : Type u} [Preorder α] (a : α)
Goal: a ≤ a
-- le_rfl
theorem le_rfl {a : α} : a ≤ a 
Arguments: {α : Type u} [Preorder α] {a : α}
Goal: a ≤ a
-- le_trans
@[trans]
theorem le_trans : ∀ {a b c : α}, a ≤ b → b ≤ c → a ≤ c 
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a ≤ b → b ≤ c → a ≤ c
-- lt_iff_le_not_le
theorem lt_iff_le_not_le : ∀ {a b : α}, a < b ↔ a ≤ b ∧ ¬b ≤ a 
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a < b ↔ a ≤ b ∧ ¬b ≤ a
-- lt_of_le_not_le
theorem lt_of_le_not_le : ∀ {a b : α}, a ≤ b → ¬b ≤ a → a < b
  
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a ≤ b → ¬b ≤ a → a < b
-- le_not_le_of_lt
theorem le_not_le_of_lt : ∀ {a b : α}, a < b → a ≤ b ∧ ¬b ≤ a
  
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a < b → a ≤ b ∧ ¬b ≤ a
-- le_of_eq
theorem le_of_eq {a b : α} : a = b → a ≤ b 
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a = b → a ≤ b
-- ge_trans
@[trans]
theorem ge_trans : ∀ {a b c : α}, a ≥ b → b ≥ c → a ≥ c 
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a ≥ b → b ≥ c → a ≥ c
-- lt_irrefl
theorem lt_irrefl : ∀ a : α, ¬a < a
  
Arguments: {α : Type u} [Preorder α] (a : α)
Goal: ¬a < a
-- gt_irrefl
theorem gt_irrefl : ∀ a : α, ¬a > a 
Arguments: {α : Type u} [Preorder α] (a : α)
Goal: ¬a > a
-- lt_trans
@[trans]
theorem lt_trans : ∀ {a b c : α}, a < b → b < c → a < c
  
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a < b → b < c → a < c
-- gt_trans
@[trans]
theorem gt_trans : ∀ {a b c : α}, a > b → b > c → a > c 
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a > b → b > c → a > c
-- ne_of_lt
theorem ne_of_lt {a b : α} (h : a < b) : a ≠ b 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : a < b)
Goal: a ≠ b
-- ne_of_gt
theorem ne_of_gt {a b : α} (h : b < a) : a ≠ b 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : b < a)
Goal: a ≠ b
-- lt_asymm
theorem lt_asymm {a b : α} (h : a < b) : ¬b < a 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : a < b)
Goal: ¬b < a
-- le_of_lt
theorem le_of_lt : ∀ {a b : α}, a < b → a ≤ b
  
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a < b → a ≤ b
-- lt_of_lt_of_le
@[trans]
theorem lt_of_lt_of_le : ∀ {a b c : α}, a < b → b ≤ c → a < c
  
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a < b → b ≤ c → a < c
-- lt_of_le_of_lt
@[trans]
theorem lt_of_le_of_lt : ∀ {a b c : α}, a ≤ b → b < c → a < c
  
Arguments: {α : Type u} [Preorder α] {a b c : α}
Goal: a ≤ b → b < c → a < c
-- gt_of_gt_of_ge
@[trans]
theorem gt_of_gt_of_ge {a b c : α} (h₁ : a > b) (h₂ : b ≥ c) : a > c 
Arguments: {α : Type u} [Preorder α] {a b c : α} (h₁ : a > b) (h₂ : b ≥ c)
Goal: a > c
-- gt_of_ge_of_gt
@[trans]
theorem gt_of_ge_of_gt {a b c : α} (h₁ : a ≥ b) (h₂ : b > c) : a > c 
Arguments: {α : Type u} [Preorder α] {a b c : α} (h₁ : a ≥ b) (h₂ : b > c)
Goal: a > c
-- not_le_of_gt
theorem not_le_of_gt {a b : α} (h : a > b) : ¬a ≤ b 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : a > b)
Goal: ¬a ≤ b
-- not_lt_of_ge
theorem not_lt_of_ge {a b : α} (h : a ≥ b) : ¬a < b 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : a ≥ b)
Goal: ¬a < b
-- le_of_lt_or_eq
theorem le_of_lt_or_eq : ∀ {a b : α}, a < b ∨ a = b → a ≤ b
  
Arguments: {α : Type u} [Preorder α] {a b : α}
Goal: a < b ∨ a = b → a ≤ b
-- le_of_eq_or_lt
theorem le_of_eq_or_lt {a b : α} (h : a = b ∨ a < b) : a ≤ b 
Arguments: {α : Type u} [Preorder α] {a b : α} (h : a = b ∨ a < b)
Goal: a ≤ b
-- PartialOrder.le_antisymm
class PartialOrder (α : Type u) extends Preorder α where
  le_antisymm : ∀ a b : α, a ≤ b → b ≤ a → a = b
Arguments: {α : Type u} [self : PartialOrder α] (a b : α)
Goal: a ≤ b → b ≤ a → a = b
-- le_antisymm
theorem le_antisymm : ∀ {a b : α}, a ≤ b → b ≤ a → a = b 
Arguments: {α : Type u} [PartialOrder α] {a b : α}
Goal: a ≤ b → b ≤ a → a = b
-- le_antisymm_iff
theorem le_antisymm_iff {a b : α} : a = b ↔ a ≤ b ∧ b ≤ a 
Arguments: {α : Type u} [PartialOrder α] {a b : α}
Goal: a = b ↔ a ≤ b ∧ b ≤ a
-- lt_of_le_of_ne
theorem lt_of_le_of_ne {a b : α} : a ≤ b → a ≠ b → a < b 
Arguments: {α : Type u} [PartialOrder α] {a b : α}
Goal: a ≤ b → a ≠ b → a < b
-- Decidable.lt_or_eq_of_le
theorem lt_or_eq_of_le {a b : α} (hab : a ≤ b) : a < b ∨ a = b 
Arguments: {α : Type u} [PartialOrder α] [DecidableRel fun x x_1 => x ≤ x_1] {a b : α} (hab : a ≤ b)
Goal: a < b ∨ a = b
-- Decidable.eq_or_lt_of_le
theorem eq_or_lt_of_le {a b : α} (hab : a ≤ b) : a = b ∨ a < b 
Arguments: {α : Type u} [PartialOrder α] [DecidableRel fun x x_1 => x ≤ x_1] {a b : α} (hab : a ≤ b)
Goal: a = b ∨ a < b
-- Decidable.le_iff_lt_or_eq
theorem le_iff_lt_or_eq {a b : α} : a ≤ b ↔ a < b ∨ a = b 
Arguments: {α : Type u} [PartialOrder α] [DecidableRel fun x x_1 => x ≤ x_1] {a b : α}
Goal: a ≤ b ↔ a < b ∨ a = b
-- lt_or_eq_of_le
theorem lt_or_eq_of_le {a b : α} : a ≤ b → a < b ∨ a = b 
Arguments: {α : Type u} [PartialOrder α] {a b : α}
Goal: a ≤ b → a < b ∨ a = b
-- le_iff_lt_or_eq
theorem le_iff_lt_or_eq {a b : α} : a ≤ b ↔ a < b ∨ a = b 
Arguments: {α : Type u} [PartialOrder α] {a b : α}
Goal: a ≤ b ↔ a < b ∨ a = b