fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
WellFoundedGT.monotone_chain_condition [PartialOrder α] [h : WellFoundedGT α] (a : ℕ →o α) :
∃ n, ∀ m, n ≤ m → a n = a m :=
wellFoundedGT_iff_monotone_chain_condition.1 h a | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | WellFoundedGT.monotone_chain_condition | null |
noncomputable monotonicSequenceLimitIndex [Preorder α] (a : ℕ →o α) : ℕ :=
sInf { n | ∀ m, n ≤ m → a n = a m } | def | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | monotonicSequenceLimitIndex | Given an eventually-constant monotone sequence `a₀ ≤ a₁ ≤ a₂ ≤ ...` in a partially-ordered
type, `monotonicSequenceLimitIndex a` is the least natural number `n` for which `aₙ` reaches the
constant value. For sequences that are not eventually constant, `monotonicSequenceLimitIndex a`
is defined, but is a junk value. |
noncomputable monotonicSequenceLimit [Preorder α] (a : ℕ →o α) :=
a (monotonicSequenceLimitIndex a) | def | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | monotonicSequenceLimit | The constant value of an eventually-constant monotone sequence `a₀ ≤ a₁ ≤ a₂ ≤ ...` in a
partially-ordered type. |
le_monotonicSequenceLimit [PartialOrder α] [WellFoundedGT α] (a : ℕ →o α) (m : ℕ) :
a m ≤ monotonicSequenceLimit a := by
rcases le_or_gt m (monotonicSequenceLimitIndex a) with hm | hm
· exact a.monotone hm
· obtain h := WellFoundedGT.monotone_chain_condition a
exact (Nat.sInf_mem (s := {n | ∀ m, n ≤ m → a... | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | le_monotonicSequenceLimit | null |
WellFoundedGT.iSup_eq_monotonicSequenceLimit [CompleteLattice α]
[WellFoundedGT α] (a : ℕ →o α) : iSup a = monotonicSequenceLimit a :=
(iSup_le (le_monotonicSequenceLimit a)).antisymm (le_iSup a _) | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | WellFoundedGT.iSup_eq_monotonicSequenceLimit | null |
WellFoundedGT.ciSup_eq_monotonicSequenceLimit [ConditionallyCompleteLattice α]
[WellFoundedGT α] (a : ℕ →o α) (ha : BddAbove (Set.range a)) :
iSup a = monotonicSequenceLimit a :=
(ciSup_le (le_monotonicSequenceLimit a)).antisymm (le_ciSup ha _) | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | WellFoundedGT.ciSup_eq_monotonicSequenceLimit | null |
exists_covBy_seq_of_wellFoundedLT_wellFoundedGT (α) [Preorder α]
[Nonempty α] [wfl : WellFoundedLT α] [wfg : WellFoundedGT α] :
∃ a : ℕ → α, IsMin (a 0) ∧ ∃ n, IsMax (a n) ∧ ∀ i < n, a i ⋖ a (i + 1) := by
choose next hnext using exists_covBy_of_wellFoundedLT (α := α)
have hα := Set.nonempty_iff_univ_nonempt... | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | exists_covBy_seq_of_wellFoundedLT_wellFoundedGT | null |
exists_covBy_seq_of_wellFoundedLT_wellFoundedGT_of_le {α : Type*} [PartialOrder α]
[wfl : WellFoundedLT α] [wfg : WellFoundedGT α] {x y : α} (h : x ≤ y) :
∃ a : ℕ → α, a 0 = x ∧ ∃ n, a n = y ∧ ∀ i < n, a i ⋖ a (i + 1) := by
let S := Set.Icc x y
let hS : BoundedOrder S :=
{ top := ⟨y, h, le_rfl⟩, le_top ... | theorem | Order | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Logic.Denumerable",
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Hom.Basic",
"Mathlib.Data.Set.Subsingleton"
] | Mathlib/Order/OrderIsoNat.lean | exists_covBy_seq_of_wellFoundedLT_wellFoundedGT_of_le | null |
Monotone.partBind (hf : Monotone f) (hg : Monotone g) :
Monotone fun x ↦ (f x).bind (g x) := by
rintro x y h a
simp only [and_imp, Part.mem_bind_iff, exists_imp]
exact fun b hb ha ↦ ⟨b, hf h _ hb, hg h _ _ ha⟩ | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Monotone.partBind | null |
Antitone.partBind (hf : Antitone f) (hg : Antitone g) :
Antitone fun x ↦ (f x).bind (g x) := by
rintro x y h a
simp only [and_imp, Part.mem_bind_iff, exists_imp]
exact fun b hb ha ↦ ⟨b, hf h _ hb, hg h _ _ ha⟩ | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Antitone.partBind | null |
Monotone.partMap (hg : Monotone g) : Monotone fun x ↦ (g x).map f := by
simpa only [← bind_some_eq_map] using hg.partBind monotone_const | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Monotone.partMap | null |
Antitone.partMap (hg : Antitone g) : Antitone fun x ↦ (g x).map f := by
simpa only [← bind_some_eq_map] using hg.partBind antitone_const | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Antitone.partMap | null |
Monotone.partSeq (hf : Monotone f) (hg : Monotone g) : Monotone fun x ↦ f x <*> g x := by
simpa only [seq_eq_bind_map] using hf.partBind <| Monotone.of_apply₂ fun _ ↦ hg.partMap | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Monotone.partSeq | null |
Antitone.partSeq (hf : Antitone f) (hg : Antitone g) : Antitone fun x ↦ f x <*> g x := by
simpa only [seq_eq_bind_map] using hf.partBind <| Antitone.of_apply₂ fun _ ↦ hg.partMap | lemma | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | Antitone.partSeq | null |
@[simps]
partBind (f : α →o Part β) (g : α →o β → Part γ) : α →o Part γ where
toFun x := (f x).bind (g x)
monotone' := f.2.partBind g.2 | def | Order | [
"Mathlib.Data.Part",
"Mathlib.Order.Hom.Basic",
"Mathlib.Tactic.Common"
] | Mathlib/Order/Part.lean | partBind | `Part.bind` as a monotone function |
partialSups (f : ι → α) : ι →o α where
toFun i := (Iic i).sup' nonempty_Iic f
monotone' _ _ hmn := sup'_mono f (Iic_subset_Iic.mpr hmn) nonempty_Iic | def | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups | The monotone sequence whose value at `i` is the supremum of the `f j` where `j ≤ i`. |
partialSups_apply (f : ι → α) (i : ι) :
partialSups f i = (Iic i).sup' nonempty_Iic f :=
rfl | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_apply | null |
partialSups_iff_forall {f : ι → α} (p : α → Prop)
(hp : ∀ {a b}, p (a ⊔ b) ↔ p a ∧ p b) {i : ι} :
p (partialSups f i) ↔ ∀ j ≤ i, p (f j) := by
classical
rw [partialSups_apply, comp_sup'_eq_sup'_comp (γ := Propᵒᵈ) _ p, sup'_eq_sup]
· change (Iic i).inf (p ∘ f) ↔ _
simp [Finset.inf_eq_iInf]
· intro x ... | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_iff_forall | null |
partialSups_le_iff {f : ι → α} {i : ι} {a : α} :
partialSups f i ≤ a ↔ ∀ j ≤ i, f j ≤ a :=
partialSups_iff_forall (· ≤ a) sup_le_iff | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_le_iff | null |
le_partialSups_of_le (f : ι → α) {i j : ι} (h : i ≤ j) :
f i ≤ partialSups f j :=
partialSups_le_iff.1 le_rfl i h | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | le_partialSups_of_le | null |
le_partialSups (f : ι → α) :
f ≤ partialSups f :=
fun _ => le_partialSups_of_le f le_rfl | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | le_partialSups | null |
partialSups_le (f : ι → α) (i : ι) (a : α) (w : ∀ j ≤ i, f j ≤ a) :
partialSups f i ≤ a :=
partialSups_le_iff.2 w
@[simp] | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_le | null |
upperBounds_range_partialSups (f : ι → α) :
upperBounds (Set.range (partialSups f)) = upperBounds (Set.range f) := by
ext a
simp only [mem_upperBounds, Set.forall_mem_range, partialSups_le_iff]
exact ⟨fun h _ ↦ h _ _ le_rfl, fun h _ _ _ ↦ h _⟩
@[simp] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | upperBounds_range_partialSups | null |
bddAbove_range_partialSups {f : ι → α} :
BddAbove (Set.range (partialSups f)) ↔ BddAbove (Set.range f) :=
.of_eq <| congr_arg Set.Nonempty <| upperBounds_range_partialSups f | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | bddAbove_range_partialSups | null |
Monotone.partialSups_eq {f : ι → α} (hf : Monotone f) :
partialSups f = f :=
funext fun i ↦ le_antisymm (partialSups_le _ _ _ (@hf · i)) (le_partialSups _ _) | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | Monotone.partialSups_eq | null |
partialSups_mono :
Monotone (partialSups : (ι → α) → ι →o α) :=
fun _ _ h _ ↦ partialSups_le_iff.2 fun j hj ↦ (h j).trans (le_partialSups_of_le _ hj) | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_mono | null |
partialSups_monotone (f : ι → α) :
Monotone (partialSups f) :=
fun i _ hnm ↦ partialSups_le f i _ (fun _ hm'n ↦ le_partialSups_of_le _ (hm'n.trans hnm)) | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_monotone | null |
partialSups.gi :
GaloisInsertion (partialSups : (ι → α) → ι →o α) (↑) where
choice f h :=
⟨f, by convert (partialSups f).monotone using 1; exact (le_partialSups f).antisymm h⟩
gc f g := by
refine ⟨(le_partialSups f).trans, fun h ↦ ?_⟩
convert partialSups_mono h
exact OrderHom.ext _ _ g.monotone.... | def | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups.gi | `partialSups` forms a Galois insertion with the coercion from monotone functions to functions. |
protected Pi.partialSups_apply {τ : Type*} {π : τ → Type*} [∀ t, SemilatticeSup (π t)]
(f : ι → (t : τ) → π t) (i : ι) (t : τ) :
partialSups f i t = partialSups (f · t) i := by
simp only [partialSups_apply, Finset.sup'_apply] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | Pi.partialSups_apply | null |
comp_partialSups {F : Type*} [FunLike F α β] [SupHomClass F α β] (f : ι → α) (g : F) :
partialSups (g ∘ f) = g ∘ partialSups f := by
funext _; simp [partialSups] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | comp_partialSups | null |
map_partialSups {F : Type*} [FunLike F α β] [SupHomClass F α β] (f : F) (g : ι → α) (i : ι) :
partialSups (fun j ↦ f (g j)) i = f (partialSups g i) := congr($(comp_partialSups ..) i) | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | map_partialSups | null |
@[simp]
partialSups_succ [LinearOrder ι] [LocallyFiniteOrderBot ι] [SuccOrder ι]
(f : ι → α) (i : ι) :
partialSups f (Order.succ i) = partialSups f i ⊔ f (Order.succ i) := by
suffices Iic (Order.succ i) = Iic i ∪ {Order.succ i} by simp only [partialSups_apply, this,
sup'_union nonempty_Iic ⟨_, mem_singlet... | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_succ | null |
partialSups_bot [PartialOrder ι] [LocallyFiniteOrder ι] [OrderBot ι]
(f : ι → α) : partialSups f ⊥ = f ⊥ := by
simp only [partialSups_apply]
suffices Iic (⊥ : ι) = {⊥} by simp only [this, sup'_singleton]
simp only [← coe_eq_singleton, coe_Iic, Set.Iic_bot]
/-! | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_bot | null |
@[simp]
partialSups_zero (f : ℕ → α) : partialSups f 0 = f 0 :=
partialSups_bot f | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_zero | null |
partialSups_eq_sup'_range (f : ℕ → α) (n : ℕ) :
partialSups f n = (Finset.range (n + 1)).sup' nonempty_range_add_one f :=
eq_of_forall_ge_iff fun _ ↦ by simp [Nat.lt_succ_iff] | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_sup'_range | null |
partialSups_eq_sup_range [OrderBot α] (f : ℕ → α) (n : ℕ) :
partialSups f n = (Finset.range (n + 1)).sup f :=
eq_of_forall_ge_iff fun _ ↦ by simp [Nat.lt_succ_iff] | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_sup_range | null |
@[simp]
disjoint_partialSups_left {f : ι → α} {i : ι} {x : α} :
Disjoint (partialSups f i) x ↔ ∀ j ≤ i, Disjoint (f j) x :=
partialSups_iff_forall (Disjoint · x) disjoint_sup_left
@[simp] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | disjoint_partialSups_left | null |
disjoint_partialSups_right {f : ι → α} {i : ι} {x : α} :
Disjoint x (partialSups f i) ↔ ∀ j ≤ i, Disjoint x (f j) :=
partialSups_iff_forall (Disjoint x) disjoint_sup_right
open scoped Function in -- required for scoped `on` notation
/- Note this lemma requires a distributive lattice, so is not useful (or true) in... | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | disjoint_partialSups_right | null |
partialSups_disjoint_of_disjoint (f : ι → α) (h : Pairwise (Disjoint on f))
{i j : ι} (hij : i < j) :
Disjoint (partialSups f i) (f j) :=
disjoint_partialSups_left.2 fun _ hk ↦ h (hk.trans_lt hij).ne | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_disjoint_of_disjoint | null |
partialSups_eq_ciSup_Iic [ConditionallyCompleteLattice α] (f : ι → α) (i : ι) :
partialSups f i = ⨆ i : Set.Iic i, f i := by
simp only [partialSups_apply]
apply le_antisymm
· exact sup'_le _ _ fun j hj ↦ le_ciSup_of_le (Set.finite_range _).bddAbove
⟨j, by simpa only [Set.mem_Iic, mem_Iic] using hj⟩ le_r... | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_ciSup_Iic | null |
ciSup_partialSups_eq [ConditionallyCompleteLattice α]
{f : ι → α} (h : BddAbove (Set.range f)) :
⨆ i, partialSups f i = ⨆ i, f i := by
by_cases hι : Nonempty ι
· refine (ciSup_le fun i ↦ ?_).antisymm (ciSup_mono ?_ <| le_partialSups f)
· simpa only [partialSups_eq_ciSup_Iic] using ciSup_le fun i ↦ le_ci... | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | ciSup_partialSups_eq | null |
@[simp]
ciSup_partialSups_eq' [ConditionallyCompleteLinearOrder α] (f : ι → α) :
⨆ i, partialSups f i = ⨆ i, f i := by
by_cases h : BddAbove (Set.range f)
· exact ciSup_partialSups_eq h
· rw [iSup, iSup, ConditionallyCompleteLinearOrder.csSup_of_not_bddAbove _ h,
ConditionallyCompleteLinearOrder.csSup_o... | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | ciSup_partialSups_eq' | Version of `ciSup_partialSups_eq` without boundedness assumptions, but requiring a
`ConditionallyCompleteLinearOrder` rather than just a `ConditionallyCompleteLattice`. |
iSup_partialSups_eq (f : ι → α) :
⨆ i, partialSups f i = ⨆ i, f i :=
ciSup_partialSups_eq <| OrderTop.bddAbove _ | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | iSup_partialSups_eq | Version of `ciSup_partialSups_eq` without boundedness assumptions, but requiring a
`CompleteLattice` rather than just a `ConditionallyCompleteLattice`. |
partialSups_eq_biSup (f : ι → α) (i : ι) :
partialSups f i = ⨆ j ≤ i, f j := by
simpa only [iSup_subtype] using partialSups_eq_ciSup_Iic f i | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_biSup | null |
iSup_le_iSup_of_partialSups_le_partialSups {f g : ι → α}
(h : partialSups f ≤ partialSups g) : ⨆ i, f i ≤ ⨆ i, g i := by
rw [← iSup_partialSups_eq f, ← iSup_partialSups_eq g]
exact iSup_mono h | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | iSup_le_iSup_of_partialSups_le_partialSups | null |
iSup_eq_iSup_of_partialSups_eq_partialSups {f g : ι → α}
(h : partialSups f = partialSups g) : ⨆ i, f i = ⨆ i, g i := by
simp_rw [← iSup_partialSups_eq f, ← iSup_partialSups_eq g, h] | theorem | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | iSup_eq_iSup_of_partialSups_eq_partialSups | null |
partialSups_eq_sUnion_image [DecidableEq (Set α)] (s : ℕ → Set α) (n : ℕ) :
partialSups s n = ⋃₀ ↑((Finset.range (n + 1)).image s) := by
simp [partialSups_eq_biSup, Nat.lt_succ_iff] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_sUnion_image | null |
partialSups_eq_biUnion_range (s : ℕ → Set α) (n : ℕ) :
partialSups s n = ⋃ i ∈ Finset.range (n + 1), s i := by
simp [partialSups_eq_biSup, Nat.lt_succ] | lemma | Order | [
"Mathlib.Data.Set.Finite.Lattice",
"Mathlib.Order.ConditionallyCompleteLattice.Indexed",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Order.SuccPred.Basic"
] | Mathlib/Order/PartialSups.lean | partialSups_eq_biUnion_range | null |
PFilter (P : Type*) [Preorder P] where
dual : Ideal Pᵒᵈ
variable {P : Type*} | structure | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | PFilter | A filter on a preorder `P` is a subset of `P` that is
- nonempty
- downward directed
- upward closed. |
IsPFilter [Preorder P] (F : Set P) : Prop :=
IsIdeal (OrderDual.ofDual ⁻¹' F) | def | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | IsPFilter | A predicate for when a subset of `P` is a filter. |
IsPFilter.of_def [Preorder P] {F : Set P} (nonempty : F.Nonempty)
(directed : DirectedOn (· ≥ ·) F) (mem_of_le : ∀ {x y : P}, x ≤ y → x ∈ F → y ∈ F) :
IsPFilter F :=
⟨fun _ _ _ _ => mem_of_le ‹_› ‹_›, nonempty, directed⟩ | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | IsPFilter.of_def | null |
IsPFilter.toPFilter [Preorder P] {F : Set P} (h : IsPFilter F) : PFilter P :=
⟨h.toIdeal⟩ | def | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | IsPFilter.toPFilter | Create an element of type `Order.PFilter` from a set satisfying the predicate
`Order.IsPFilter`. |
@[ext]
ext (h : (s : Set P) = t) : s = t := SetLike.ext' h
@[trans] | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | ext | A filter on `P` is a subset of `P`. -/
instance : SetLike (PFilter P) P where
coe F := toDual ⁻¹' F.dual.carrier
coe_injective' := fun ⟨_⟩ ⟨_⟩ h => congr_arg mk <| Ideal.ext h
theorem isPFilter : IsPFilter (F : Set P) := F.dual.isIdeal
protected theorem nonempty : (F : Set P).Nonempty := F.dual.nonempty
theorem ... |
mem_of_mem_of_le {F G : PFilter P} (hx : x ∈ F) (hle : F ≤ G) : x ∈ G :=
hle hx | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | mem_of_mem_of_le | null |
principal (p : P) : PFilter P :=
⟨Ideal.principal (toDual p)⟩
@[simp] | def | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | principal | The smallest filter containing a given element. |
mem_mk (x : P) (I : Ideal Pᵒᵈ) : x ∈ (⟨I⟩ : PFilter P) ↔ toDual x ∈ I :=
Iff.rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | mem_mk | null |
principal_le_iff {F : PFilter P} : principal x ≤ F ↔ x ∈ F :=
Ideal.principal_le_iff (x := toDual x)
@[simp] theorem mem_principal : x ∈ principal y ↔ y ≤ x := Iff.rfl | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | principal_le_iff | null |
principal_le_principal_iff {p q : P} : principal q ≤ principal p ↔ p ≤ q := by simp | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | principal_le_principal_iff | null |
antitone_principal : Antitone (principal : P → PFilter P) := fun _ _ =>
principal_le_principal_iff.2 | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | antitone_principal | null |
@[simp] top_mem : ⊤ ∈ F := Ideal.bot_mem _ | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | top_mem | A specific witness of `pfilter.nonempty` when `P` has a top element. |
inf_mem (hx : x ∈ F) (hy : y ∈ F) : x ⊓ y ∈ F :=
Ideal.sup_mem hx hy
@[simp] | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | inf_mem | There is a bottom filter when `P` has a top element. -/
instance : OrderBot (PFilter P) where
bot := ⟨⊥⟩
bot_le F := (bot_le : ⊥ ≤ F.dual)
end OrderTop
/-- There is a top filter when `P` has a bottom element. -/
instance {P} [Preorder P] [OrderBot P] : OrderTop (PFilter P) where
top := ⟨⊤⟩
le_top F := (le_top... |
inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F :=
Ideal.sup_mem_iff | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | inf_mem_iff | null |
sInf_gc :
GaloisConnection (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) :=
fun x F => by simp only [le_sInf_iff, SetLike.mem_coe, toDual_le, SetLike.le_def, mem_principal] | theorem | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | sInf_gc | null |
infGi :
GaloisCoinsertion (fun x => toDual (principal x)) fun F => sInf (ofDual F : PFilter P) :=
sInf_gc.toGaloisCoinsertion fun _ => sInf_le <| mem_principal.2 le_rfl | def | Order | [
"Mathlib.Order.Ideal"
] | Mathlib/Order/PFilter.lean | infGi | If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. |
protected Lex (x y : ∀ i, β i) : Prop :=
∃ i, (∀ j, r j i → x j = y j) ∧ s (x i) (y i)
/- This unfortunately results in a type that isn't delta-reduced, so we keep the notation out of the
basic API, just in case -/ | def | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | Lex | The lexicographic relation on `Π i : ι, β i`, where `ι` is ordered by `r`,
and each `β i` is ordered by `s`.
The `<` relation on `Lex (∀ i, β i)` is `Pi.Lex (· < ·) (· < ·)`, while the `<` relation on
`Colex (∀ i, β i)` is `Pi.Lex (· > ·) (· < ·)`. |
noncomputable Lex.linearOrder [LinearOrder ι] [WellFoundedLT ι]
[∀ a, LinearOrder (β a)] : LinearOrder (Lex (∀ i, β i)) :=
@linearOrderOfSTO (Πₗ i, β i) (· < ·)
{ trichotomous := (isTrichotomous_lex _ _ IsWellFounded.wf).1 } (Classical.decRel _) | instance | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | Lex.linearOrder | The notation `Πₗ i, α i` refers to a pi type equipped with the lexicographic order. -/
notation3 (prettyPrint := false) "Πₗ "(...)", "r:(scoped p => Lex (∀ i, p i)) => r
@[simp]
theorem toLex_apply (x : ∀ i, β i) (i : ι) : toLex x i = x i :=
rfl
@[simp]
theorem ofLex_apply (x : Lex (∀ i, β i)) (i : ι) : ofLex x i =... |
noncomputable Colex.linearOrder [LinearOrder ι] [WellFoundedGT ι]
[∀ a, LinearOrder (β a)] : LinearOrder (Colex (∀ i, β i)) :=
Lex.linearOrder (ι := ιᵒᵈ) | instance | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | Colex.linearOrder | `Colex (∀ i, α i)` is a linear order if the original order has well-founded `>`. |
toLex_monotone : Monotone (@toLex (∀ i, β i)) := fun a b h =>
or_iff_not_imp_left.2 fun hne =>
let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < ·)) { i | a i ≠ b i }
(Function.ne_iff.1 hne)
⟨i, fun j hj => by
contrapose! hl
exact ⟨j, hl, hj⟩, (h i).lt_of_ne hi⟩ | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toLex_monotone | null |
toLex_strictMono : StrictMono (@toLex (∀ i, β i)) := fun a b h =>
let ⟨i, hi, hl⟩ := IsWellFounded.wf.has_min (r := (· < ·)) { i | a i ≠ b i }
(Function.ne_iff.1 h.ne)
⟨i, fun j hj => by
contrapose! hl
exact ⟨j, hl, hj⟩, (h.le i).lt_of_ne hi⟩
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toLex_strictMono | null |
lt_toLex_update_self_iff : toLex x < toLex (update x i a) ↔ x i < a := by
refine ⟨?_, fun h => toLex_strictMono <| lt_update_self_iff.2 h⟩
rintro ⟨j, hj, h⟩
dsimp at h
obtain rfl : j = i := by
by_contra H
rw [update_of_ne H] at h
exact h.false
rwa [update_self] at h
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | lt_toLex_update_self_iff | null |
toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i := by
refine ⟨?_, fun h => toLex_strictMono <| update_lt_self_iff.2 h⟩
rintro ⟨j, hj, h⟩
dsimp at h
obtain rfl : j = i := by
by_contra H
rw [update_of_ne H] at h
exact h.false
rwa [update_self] at h
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toLex_update_lt_self_iff | null |
le_toLex_update_self_iff : toLex x ≤ toLex (update x i a) ↔ x i ≤ a := by
simp_rw [le_iff_lt_or_eq, lt_toLex_update_self_iff, toLex_inj, eq_update_self_iff]
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | le_toLex_update_self_iff | null |
toLex_update_le_self_iff : toLex (update x i a) ≤ toLex x ↔ a ≤ x i := by
simp_rw [le_iff_lt_or_eq, toLex_update_lt_self_iff, toLex_inj, update_eq_self_iff] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toLex_update_le_self_iff | null |
toColex_monotone : Monotone (@toColex (∀ i, β i)) :=
toLex_monotone (ι := ιᵒᵈ) | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toColex_monotone | null |
toColex_strictMono : StrictMono (@toColex (∀ i, β i)) :=
toLex_strictMono (ι := ιᵒᵈ)
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toColex_strictMono | null |
lt_toColex_update_self_iff : toColex x < toColex (update x i a) ↔ x i < a :=
lt_toLex_update_self_iff (ι := ιᵒᵈ)
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | lt_toColex_update_self_iff | null |
toColex_update_lt_self_iff : toColex (update x i a) < toColex x ↔ a < x i :=
toLex_update_lt_self_iff (ι := ιᵒᵈ)
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toColex_update_lt_self_iff | null |
le_toColex_update_self_iff : toColex x ≤ toColex (update x i a) ↔ x i ≤ a :=
le_toLex_update_self_iff (ι := ιᵒᵈ)
@[simp] | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | le_toColex_update_self_iff | null |
toColex_update_le_self_iff : toColex (update x i a) ≤ toColex x ↔ a ≤ x i :=
toLex_update_le_self_iff (ι := ιᵒᵈ) | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | toColex_update_le_self_iff | null |
Lex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
NoMaxOrder (Lex (∀ i, β i)) :=
⟨fun a => by
let ⟨b, hb⟩ := exists_gt (a i)
classical
exact ⟨Function.update a i b, i, fun j hj =>
(Function.update_of_ne hj.ne b a).symm, by rwa [Function.update_self i b]⟩⟩ | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | Lex.noMaxOrder' | null |
Colex.noMaxOrder' [Preorder ι] [∀ i, LT (β i)] (i : ι) [NoMaxOrder (β i)] :
NoMaxOrder (Colex (∀ i, β i)) :=
Lex.noMaxOrder' (ι := ιᵒᵈ) i | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | Colex.noMaxOrder' | null |
lex_desc {α} [Preorder ι] [DecidableEq ι] [LT α] {f : ι → α} {i j : ι} (h₁ : i ≤ j)
(h₂ : f j < f i) : toLex (f ∘ Equiv.swap i j) < toLex f :=
⟨i, fun _ hik => congr_arg f (Equiv.swap_apply_of_ne_of_ne hik.ne (hik.trans_le h₁).ne), by
simpa only [Pi.toLex_apply, Function.comp_apply, Equiv.swap_apply_left] usi... | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | lex_desc | If we swap two strictly decreasing values in a function, then the result is lexicographically
smaller than the original function. |
colex_asc {α} [Preorder ι] [DecidableEq ι] [LT α] {f : ι → α} {i j : ι} (h₁ : i ≤ j)
(h₂ : f i < f j) : toColex (f ∘ Equiv.swap i j) < toColex f := by
rw [Equiv.swap_comm]
exact lex_desc (ι := ιᵒᵈ) h₁ h₂ | theorem | Order | [
"Mathlib.Order.WellFounded",
"Mathlib.Tactic.Common"
] | Mathlib/Order/PiLex.lean | colex_asc | If we swap two strictly increasing values in a function, then the result is colexicographically
smaller than the original function. |
PrimePair (P : Type*) [Preorder P] where
I : Ideal P
F : PFilter P
isCompl_I_F : IsCompl (I : Set P) F | structure | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | PrimePair | A pair of an `Order.Ideal` and an `Order.PFilter` which form a partition of `P`. |
compl_I_eq_F : (IF.I : Set P)ᶜ = IF.F :=
IF.isCompl_I_F.compl_eq | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | compl_I_eq_F | null |
compl_F_eq_I : (IF.F : Set P)ᶜ = IF.I :=
IF.isCompl_I_F.eq_compl.symm | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | compl_F_eq_I | null |
I_isProper : IsProper IF.I := by
obtain ⟨w, h⟩ := IF.F.nonempty
apply isProper_of_notMem (_ : w ∉ IF.I)
rwa [← IF.compl_I_eq_F] at h | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | I_isProper | null |
protected disjoint : Disjoint (IF.I : Set P) IF.F :=
IF.isCompl_I_F.disjoint | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | disjoint | null |
I_union_F : (IF.I : Set P) ∪ IF.F = Set.univ :=
IF.isCompl_I_F.sup_eq_top | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | I_union_F | null |
F_union_I : (IF.F : Set P) ∪ IF.I = Set.univ :=
IF.isCompl_I_F.symm.sup_eq_top | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | F_union_I | null |
@[mk_iff]
IsPrime [Preorder P] (I : Ideal P) : Prop extends IsProper I where
compl_filter : IsPFilter (I : Set P)ᶜ | class | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime | An ideal `I` is prime if its complement is a filter. |
IsPrime.toPrimePair {I : Ideal P} (h : IsPrime I) : PrimePair P :=
{ I
F := h.compl_filter.toPFilter
isCompl_I_F := isCompl_compl } | def | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.toPrimePair | Create an element of type `Order.Ideal.PrimePair` from an ideal satisfying the predicate
`Order.Ideal.IsPrime`. |
PrimePair.I_isPrime (IF : PrimePair P) : IsPrime IF.I :=
{ IF.I_isProper with
compl_filter := by
rw [IF.compl_I_eq_F]
exact IF.F.isPFilter } | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | PrimePair.I_isPrime | null |
IsPrime.mem_or_mem (hI : IsPrime I) {x y : P} : x ⊓ y ∈ I → x ∈ I ∨ y ∈ I := by
contrapose!
let F := hI.compl_filter.toPFilter
change x ∈ F ∧ y ∈ F → x ⊓ y ∈ F
exact fun h => inf_mem h.1 h.2 | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.mem_or_mem | null |
IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
IsPrime I := by
rw [isPrime_iff]
use ‹_›
refine .of_def ?_ ?_ ?_
· exact Set.nonempty_compl.2 (I.isProper_iff.1 ‹_›)
· intro x hx y hy
exact ⟨x ⊓ y, fun h => (hI h).elim hx hy, inf_le_left, inf_le_right⟩
· exact @mem_... | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.of_mem_or_mem | null |
isPrime_iff_mem_or_mem [IsProper I] : IsPrime I ↔ ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I :=
⟨IsPrime.mem_or_mem, IsPrime.of_mem_or_mem⟩ | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | isPrime_iff_mem_or_mem | null |
IsPrime.mem_or_compl_mem (hI : IsPrime I) : x ∈ I ∨ xᶜ ∈ I := by
apply hI.mem_or_mem
rw [inf_compl_eq_bot]
exact I.bot_mem | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.mem_or_compl_mem | null |
IsPrime.compl_mem_of_notMem (hI : IsPrime I) (hxnI : x ∉ I) : xᶜ ∈ I :=
hI.mem_or_compl_mem.resolve_left hxnI
@[deprecated (since := "2025-05-23")]
alias IsPrime.mem_compl_of_not_mem := IsPrime.compl_mem_of_notMem | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.compl_mem_of_notMem | null |
isPrime_of_mem_or_compl_mem [IsProper I] (h : ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I) : IsPrime I := by
simp only [isPrime_iff_mem_or_mem, or_iff_not_imp_left]
intro x y hxy hxI
have hxcI : xᶜ ∈ I := h.resolve_left hxI
have ass : x ⊓ y ⊔ y ⊓ xᶜ ∈ I := sup_mem hxy (I.lower inf_le_right hxcI)
rwa [inf_comm, sup_inf_inf_comp... | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | isPrime_of_mem_or_compl_mem | null |
isPrime_iff_mem_or_compl_mem [IsProper I] : IsPrime I ↔ ∀ {x : P}, x ∈ I ∨ xᶜ ∈ I :=
⟨fun h _ => h.mem_or_compl_mem, isPrime_of_mem_or_compl_mem⟩ | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | isPrime_iff_mem_or_compl_mem | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.