File: Mathlib/Order/PrimeIdeal.lean

full_name: Order.Ideal.PrimePair.F
code: /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
-/
-- 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
goal: Order.PFilter P

full_name: Order.Ideal.PrimePair.isCompl_I_F
code: /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
-/
-- 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
goal: IsCompl ↑self.I ↑self.F

full_name: Order.Ideal.PrimePair.I
code: /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
-/
-- 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
goal: Order.Ideal P

full_name: Order.Ideal.PrimePair
code: /-- A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`.
-/
-- 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
goal: Type u_2

full_name: Order.Ideal.PrimePair.compl_I_eq_F
code: theorem compl_I_eq_F : (IF.I : Set P)ᶜ = IF.F 
goal: (↑IF.I)ᶜ = ↑IF.F

full_name: Order.Ideal.PrimePair.compl_F_eq_I
code: theorem compl_F_eq_I : (IF.F : Set P)ᶜ = IF.I 
goal: (↑IF.F)ᶜ = ↑IF.I

full_name: Order.Ideal.PrimePair.I_isProper
code: theorem I_isProper : IsProper IF.I 
goal: IF.I.IsProper

full_name: Order.Ideal.PrimePair.disjoint
code: protected theorem disjoint : Disjoint (IF.I : Set P) IF.F 
goal: Disjoint ↑IF.I ↑IF.F

full_name: Order.Ideal.PrimePair.I_union_F
code: theorem I_union_F : (IF.I : Set P) ∪ IF.F = Set.univ 
goal: ↑IF.I ∪ ↑IF.F = Set.univ

full_name: Order.Ideal.PrimePair.F_union_I
code: theorem F_union_I : (IF.F : Set P) ∪ IF.I = Set.univ 
goal: ↑IF.F ∪ ↑IF.I = Set.univ

full_name: Order.Ideal.IsPrime.compl_filter
code: /-- An ideal `I` is prime if its complement is a filter.
-/
@[mk_iff]
class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
  compl_filter : IsPFilter (I : Set P)ᶜ
goal: Order.IsPFilter (↑I)ᶜ

full_name: Order.Ideal.isPrime_iff
code: /-- An ideal `I` is prime if its complement is a filter.
-/
@[mk_iff]
class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
  compl_filter : IsPFilter (I : Set P)ᶜ
goal: I.IsPrime ↔ I.IsProper ∧ Order.IsPFilter (↑I)ᶜ

full_name: Order.Ideal.IsPrime
code: /-- An ideal `I` is prime if its complement is a filter.
-/
@[mk_iff]
class IsPrime [Preorder P] (I : Ideal P) extends IsProper I : Prop where
  compl_filter : IsPFilter (I : Set P)ᶜ
goal: Prop

full_name: Order.Ideal.IsPrime.toPrimePair
code: /-- Create an element of type `Order.Ideal.PrimePair` from an ideal satisfying the predicate
`Order.Ideal.IsPrime`. -/
def IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P 
goal: Order.Ideal.PrimePair P

full_name: Order.Ideal.PrimePair.I_isPrime
code: theorem PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.I 
goal: IF.I.IsPrime

full_name: Order.Ideal.IsPrime.mem_or_mem
code: theorem IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I 
goal: x ⊓ y ∈ I → x ∈ I ∨ y ∈ I

full_name: Order.Ideal.IsPrime.of_mem_or_mem
code: theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
    IsPrime I 
goal: I.IsPrime

full_name: Order.Ideal.isPrime_iff_mem_or_mem
code: theorem isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I 
goal: I.IsPrime ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I

full_name: Order.Ideal.IsMaximal.isPrime
code: instance (priority := 100) IsMaximal.isPrime [IsMaximal I] : IsPrime I 
goal: I.IsPrime

full_name: Order.Ideal.IsPrime.mem_or_compl_mem
code: theorem IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I 
goal: x ∈ I ∨ xᶜ ∈ I

full_name: Order.Ideal.IsPrime.mem_compl_of_not_mem
code: theorem IsPrime.mem_compl_of_not_mem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I 
goal: xᶜ ∈ I

full_name: Order.Ideal.isPrime_of_mem_or_compl_mem
code: theorem isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I 
goal: I.IsPrime

full_name: Order.Ideal.isPrime_iff_mem_or_compl_mem
code: theorem isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I 
goal: I.IsPrime ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I

full_name: Order.Ideal.IsPrime.isMaximal
code: instance (priority := 100) IsPrime.isMaximal [IsPrime I] : IsMaximal I 
goal: I.IsMaximal

full_name: Order.PFilter.isPrime_iff
code: /-- A filter `F` is prime if its complement is an ideal.
-/
@[mk_iff]
class IsPrime (F : PFilter P) : Prop where
  compl_ideal : IsIdeal (F : Set P)ᶜ
goal: F.IsPrime ↔ Order.IsIdeal (↑F)ᶜ

full_name: Order.PFilter.IsPrime.compl_ideal
code: /-- A filter `F` is prime if its complement is an ideal.
-/
@[mk_iff]
class IsPrime (F : PFilter P) : Prop where
  compl_ideal : IsIdeal (F : Set P)ᶜ
goal: Order.IsIdeal (↑F)ᶜ

full_name: Order.PFilter.IsPrime
code: /-- A filter `F` is prime if its complement is an ideal.
-/
@[mk_iff]
class IsPrime (F : PFilter P) : Prop where
  compl_ideal : IsIdeal (F : Set P)ᶜ
goal: Prop

full_name: Order.PFilter.IsPrime.toPrimePair
code: /-- Create an element of type `Order.Ideal.PrimePair` from a filter satisfying the predicate
`Order.PFilter.IsPrime`. -/
def IsPrime.toPrimePair {F : PFilter P} (h : IsPrime F) : Ideal.PrimePair P 
goal: Order.Ideal.PrimePair P

full_name: Order.Ideal.PrimePair.F_isPrime
code: theorem _root_.Order.Ideal.PrimePair.F_isPrime (IF : Ideal.PrimePair P) : IsPrime IF.F 
goal: IF.F.IsPrime