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 ⌀ |
|---|---|---|---|---|---|---|
Set.range_injOn_strictMono [WellFoundedLT β] :
Set.InjOn Set.range { f : β → γ | StrictMono f } := by
intro f hf g hg hfg
ext a
apply WellFoundedLT.induction a
intro a IH
obtain ⟨b, hb⟩ := hfg ▸ mem_range_self a
obtain h | rfl | h := lt_trichotomy b a
· rw [← IH b h] at hb
cases (hf.injective hb).... | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | Set.range_injOn_strictMono | null |
Set.range_injOn_strictAnti [WellFoundedGT β] :
Set.InjOn Set.range { f : β → γ | StrictAnti f } :=
fun _ hf _ hg ↦ Set.range_injOn_strictMono (β := βᵒᵈ) hf.dual hg.dual | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | Set.range_injOn_strictAnti | null |
StrictMono.range_inj [WellFoundedLT β] {f g : β → γ}
(hf : StrictMono f) (hg : StrictMono g) : Set.range f = Set.range g ↔ f = g :=
Set.range_injOn_strictMono.eq_iff hf hg | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.range_inj | null |
StrictAnti.range_inj [WellFoundedGT β] {f g : β → γ}
(hf : StrictAnti f) (hg : StrictAnti g) : Set.range f = Set.range g ↔ f = g :=
Set.range_injOn_strictAnti.eq_iff hf hg | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictAnti.range_inj | null |
StrictMono.id_le [WellFoundedLT β] {f : β → β} (hf : StrictMono f) : id ≤ f := by
rw [Pi.le_def]
by_contra! H
obtain ⟨m, hm, hm'⟩ := wellFounded_lt.has_min _ H
exact hm' _ (hf hm) hm | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.id_le | A strictly monotone function `f` on a well-order satisfies `x ≤ f x` for all `x`. |
StrictMono.le_apply [WellFoundedLT β] {f : β → β} (hf : StrictMono f) {x} : x ≤ f x :=
hf.id_le x | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.le_apply | null |
StrictMono.le_id [WellFoundedGT β] {f : β → β} (hf : StrictMono f) : f ≤ id :=
StrictMono.id_le (β := βᵒᵈ) hf.dual | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.le_id | A strictly monotone function `f` on a cowell-order satisfies `f x ≤ x` for all `x`. |
StrictMono.apply_le [WellFoundedGT β] {f : β → β} (hf : StrictMono f) {x} : f x ≤ x :=
StrictMono.le_apply (β := βᵒᵈ) hf.dual | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.apply_le | null |
StrictMono.not_bddAbove_range_of_wellFoundedLT {f : β → β} [WellFoundedLT β] [NoMaxOrder β]
(hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
rintro ⟨a, ha⟩
obtain ⟨b, hb⟩ := exists_gt a
exact ((hf.le_apply.trans_lt (hf hb)).trans_le <| ha (Set.mem_range_self _)).false | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.not_bddAbove_range_of_wellFoundedLT | null |
StrictMono.not_bddBelow_range_of_wellFoundedGT {f : β → β} [WellFoundedGT β] [NoMinOrder β]
(hf : StrictMono f) : ¬ BddBelow (Set.range f) :=
hf.dual.not_bddAbove_range_of_wellFoundedLT | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | StrictMono.not_bddBelow_range_of_wellFoundedGT | null |
noncomputable argmin [Nonempty α] : α :=
WellFounded.min (InvImage.wf f h.wf) Set.univ Set.univ_nonempty | def | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | argmin | Given a function `f : α → β` where `β` carries a well-founded `<`, this is an element of `α`
whose image under `f` is minimal in the sense of `Function.not_lt_argmin`. |
not_lt_argmin [Nonempty α] (a : α) : ¬f a < f (argmin f) :=
WellFounded.not_lt_min (InvImage.wf f h.wf) _ _ (Set.mem_univ a) | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | not_lt_argmin | null |
noncomputable argminOn (s : Set α) (hs : s.Nonempty) : α :=
WellFounded.min (InvImage.wf f h.wf) s hs
@[simp] | def | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | argminOn | Given a function `f : α → β` where `β` carries a well-founded `<`, and a non-empty subset `s`
of `α`, this is an element of `s` whose image under `f` is minimal in the sense of
`Function.not_lt_argminOn`. |
argminOn_mem (s : Set α) (hs : s.Nonempty) : argminOn f s hs ∈ s :=
WellFounded.min_mem _ _ _ | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | argminOn_mem | null |
not_lt_argminOn (s : Set α) {a : α} (ha : a ∈ s)
(hs : s.Nonempty := Set.nonempty_of_mem ha) : ¬f a < f (argminOn f s hs) :=
WellFounded.not_lt_min (InvImage.wf f h.wf) s hs ha | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | not_lt_argminOn | null |
argmin_le (a : α) [Nonempty α] : f (argmin f) ≤ f a :=
not_lt.mp <| not_lt_argmin f a | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | argmin_le | null |
argminOn_le (s : Set α) {a : α} (ha : a ∈ s) (hs : s.Nonempty := Set.nonempty_of_mem ha) :
f (argminOn f s hs) ≤ f a :=
not_lt.mp <| not_lt_argminOn f s ha hs | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | argminOn_le | null |
Acc.induction_bot' {α β} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : β → Prop}
{f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) : C (f a) → C (f bot) :=
(@Acc.recOn _ _ (fun x _ => C (f x) → C (f bot)) _ ha) fun x _ ih' hC =>
(eq_or_ne (f x) (f bot)).elim (fun h => h ▸ hC) (fun h =>... | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | Acc.induction_bot' | Let `r` be a relation on `α`, let `f : α → β` be a function, let `C : β → Prop`, and
let `bot : α`. This induction principle shows that `C (f bot)` holds, given that
* some `a` that is accessible by `r` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
satisfying `r c b... |
Acc.induction_bot {α} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : α → Prop}
(ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot :=
ha.induction_bot' ih | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | Acc.induction_bot | Let `r` be a relation on `α`, let `C : α → Prop` and let `bot : α`.
This induction principle shows that `C bot` holds, given that
* some `a` that is accessible by `r` satisfies `C a`, and
* for each `b ≠ bot` such that `C b` holds, there is `c` satisfying `r c b` and `C c`. |
WellFounded.induction_bot' {α β} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
{C : β → Prop} {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) :
C (f a) → C (f bot) :=
(hwf.apply a).induction_bot' ih | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | WellFounded.induction_bot' | Let `r` be a well-founded relation on `α`, let `f : α → β` be a function,
let `C : β → Prop`, and let `bot : α`.
This induction principle shows that `C (f bot)` holds, given that
* some `a` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
satisfying `r c b` and `C (f c... |
WellFounded.induction_bot {α} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
{C : α → Prop} (ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot :=
hwf.induction_bot' ih | theorem | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | WellFounded.induction_bot | Let `r` be a well-founded relation on `α`, let `C : α → Prop`, and let `bot : α`.
This induction principle shows that `C bot` holds, given that
* some `a` satisfies `C a`, and
* for each `b` that satisfies `C b`, there is `c` satisfying `r c b` and `C c`.
The naming is inspired by the fact that when `r` is transitive,... |
noncomputable WellFoundedLT.toOrderBot {α} [LinearOrder α] [Nonempty α] [h : WellFoundedLT α] :
OrderBot α where
bot := h.wf.min _ Set.univ_nonempty
bot_le a := h.wf.min_le (Set.mem_univ a) | def | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | WellFoundedLT.toOrderBot | A nonempty linear order with well-founded `<` has a bottom element. |
noncomputable WellFoundedGT.toOrderTop {α} [LinearOrder α] [Nonempty α] [WellFoundedGT α] :
OrderTop α :=
have := WellFoundedLT.toOrderBot (α := αᵒᵈ)
inferInstanceAs (OrderTop αᵒᵈᵒᵈ) | def | Order | [
"Mathlib.Data.Set.Function",
"Mathlib.Order.Bounds.Defs"
] | Mathlib/Order/WellFounded.lean | WellFoundedGT.toOrderTop | A nonempty linear order with well-founded `>` has a top element. |
WellFoundedOn (s : Set α) (r : α → α → Prop) : Prop :=
WellFounded (Subrel r (· ∈ s))
@[simp] | def | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | WellFoundedOn | `s.WellFoundedOn r` indicates that the relation `r` is `WellFounded` when restricted to `s`. |
wellFoundedOn_empty (r : α → α → Prop) : WellFoundedOn ∅ r :=
wellFounded_of_isEmpty _ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_empty | null |
wellFoundedOn_iff :
s.WellFoundedOn r ↔ WellFounded fun a b : α => r a b ∧ a ∈ s ∧ b ∈ s := by
have f : RelEmbedding (Subrel r (· ∈ s)) fun a b : α => r a b ∧ a ∈ s ∧ b ∈ s :=
⟨⟨(↑), Subtype.coe_injective⟩, by simp⟩
refine ⟨fun h => ?_, f.wellFounded⟩
rw [WellFounded.wellFounded_iff_has_min]
intro t ht
... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_iff | null |
wellFoundedOn_univ : (univ : Set α).WellFoundedOn r ↔ WellFounded r := by
simp [wellFoundedOn_iff] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_univ | null |
_root_.WellFounded.wellFoundedOn : WellFounded r → s.WellFoundedOn r :=
InvImage.wf _
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | _root_.WellFounded.wellFoundedOn | null |
wellFoundedOn_range : (range f).WellFoundedOn r ↔ WellFounded (r on f) := by
let f' : β → range f := fun c => ⟨f c, c, rfl⟩
refine ⟨fun h => (InvImage.wf f' h).mono fun c c' => id, fun h => ⟨?_⟩⟩
rintro ⟨_, c, rfl⟩
refine Acc.of_downward_closed f' ?_ _ ?_
· rintro _ ⟨_, c', rfl⟩ -
exact ⟨c', rfl⟩
· exac... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_range | null |
wellFoundedOn_image {s : Set β} : (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f) := by
rw [image_eq_range]; exact wellFoundedOn_range | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_image | null |
protected induction (hs : s.WellFoundedOn r) (hx : x ∈ s) {P : α → Prop}
(hP : ∀ y ∈ s, (∀ z ∈ s, r z y → P z) → P y) : P x := by
let Q : s → Prop := fun y => P y
change Q ⟨x, hx⟩
refine WellFounded.induction hs ⟨x, hx⟩ ?_
simpa only [Subtype.forall] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | induction | null |
protected mono (h : t.WellFoundedOn r') (hle : r ≤ r') (hst : s ⊆ t) :
s.WellFoundedOn r := by
rw [wellFoundedOn_iff] at *
exact Subrelation.wf (fun xy => ⟨hle _ _ xy.1, hst xy.2.1, hst xy.2.2⟩) h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | mono | null |
mono' (h : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), r' a b → r a b) :
s.WellFoundedOn r → s.WellFoundedOn r' :=
Subrelation.wf @fun a b => h _ a.2 _ b.2 | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | mono' | null |
subset (h : t.WellFoundedOn r) (hst : s ⊆ t) : s.WellFoundedOn r :=
h.mono le_rfl hst
open Relation
open List in | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | subset | null |
acc_iff_wellFoundedOn {α} {r : α → α → Prop} {a : α} :
TFAE [Acc r a,
WellFoundedOn { b | ReflTransGen r b a } r,
WellFoundedOn { b | TransGen r b a } r] := by
tfae_have 1 → 2 := by
refine fun h => ⟨fun b => InvImage.accessible Subtype.val ?_⟩
rw [← acc_transGen_iff] at h ⊢
obtain h' | h' ... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | acc_iff_wellFoundedOn | `a` is accessible under the relation `r` iff `r` is well-founded on the downward transitive
closure of `a` under `r` (including `a` or not). |
IsStrictOrder.subset : IsStrictOrder α fun a b : α => r a b ∧ a ∈ s ∧ b ∈ s where
toIsIrrefl := ⟨fun a con => irrefl_of r a con.1⟩
toIsTrans := ⟨fun _ _ _ ab bc => ⟨trans_of r ab.1 bc.1, ab.2.1, bc.2.2⟩⟩ | instance | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsStrictOrder.subset | null |
wellFoundedOn_iff_no_descending_seq :
s.WellFoundedOn r ↔ ∀ f : ((· > ·) : ℕ → ℕ → Prop) ↪r r, ¬∀ n, f n ∈ s := by
simp only [wellFoundedOn_iff, RelEmbedding.wellFounded_iff_isEmpty, ← not_exists, ←
not_nonempty_iff, not_iff_not]
constructor
· rintro ⟨⟨f, hf⟩⟩
have H : ∀ n, f n ∈ s := fun n => (hf.2 n... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_iff_no_descending_seq | null |
WellFoundedOn.union (hs : s.WellFoundedOn r) (ht : t.WellFoundedOn r) :
(s ∪ t).WellFoundedOn r := by
rw [wellFoundedOn_iff_no_descending_seq] at *
rintro f hf
rcases Nat.exists_subseq_of_forall_mem_union f hf with ⟨g, hg | hg⟩
exacts [hs (g.dual.ltEmbedding.trans f) hg, ht (g.dual.ltEmbedding.trans f) hg]
... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | WellFoundedOn.union | null |
wellFoundedOn_union : (s ∪ t).WellFoundedOn r ↔ s.WellFoundedOn r ∧ t.WellFoundedOn r :=
⟨fun h => ⟨h.subset subset_union_left, h.subset subset_union_right⟩, fun h =>
h.1.union h.2⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_union | null |
IsWF (s : Set α) : Prop :=
WellFoundedOn s (· < ·)
@[simp] | def | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsWF | `s.IsWF` indicates that `<` is well-founded when restricted to `s`. |
isWF_empty : IsWF (∅ : Set α) :=
wellFounded_of_isEmpty _ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_empty | null |
IsWF.mono (h : IsWF t) (st : s ⊆ t) : IsWF s := h.subset st | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsWF.mono | null |
isWF_univ_iff : IsWF (univ : Set α) ↔ WellFoundedLT α := by
simp [IsWF, wellFoundedOn_iff, isWellFounded_iff] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_univ_iff | null |
IsWF.of_wellFoundedLT [h : WellFoundedLT α] (s : Set α) : s.IsWF :=
(Set.isWF_univ_iff.2 h).mono s.subset_univ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsWF.of_wellFoundedLT | null |
@[simp] isWF_union : IsWF (s ∪ t) ↔ IsWF s ∧ IsWF t := wellFoundedOn_union | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_union | null |
isWF_iff_no_descending_seq :
IsWF s ↔ ∀ f : ℕ → α, StrictAnti f → ¬∀ n, f n ∈ s :=
wellFoundedOn_iff_no_descending_seq.trans
⟨fun H f hf => H ⟨⟨f, hf.injective⟩, hf.lt_iff_gt⟩, fun H f => H f fun _ _ => f.map_rel_iff.2⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_iff_no_descending_seq | null |
PartiallyWellOrderedOn (s : Set α) (r : α → α → Prop) : Prop :=
WellQuasiOrdered (Subrel r (· ∈ s)) | def | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn | `s.PartiallyWellOrderedOn r` indicates that the relation `r` is `WellQuasiOrdered` when
restricted to `s`.
A set is partially well-ordered by a relation `r` when any infinite sequence contains two elements
where the first is related to the second by `r`. Equivalently, any antichain (see `IsAntichain`) is
finite, see `... |
PartiallyWellOrderedOn.exists_lt (hs : s.PartiallyWellOrderedOn r) {f : ℕ → α}
(hf : ∀ n, f n ∈ s) : ∃ m n, m < n ∧ r (f m) (f n) :=
hs fun n ↦ ⟨_, hf n⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.exists_lt | null |
partiallyWellOrderedOn_iff_exists_lt : s.PartiallyWellOrderedOn r ↔
∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ m n, m < n ∧ r (f m) (f n) :=
⟨PartiallyWellOrderedOn.exists_lt, fun hf f ↦ hf _ fun n ↦ (f n).2⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_iff_exists_lt | null |
PartiallyWellOrderedOn.mono (ht : t.PartiallyWellOrderedOn r) (h : s ⊆ t) :
s.PartiallyWellOrderedOn r :=
fun f ↦ ht (Set.inclusion h ∘ f)
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.mono | null |
partiallyWellOrderedOn_empty (r : α → α → Prop) : PartiallyWellOrderedOn ∅ r :=
wellQuasiOrdered_of_isEmpty _ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_empty | null |
PartiallyWellOrderedOn.union (hs : s.PartiallyWellOrderedOn r)
(ht : t.PartiallyWellOrderedOn r) : (s ∪ t).PartiallyWellOrderedOn r := by
intro f
obtain ⟨g, hgs | hgt⟩ := Nat.exists_subseq_of_forall_mem_union _ fun x ↦ (f x).2
· rcases hs.exists_lt hgs with ⟨m, n, hlt, hr⟩
exact ⟨g m, g n, g.strictMono hl... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.union | null |
partiallyWellOrderedOn_union :
(s ∪ t).PartiallyWellOrderedOn r ↔ s.PartiallyWellOrderedOn r ∧ t.PartiallyWellOrderedOn r :=
⟨fun h ↦ ⟨h.mono subset_union_left, h.mono subset_union_right⟩, fun h ↦ h.1.union h.2⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_union | null |
PartiallyWellOrderedOn.image_of_monotone_on (hs : s.PartiallyWellOrderedOn r)
(hf : ∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂)) : (f '' s).PartiallyWellOrderedOn r' := by
rw [partiallyWellOrderedOn_iff_exists_lt] at *
intro g' hg'
choose g hgs heq using hg'
obtain rfl : f ∘ g = g' := funext heq
obtain... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.image_of_monotone_on | null |
_root_.IsAntichain.finite_of_partiallyWellOrderedOn (ha : IsAntichain r s)
(hp : s.PartiallyWellOrderedOn r) : s.Finite := by
refine not_infinite.1 fun hi => ?_
obtain ⟨m, n, hmn, h⟩ := hp (hi.natEmbedding _)
exact hmn.ne ((hi.natEmbedding _).injective <| Subtype.val_injective <|
ha.eq (hi.natEmbedding _ ... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | _root_.IsAntichain.finite_of_partiallyWellOrderedOn | null |
protected Finite.partiallyWellOrderedOn (hs : s.Finite) : s.PartiallyWellOrderedOn r :=
hs.to_subtype.wellQuasiOrdered _ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Finite.partiallyWellOrderedOn | null |
_root_.IsAntichain.partiallyWellOrderedOn_iff (hs : IsAntichain r s) :
s.PartiallyWellOrderedOn r ↔ s.Finite :=
⟨hs.finite_of_partiallyWellOrderedOn, Finite.partiallyWellOrderedOn⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | _root_.IsAntichain.partiallyWellOrderedOn_iff | null |
partiallyWellOrderedOn_singleton (a : α) : PartiallyWellOrderedOn {a} r :=
(finite_singleton a).partiallyWellOrderedOn
@[nontriviality] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_singleton | null |
Subsingleton.partiallyWellOrderedOn (hs : s.Subsingleton) : PartiallyWellOrderedOn s r :=
hs.finite.partiallyWellOrderedOn
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Subsingleton.partiallyWellOrderedOn | null |
partiallyWellOrderedOn_insert :
PartiallyWellOrderedOn (insert a s) r ↔ PartiallyWellOrderedOn s r := by
simp only [← singleton_union, partiallyWellOrderedOn_union,
partiallyWellOrderedOn_singleton, true_and] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_insert | null |
protected PartiallyWellOrderedOn.insert (h : PartiallyWellOrderedOn s r) (a : α) :
PartiallyWellOrderedOn (insert a s) r :=
partiallyWellOrderedOn_insert.2 h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.insert | null |
partiallyWellOrderedOn_iff_finite_antichains [IsSymm α r] :
s.PartiallyWellOrderedOn r ↔ ∀ t, t ⊆ s → IsAntichain r t → t.Finite := by
refine ⟨fun h t ht hrt => hrt.finite_of_partiallyWellOrderedOn (h.mono ht), ?_⟩
rw [partiallyWellOrderedOn_iff_exists_lt]
intro hs f hf
by_contra! H
refine infinite_range_... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_iff_finite_antichains | null |
PartiallyWellOrderedOn.exists_monotone_subseq (h : s.PartiallyWellOrderedOn r) {f : ℕ → α}
(hf : ∀ n, f n ∈ s) : ∃ g : ℕ ↪o ℕ, ∀ m n : ℕ, m ≤ n → r (f (g m)) (f (g n)) :=
WellQuasiOrdered.exists_monotone_subseq h fun n ↦ ⟨_, hf n⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.exists_monotone_subseq | null |
partiallyWellOrderedOn_iff_exists_monotone_subseq :
s.PartiallyWellOrderedOn r ↔
∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ g : ℕ ↪o ℕ, ∀ m n : ℕ, m ≤ n → r (f (g m)) (f (g n)) := by
use PartiallyWellOrderedOn.exists_monotone_subseq
rw [PartiallyWellOrderedOn, wellQuasiOrdered_iff_exists_monotone_subseq]
exact fun... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_iff_exists_monotone_subseq | null |
protected PartiallyWellOrderedOn.prod {t : Set β} (hs : PartiallyWellOrderedOn s r)
(ht : PartiallyWellOrderedOn t r') :
PartiallyWellOrderedOn (s ×ˢ t) fun x y : α × β => r x.1 y.1 ∧ r' x.2 y.2 := by
rw [partiallyWellOrderedOn_iff_exists_lt]
intro f hf
obtain ⟨g₁, h₁⟩ := hs.exists_monotone_subseq fun n =... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.prod | null |
PartiallyWellOrderedOn.wellFoundedOn (h : s.PartiallyWellOrderedOn r) :
s.WellFoundedOn fun a b => r a b ∧ ¬ r b a :=
h.wellFounded | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | PartiallyWellOrderedOn.wellFoundedOn | null |
IsPWO (s : Set α) : Prop :=
PartiallyWellOrderedOn s (· ≤ ·)
nonrec theorem IsPWO.mono (ht : t.IsPWO) : s ⊆ t → s.IsPWO := ht.mono
nonrec theorem IsPWO.exists_monotone_subseq (h : s.IsPWO) {f : ℕ → α} (hf : ∀ n, f n ∈ s) :
∃ g : ℕ ↪o ℕ, Monotone (f ∘ g) :=
h.exists_monotone_subseq hf | def | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO | A subset of a preorder is partially well-ordered when any infinite sequence contains
a monotone subsequence of length 2 (or equivalently, an infinite monotone subsequence). |
isPWO_iff_exists_monotone_subseq :
s.IsPWO ↔ ∀ f : ℕ → α, (∀ n, f n ∈ s) → ∃ g : ℕ ↪o ℕ, Monotone (f ∘ g) :=
partiallyWellOrderedOn_iff_exists_monotone_subseq | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isPWO_iff_exists_monotone_subseq | null |
protected IsPWO.isWF (h : s.IsPWO) : s.IsWF := by
simpa only [← lt_iff_le_not_ge] using h.wellFoundedOn
nonrec theorem IsPWO.prod {t : Set β} (hs : s.IsPWO) (ht : t.IsPWO) : IsPWO (s ×ˢ t) :=
hs.prod ht | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.isWF | null |
IsPWO.image_of_monotoneOn (hs : s.IsPWO) {f : α → β} (hf : MonotoneOn f s) :
IsPWO (f '' s) :=
hs.image_of_monotone_on hf | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.image_of_monotoneOn | null |
IsPWO.image_of_monotone (hs : s.IsPWO) {f : α → β} (hf : Monotone f) : IsPWO (f '' s) :=
hs.image_of_monotone_on (hf.monotoneOn _)
protected nonrec theorem IsPWO.union (hs : IsPWO s) (ht : IsPWO t) : IsPWO (s ∪ t) :=
hs.union ht
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.image_of_monotone | null |
isPWO_union : IsPWO (s ∪ t) ↔ IsPWO s ∧ IsPWO t :=
partiallyWellOrderedOn_union | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isPWO_union | null |
protected Finite.isPWO (hs : s.Finite) : IsPWO s := hs.partiallyWellOrderedOn
@[simp] theorem isPWO_of_finite [Finite α] : s.IsPWO := s.toFinite.isPWO
@[simp] theorem isPWO_singleton (a : α) : IsPWO ({a} : Set α) := (finite_singleton a).isPWO
@[simp] theorem isPWO_empty : IsPWO (∅ : Set α) := finite_empty.isPWO | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Finite.isPWO | null |
protected Subsingleton.isPWO (hs : s.Subsingleton) : IsPWO s := hs.finite.isPWO
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Subsingleton.isPWO | null |
isPWO_insert {a} : IsPWO (insert a s) ↔ IsPWO s := by
simp only [← singleton_union, isPWO_union, isPWO_singleton, true_and] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isPWO_insert | null |
protected IsPWO.insert (h : IsPWO s) (a : α) : IsPWO (insert a s) :=
isPWO_insert.2 h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.insert | null |
protected Finite.isWF (hs : s.Finite) : IsWF s := hs.isPWO.isWF
@[simp] theorem isWF_singleton {a : α} : IsWF ({a} : Set α) := (finite_singleton a).isWF | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Finite.isWF | null |
protected Subsingleton.isWF (hs : s.Subsingleton) : IsWF s := hs.isPWO.isWF
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Subsingleton.isWF | null |
isWF_insert {a} : IsWF (insert a s) ↔ IsWF s := by
simp only [← singleton_union, isWF_union, isWF_singleton, true_and] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_insert | null |
protected IsWF.insert (h : IsWF s) (a : α) : IsWF (insert a s) :=
isWF_insert.2 h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsWF.insert | null |
IsPWO.exists_le_minimal {a} (hs : s.IsPWO) (ha : a ∈ s) :
∃ b ≤ a, Minimal (· ∈ s) b := by
let t : Set s := {x | x ≤ a}
let h : t.Nonempty := ⟨⟨a, ha⟩, le_rfl⟩
refine ⟨hs.wellFounded.min t h, hs.wellFounded.min_mem t h,
(hs.wellFounded.min t h).2, fun y hy hle => ?_⟩
by_contra hnle
exact hs.wellFounde... | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.exists_le_minimal | null |
IsPWO.exists_minimal (h : s.IsPWO) (hs : s.Nonempty) :
∃ a, Minimal (· ∈ s) a := by
rcases hs with ⟨a, ha⟩
obtain ⟨b, _, hb⟩ := h.exists_le_minimal ha
exact ⟨b, hb⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.exists_minimal | null |
IsPWO.exists_minimalFor (f : ι → α) (s : Set ι) (h : (f '' s).IsPWO) (hs : s.Nonempty) :
∃ i, MinimalFor (· ∈ s) f i := by
obtain ⟨_, h⟩ := h.exists_minimal (hs.image _)
obtain ⟨a, ha, rfl⟩ := h.1
exact ⟨a, ha, fun b hb => h.2 (mem_image_of_mem _ hb)⟩ | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.exists_minimalFor | null |
protected Finite.wellFoundedOn (hs : s.Finite) : s.WellFoundedOn r :=
letI := partialOrderOfSO r
hs.isWF
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Finite.wellFoundedOn | null |
wellFoundedOn_singleton : WellFoundedOn ({a} : Set α) r :=
(finite_singleton a).wellFoundedOn | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_singleton | null |
protected Subsingleton.wellFoundedOn (hs : s.Subsingleton) : s.WellFoundedOn r :=
hs.finite.wellFoundedOn
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | Subsingleton.wellFoundedOn | null |
wellFoundedOn_insert : WellFoundedOn (insert a s) r ↔ WellFoundedOn s r := by
simp only [← singleton_union, wellFoundedOn_union, wellFoundedOn_singleton, true_and]
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_insert | null |
wellFoundedOn_sdiff_singleton : WellFoundedOn (s \ {a}) r ↔ WellFoundedOn s r := by
simp only [← wellFoundedOn_insert (a := a), insert_diff_singleton, mem_insert_iff, true_or,
insert_eq_of_mem] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_sdiff_singleton | null |
protected WellFoundedOn.insert (h : WellFoundedOn s r) (a : α) :
WellFoundedOn (insert a s) r :=
wellFoundedOn_insert.2 h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | WellFoundedOn.insert | null |
protected WellFoundedOn.sdiff_singleton (h : WellFoundedOn s r) (a : α) :
WellFoundedOn (s \ {a}) r :=
wellFoundedOn_sdiff_singleton.2 h | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | WellFoundedOn.sdiff_singleton | null |
WellFoundedOn.mapsTo {α β : Type*} {r : α → α → Prop} (f : β → α)
{s : Set α} {t : Set β} (h : MapsTo f t s) (hw : s.WellFoundedOn r) :
t.WellFoundedOn (r on f) := by
exact InvImage.wf (fun x : t ↦ ⟨f x, h x.prop⟩) hw | lemma | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | WellFoundedOn.mapsTo | null |
isPWO_iff_isWF : s.IsPWO ↔ s.IsWF := by
change WellQuasiOrdered (· ≤ ·) ↔ WellFounded (· < ·)
rw [← wellQuasiOrderedLE_def, ← isWellFounded_iff, wellQuasiOrderedLE_iff_wellFoundedLT]
alias ⟨_, IsWF.isPWO⟩ := isPWO_iff_isWF | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isPWO_iff_isWF | In a linear order, the predicates `Set.IsPWO` and `Set.IsWF` are equivalent. |
IsPWO.of_linearOrder [WellFoundedLT α] (s : Set α) : s.IsPWO :=
(IsWF.of_wellFoundedLT s).isPWO | lemma | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | IsPWO.of_linearOrder | If `α` is a linear order with well-founded `<`, then any set in it is a partially well-ordered set.
Note this does not hold without the linearity assumption. |
@[simp]
protected partiallyWellOrderedOn [IsRefl α r] (s : Finset α) :
(s : Set α).PartiallyWellOrderedOn r :=
s.finite_toSet.partiallyWellOrderedOn
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn | null |
protected isPWO [Preorder α] (s : Finset α) : Set.IsPWO (↑s : Set α) :=
s.partiallyWellOrderedOn
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isPWO | null |
protected isWF [Preorder α] (s : Finset α) : Set.IsWF (↑s : Set α) :=
s.finite_toSet.isWF
@[simp] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF | null |
protected wellFoundedOn [IsStrictOrder α r] (s : Finset α) :
Set.WellFoundedOn (↑s : Set α) r :=
letI := partialOrderOfSO r
s.isWF | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn | null |
wellFoundedOn_sup [IsStrictOrder α r] (s : Finset ι) {f : ι → Set α} :
(s.sup f).WellFoundedOn r ↔ ∀ i ∈ s, (f i).WellFoundedOn r :=
Finset.cons_induction_on s (by simp) fun a s ha hs => by simp [-sup_set_eq_biUnion, hs] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | wellFoundedOn_sup | null |
partiallyWellOrderedOn_sup (s : Finset ι) {f : ι → Set α} :
(s.sup f).PartiallyWellOrderedOn r ↔ ∀ i ∈ s, (f i).PartiallyWellOrderedOn r :=
Finset.cons_induction_on s (by simp) fun a s ha hs => by simp [-sup_set_eq_biUnion, hs] | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | partiallyWellOrderedOn_sup | null |
isWF_sup [Preorder α] (s : Finset ι) {f : ι → Set α} :
(s.sup f).IsWF ↔ ∀ i ∈ s, (f i).IsWF :=
s.wellFoundedOn_sup | theorem | Order | [
"Mathlib.Data.Prod.Lex",
"Mathlib.Data.Sigma.Lex",
"Mathlib.Order.RelIso.Set",
"Mathlib.Order.WellQuasiOrder",
"Mathlib.Tactic.TFAE"
] | Mathlib/Order/WellFoundedSet.lean | isWF_sup | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.