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 ⌀ |
|---|---|---|---|---|---|---|
le_gfp {a : α} (h : a ≤ f a) : a ≤ f.gfp :=
le_sSup h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_gfp | null |
gfp_le {a : α} (h : ∀ b, b ≤ f b → b ≤ a) : f.gfp ≤ a :=
sSup_le h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_le | null |
isFixedPt_gfp : IsFixedPt f f.gfp :=
f.dual.isFixedPt_lfp
@[simp] | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isFixedPt_gfp | null |
map_gfp : f f.gfp = f.gfp :=
f.dual.map_lfp | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_gfp | null |
map_le_gfp {a : α} (ha : a ≤ f.gfp) : f a ≤ f.gfp :=
f.dual.lfp_le_map ha | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_le_gfp | null |
gfp_le_map {a : α} (ha : f.gfp ≤ a) : f.gfp ≤ f a :=
f.dual.map_le_lfp ha | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_le_map | null |
isGreatest_gfp_le : IsGreatest { a | a ≤ f a } f.gfp :=
f.dual.isLeast_lfp_le | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isGreatest_gfp_le | null |
isGreatest_gfp : IsGreatest (fixedPoints f) f.gfp :=
f.dual.isLeast_lfp | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | isGreatest_gfp | null |
gfp_induction {p : α → Prop} (step : ∀ a, p a → f.gfp ≤ a → p (f a))
(hInf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : p f.gfp :=
f.dual.lfp_induction step hInf | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_induction | null |
map_lfp_comp : f (g.comp f).lfp = (f.comp g).lfp :=
le_antisymm ((f.comp g).map_lfp ▸ f.mono (lfp_le_fixed _ <| congr_arg g (f.comp g).map_lfp)) <|
lfp_le _ (congr_arg f (g.comp f).map_lfp).le | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_lfp_comp | null |
map_gfp_comp : f (g.comp f).gfp = (f.comp g).gfp :=
f.dual.map_lfp_comp g.dual | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_gfp_comp | null |
lfp_lfp (h : α →o α →o α) : (lfp.comp h).lfp = h.onDiag.lfp := by
let a := (lfp.comp h).lfp
refine (lfp_le _ ?_).antisymm (lfp_le _ (Eq.le ?_))
· exact lfp_le _ h.onDiag.map_lfp.le
have ha : (lfp ∘ h) a = a := (lfp.comp h).map_lfp
calc
h a a = h a (h a).lfp := congr_arg (h a) ha.symm
_ = (h a).lfp := ... | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_lfp | null |
gfp_gfp (h : α →o α →o α) : (gfp.comp h).gfp = h.onDiag.gfp :=
@lfp_lfp αᵒᵈ _ <| (OrderHom.dualIso αᵒᵈ αᵒᵈ).symm.toOrderEmbedding.toOrderHom.comp h.dual | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_gfp | null |
gfp_const_inf_le (x : α) : (const α x ⊓ f).gfp ≤ x :=
(gfp_le _) fun _ hb => hb.trans inf_le_left | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_const_inf_le | null |
prevFixed (x : α) (hx : f x ≤ x) : fixedPoints f :=
⟨(const α x ⊓ f).gfp,
calc
f (const α x ⊓ f).gfp = x ⊓ f (const α x ⊓ f).gfp :=
Eq.symm <| inf_of_le_right <| (f.mono <| f.gfp_const_inf_le x).trans hx
_ = (const α x ⊓ f).gfp := (const α x ⊓ f).map_gfp
⟩ | def | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | prevFixed | Previous fixed point of a monotone map. If `f` is a monotone self-map of a complete lattice and
`x` is a point such that `f x ≤ x`, then `f.prevFixed x hx` is the greatest fixed point of `f`
that is less than or equal to `x`. |
nextFixed (x : α) (hx : x ≤ f x) : fixedPoints f :=
{ f.dual.prevFixed x hx with val := (const α x ⊔ f).lfp } | def | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | nextFixed | Next fixed point of a monotone map. If `f` is a monotone self-map of a complete lattice and
`x` is a point such that `x ≤ f x`, then `f.nextFixed x hx` is the least fixed point of `f`
that is greater than or equal to `x`. |
prevFixed_le {x : α} (hx : f x ≤ x) : ↑(f.prevFixed x hx) ≤ x :=
f.gfp_const_inf_le x | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | prevFixed_le | null |
le_nextFixed {x : α} (hx : x ≤ f x) : x ≤ f.nextFixed x hx :=
f.dual.prevFixed_le hx | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_nextFixed | null |
nextFixed_le {x : α} (hx : x ≤ f x) {y : fixedPoints f} (h : x ≤ y) :
f.nextFixed x hx ≤ y :=
Subtype.coe_le_coe.1 <| lfp_le _ <| sup_le h y.2.le
@[simp] | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | nextFixed_le | null |
nextFixed_le_iff {x : α} (hx : x ≤ f x) {y : fixedPoints f} :
f.nextFixed x hx ≤ y ↔ x ≤ y :=
⟨fun h => (f.le_nextFixed hx).trans h, f.nextFixed_le hx⟩
@[simp] | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | nextFixed_le_iff | null |
le_prevFixed_iff {x : α} (hx : f x ≤ x) {y : fixedPoints f} :
y ≤ f.prevFixed x hx ↔ ↑y ≤ x :=
f.dual.nextFixed_le_iff hx | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_prevFixed_iff | null |
le_prevFixed {x : α} (hx : f x ≤ x) {y : fixedPoints f} (h : ↑y ≤ x) :
y ≤ f.prevFixed x hx :=
(f.le_prevFixed_iff hx).2 h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_prevFixed | null |
le_map_sup_fixedPoints (x y : fixedPoints f) : (x ⊔ y : α) ≤ f (x ⊔ y) :=
calc
(x ⊔ y : α) = f x ⊔ f y := congr_arg₂ (· ⊔ ·) x.2.symm y.2.symm
_ ≤ f (x ⊔ y) := f.mono.le_map_sup x y | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_map_sup_fixedPoints | null |
map_inf_fixedPoints_le (x y : fixedPoints f) : f (x ⊓ y) ≤ x.val ⊓ y.val :=
f.dual.le_map_sup_fixedPoints x y | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_inf_fixedPoints_le | null |
le_map_sSup_subset_fixedPoints (A : Set α) (hA : A ⊆ fixedPoints f) :
sSup A ≤ f (sSup A) :=
sSup_le fun _ hx => hA hx ▸ (f.mono <| le_sSup hx) | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | le_map_sSup_subset_fixedPoints | null |
map_sInf_subset_fixedPoints_le (A : Set α) (hA : A ⊆ fixedPoints f) :
f (sInf A) ≤ sInf A :=
le_sInf fun _ hx => hA hx ▸ (f.mono <| sInf_le hx) | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | map_sInf_subset_fixedPoints_le | null |
completeLattice : CompleteLattice (fixedPoints f) where
__ := inferInstanceAs (SemilatticeInf (fixedPoints f))
__ := inferInstanceAs (SemilatticeSup (fixedPoints f))
__ := inferInstanceAs (CompleteSemilatticeInf (fixedPoints f))
__ := inferInstanceAs (CompleteSemilatticeSup (fixedPoints f))
top := ⟨f.gfp, f.i... | instance | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | completeLattice | **Knaster-Tarski Theorem**: The fixed points of `f` form a complete lattice. |
lfp_eq_sSup_iterate (h : ωScottContinuous f) :
f.lfp = ⨆ n, f^[n] ⊥ := by
apply le_antisymm
· apply lfp_le_fixed
exact Function.mem_fixedPoints.mp (ωSup_iterate_mem_fixedPoint
⟨f, h.map_ωSup_of_orderHom⟩ ⊥ bot_le)
· apply le_lfp
intro a h_a
exact ωSup_iterate_le_prefixedPoint ⟨f, h.map_ωSup_... | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | lfp_eq_sSup_iterate | **Kleene's fixed point Theorem**: The least fixed point in a complete lattice is
the supremum of iterating a function on bottom arbitrary often. |
gfp_eq_sInf_iterate (h : ωScottContinuous f.dual) :
f.gfp = ⨅ n, f^[n] ⊤ :=
lfp_eq_sSup_iterate f.dual h | theorem | Order | [
"Mathlib.Dynamics.FixedPoints.Basic",
"Mathlib.Order.Hom.Order",
"Mathlib.Order.OmegaCompletePartialOrder"
] | Mathlib/Order/FixedPoints.lean | gfp_eq_sInf_iterate | null |
GameAdd : α × β → α × β → Prop
| fst {a₁ a₂ b} : rα a₁ a₂ → GameAdd (a₁, b) (a₂, b)
| snd {a b₁ b₂} : rβ b₁ b₂ → GameAdd (a, b₁) (a, b₂) | inductive | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd | `Prod.GameAdd rα rβ x y` means that `x` can be reached from `y` by decreasing either entry with
respect to the relations `rα` and `rβ`.
It is so called, as it models game addition within combinatorial game theory. If `rα a₁ a₂` means
that `a₂ ⟶ a₁` is a valid move in game `α`, and `rβ b₁ b₂` means that `b₂ ⟶ b₁`... |
gameAdd_iff {rα rβ} {x y : α × β} :
GameAdd rα rβ x y ↔ rα x.1 y.1 ∧ x.2 = y.2 ∨ rβ x.2 y.2 ∧ x.1 = y.1 := by
constructor
· rintro (@⟨a₁, a₂, b, h⟩ | @⟨a, b₁, b₂, h⟩)
exacts [Or.inl ⟨h, rfl⟩, Or.inr ⟨h, rfl⟩]
· revert x y
rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ (⟨h, rfl : b₁ = b₂⟩ | ⟨h, rfl : a₁ = a₂⟩)
exacts [G... | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_iff | null |
gameAdd_mk_iff {rα rβ} {a₁ a₂ : α} {b₁ b₂ : β} :
GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ rα a₁ a₂ ∧ b₁ = b₂ ∨ rβ b₁ b₂ ∧ a₁ = a₂ :=
gameAdd_iff
@[simp] | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_mk_iff | null |
gameAdd_swap_swap : ∀ a b : α × β, GameAdd rβ rα a.swap b.swap ↔ GameAdd rα rβ a b :=
fun ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ => by rw [Prod.swap, Prod.swap, gameAdd_mk_iff, gameAdd_mk_iff, or_comm] | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_swap_swap | null |
gameAdd_swap_swap_mk (a₁ a₂ : α) (b₁ b₂ : β) :
GameAdd rα rβ (a₁, b₁) (a₂, b₂) ↔ GameAdd rβ rα (b₁, a₁) (b₂, a₂) :=
gameAdd_swap_swap rβ rα (b₁, a₁) (b₂, a₂) | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_swap_swap_mk | null |
gameAdd_le_lex : GameAdd rα rβ ≤ Prod.Lex rα rβ := fun _ _ h =>
h.rec (Prod.Lex.left _ _) (Prod.Lex.right _) | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_le_lex | `Prod.GameAdd` is a subrelation of `Prod.Lex`. |
rprod_le_transGen_gameAdd : RProd rα rβ ≤ Relation.TransGen (GameAdd rα rβ)
| _, _, h => h.rec (by
intro _ _ _ _ hα hβ
exact Relation.TransGen.tail (Relation.TransGen.single <| GameAdd.fst hα) (GameAdd.snd hβ)) | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | rprod_le_transGen_gameAdd | `Prod.RProd` is a subrelation of the transitive closure of `Prod.GameAdd`. |
Acc.prod_gameAdd (ha : Acc rα a) (hb : Acc rβ b) :
Acc (Prod.GameAdd rα rβ) (a, b) := by
induction ha generalizing b with | _ a _ iha
induction hb with | _ b hb ihb
refine Acc.intro _ fun h => ?_
rintro (⟨ra⟩ | ⟨rb⟩)
exacts [iha _ ra (Acc.intro b hb), ihb _ rb] | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | Acc.prod_gameAdd | If `a` is accessible under `rα` and `b` is accessible under `rβ`, then `(a, b)` is
accessible under `Prod.GameAdd rα rβ`. Notice that `Prod.lexAccessible` requires the
stronger condition `∀ b, Acc rβ b`. |
WellFounded.prod_gameAdd (hα : WellFounded rα) (hβ : WellFounded rβ) :
WellFounded (Prod.GameAdd rα rβ) :=
⟨fun ⟨a, b⟩ => (hα.apply a).prod_gameAdd (hβ.apply b)⟩ | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | WellFounded.prod_gameAdd | The `Prod.GameAdd` relation on well-founded inputs is well-founded.
In particular, the sum of two well-founded games is well-founded. |
GameAdd.fix {C : α → β → Sort*} (hα : WellFounded rα) (hβ : WellFounded rβ)
(IH : ∀ a₁ b₁, (∀ a₂ b₂, GameAdd rα rβ (a₂, b₂) (a₁, b₁) → C a₂ b₂) → C a₁ b₁) (a : α) (b : β) :
C a b :=
@WellFounded.fix (α × β) (fun x => C x.1 x.2) _ (hα.prod_gameAdd hβ)
(fun ⟨x₁, x₂⟩ IH' => IH x₁ x₂ fun a' b' => IH' ⟨a', b'⟩... | def | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fix | Recursion on the well-founded `Prod.GameAdd` relation.
Note that it's strictly more general to recurse on the lexicographic order instead. |
GameAdd.fix_eq {C : α → β → Sort*} (hα : WellFounded rα) (hβ : WellFounded rβ)
(IH : ∀ a₁ b₁, (∀ a₂ b₂, GameAdd rα rβ (a₂, b₂) (a₁, b₁) → C a₂ b₂) → C a₁ b₁) (a : α) (b : β) :
GameAdd.fix hα hβ IH a b = IH a b fun a' b' _ => GameAdd.fix hα hβ IH a' b' :=
WellFounded.fix_eq _ _ _ | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fix_eq | null |
GameAdd.induction {C : α → β → Prop} :
WellFounded rα →
WellFounded rβ →
(∀ a₁ b₁, (∀ a₂ b₂, GameAdd rα rβ (a₂, b₂) (a₁, b₁) → C a₂ b₂) → C a₁ b₁) → ∀ a b, C a b :=
GameAdd.fix | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.induction | Induction on the well-founded `Prod.GameAdd` relation.
Note that it's strictly more general to induct on the lexicographic order instead. |
GameAdd (rα : α → α → Prop) : Sym2 α → Sym2 α → Prop :=
Sym2.lift₂
⟨fun a₁ b₁ a₂ b₂ => Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂) ∨ Prod.GameAdd rα rα (b₁, a₁) (a₂, b₂),
fun a₁ b₁ a₂ b₂ => by
dsimp
rw [Prod.gameAdd_swap_swap_mk _ _ b₁ b₂ a₁ a₂, Prod.gameAdd_swap_swap_mk _ _ a₁ b₂ b₁ a₂]
si... | def | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd | `Sym2.GameAdd rα x y` means that `x` can be reached from `y` by decreasing either entry with
respect to the relation `rα`.
See `Prod.GameAdd` for the ordered pair analog. |
gameAdd_iff : ∀ {x y : α × α},
GameAdd rα (Sym2.mk x) (Sym2.mk y) ↔ Prod.GameAdd rα rα x y ∨ Prod.GameAdd rα rα x.swap y := by
rintro ⟨_, _⟩ ⟨_, _⟩
rfl | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_iff | null |
gameAdd_mk'_iff {a₁ a₂ b₁ b₂ : α} :
GameAdd rα s(a₁, b₁) s(a₂, b₂) ↔
Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂) ∨ Prod.GameAdd rα rα (b₁, a₁) (a₂, b₂) :=
Iff.rfl | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | gameAdd_mk'_iff | null |
_root_.Prod.GameAdd.to_sym2 {a₁ a₂ b₁ b₂ : α} (h : Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂)) :
Sym2.GameAdd rα s(a₁, b₁) s(a₂, b₂) :=
gameAdd_mk'_iff.2 <| Or.inl <| h | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | _root_.Prod.GameAdd.to_sym2 | null |
GameAdd.fst {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(a₁, b) s(a₂, b) :=
(Prod.GameAdd.fst h).to_sym2 | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fst | null |
GameAdd.snd {a b₁ b₂ : α} (h : rα b₁ b₂) : GameAdd rα s(a, b₁) s(a, b₂) :=
(Prod.GameAdd.snd h).to_sym2 | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.snd | null |
GameAdd.fst_snd {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(a₁, b) s(b, a₂) := by
rw [Sym2.eq_swap]
exact GameAdd.snd h | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fst_snd | null |
GameAdd.snd_fst {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(b, a₁) s(a₂, b) := by
rw [Sym2.eq_swap]
exact GameAdd.fst h | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.snd_fst | null |
Acc.sym2_gameAdd {a b} (ha : Acc rα a) (hb : Acc rα b) :
Acc (Sym2.GameAdd rα) s(a, b) := by
induction ha generalizing b with | _ a _ iha
induction hb with | _ b hb ihb
refine Acc.intro _ fun s => ?_
induction s with | _ c d
rw [Sym2.GameAdd]
dsimp
rintro ((rc | rd) | (rd | rc))
· exact iha c rc ⟨b,... | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | Acc.sym2_gameAdd | null |
WellFounded.sym2_gameAdd (h : WellFounded rα) : WellFounded (Sym2.GameAdd rα) :=
⟨fun i => Sym2.inductionOn i fun x y => (h.apply x).sym2_gameAdd (h.apply y)⟩ | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | WellFounded.sym2_gameAdd | The `Sym2.GameAdd` relation on well-founded inputs is well-founded. |
GameAdd.fix {C : α → α → Sort*} (hr : WellFounded rα)
(IH : ∀ a₁ b₁, (∀ a₂ b₂, Sym2.GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁) (a b : α) :
C a b :=
@WellFounded.fix (α × α) (fun x => C x.1 x.2)
(fun x y ↦ Prod.GameAdd rα rα x y ∨ Prod.GameAdd rα rα x.swap y)
(by simpa [← Sym2.gameAdd_iff] us... | def | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fix | Recursion on the well-founded `Sym2.GameAdd` relation. |
GameAdd.fix_eq {C : α → α → Sort*} (hr : WellFounded rα)
(IH : ∀ a₁ b₁, (∀ a₂ b₂, Sym2.GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁) (a b : α) :
GameAdd.fix hr IH a b = IH a b fun a' b' _ => GameAdd.fix hr IH a' b' :=
WellFounded.fix_eq .. | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.fix_eq | null |
GameAdd.induction {C : α → α → Prop} :
WellFounded rα →
(∀ a₁ b₁, (∀ a₂ b₂, Sym2.GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁) →
∀ a b, C a b :=
GameAdd.fix | theorem | Order | [
"Mathlib.Data.Sym.Sym2",
"Mathlib.Logic.Relation"
] | Mathlib/Order/GameAdd.lean | GameAdd.induction | Induction on the well-founded `Sym2.GameAdd` relation. |
GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
/-- The grading function. -/
protected grade : α → 𝕆
/-- `grade` is strictly monotonic. -/
grade_strictMono : StrictMono grade
/-- `grade` preserves `CovBy`. -/
covBy_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b | class | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder | An `𝕆`-graded order is an order `α` equipped with a strictly monotone function
`grade 𝕆 : α → 𝕆` which preserves order covering (`CovBy`). |
GradeMinOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
/-- Minimal elements have minimal grades. -/
isMin_grade ⦃a : α⦄ : IsMin a → IsMin (grade a) | class | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMinOrder | An `𝕆`-graded order where minimal elements have minimal grades. |
GradeMaxOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeOrder 𝕆 α where
/-- Maximal elements have maximal grades. -/
isMax_grade ⦃a : α⦄ : IsMax a → IsMax (grade a) | class | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMaxOrder | An `𝕆`-graded order where maximal elements have maximal grades. |
GradeBoundedOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] extends GradeMinOrder 𝕆 α,
GradeMaxOrder 𝕆 α | class | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeBoundedOrder | An `𝕆`-graded order where minimal elements have minimal grades and maximal elements have maximal
grades. |
grade : α → 𝕆 :=
GradeOrder.grade | def | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade | The grade of an element in a graded order. Morally, this is the number of elements you need to
go down by to get to `⊥`. |
protected CovBy.grade (h : a ⋖ b) : grade 𝕆 a ⋖ grade 𝕆 b :=
GradeOrder.covBy_grade h
variable {𝕆} | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | CovBy.grade | null |
grade_strictMono : StrictMono (grade 𝕆 : α → 𝕆) :=
GradeOrder.grade_strictMono | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_strictMono | null |
covBy_iff_lt_covBy_grade : a ⋖ b ↔ a < b ∧ grade 𝕆 a ⋖ grade 𝕆 b :=
⟨fun h => ⟨h.1, h.grade _⟩,
And.imp_right fun h _ ha hb => h.2 (grade_strictMono ha) <| grade_strictMono hb⟩ | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | covBy_iff_lt_covBy_grade | null |
protected IsMin.grade (h : IsMin a) : IsMin (grade 𝕆 a) :=
GradeMinOrder.isMin_grade h
variable {𝕆}
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | IsMin.grade | null |
isMin_grade_iff : IsMin (grade 𝕆 a) ↔ IsMin a :=
⟨grade_strictMono.isMin_of_apply, IsMin.grade _⟩ | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | isMin_grade_iff | null |
protected IsMax.grade (h : IsMax a) : IsMax (grade 𝕆 a) :=
GradeMaxOrder.isMax_grade h
variable {𝕆}
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | IsMax.grade | null |
isMax_grade_iff : IsMax (grade 𝕆 a) ↔ IsMax a :=
⟨grade_strictMono.isMax_of_apply, IsMax.grade _⟩ | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | isMax_grade_iff | null |
grade_mono [PartialOrder α] [GradeOrder 𝕆 α] : Monotone (grade 𝕆 : α → 𝕆) :=
grade_strictMono.monotone | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_mono | null |
grade_injective : Function.Injective (grade 𝕆 : α → 𝕆) :=
grade_strictMono.injective
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_injective | null |
grade_le_grade_iff : grade 𝕆 a ≤ grade 𝕆 b ↔ a ≤ b :=
grade_strictMono.le_iff_le
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_le_grade_iff | null |
grade_lt_grade_iff : grade 𝕆 a < grade 𝕆 b ↔ a < b :=
grade_strictMono.lt_iff_lt
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_lt_grade_iff | null |
grade_eq_grade_iff : grade 𝕆 a = grade 𝕆 b ↔ a = b :=
grade_injective.eq_iff | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_eq_grade_iff | null |
grade_ne_grade_iff : grade 𝕆 a ≠ grade 𝕆 b ↔ a ≠ b :=
grade_injective.ne_iff | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_ne_grade_iff | null |
grade_covBy_grade_iff : grade 𝕆 a ⋖ grade 𝕆 b ↔ a ⋖ b :=
(covBy_iff_lt_covBy_grade.trans <| and_iff_right_of_imp fun h => grade_lt_grade_iff.1 h.1).symm | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_covBy_grade_iff | null |
@[simp]
grade_bot [OrderBot 𝕆] [OrderBot α] [GradeMinOrder 𝕆 α] : grade 𝕆 (⊥ : α) = ⊥ :=
(isMin_bot.grade _).eq_bot
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_bot | null |
grade_top [OrderTop 𝕆] [OrderTop α] [GradeMaxOrder 𝕆 α] : grade 𝕆 (⊤ : α) = ⊤ :=
(isMax_top.grade _).eq_top | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_top | null |
Preorder.toGradeBoundedOrder : GradeBoundedOrder α α where
grade := id
isMin_grade _ := id
isMax_grade _ := id
grade_strictMono := strictMono_id
covBy_grade _ _ := id
@[simp] | instance | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | Preorder.toGradeBoundedOrder | null |
grade_self (a : α) : grade α a = a :=
rfl
/-! #### Dual -/ | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_self | null |
OrderDual.gradeOrder [GradeOrder 𝕆 α] : GradeOrder 𝕆ᵒᵈ αᵒᵈ where
grade := toDual ∘ grade 𝕆 ∘ ofDual
grade_strictMono := grade_strictMono.dual
covBy_grade _ _ h := (h.ofDual.grade _).toDual | instance | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | OrderDual.gradeOrder | null |
OrderDual.gradeMinOrder [GradeMaxOrder 𝕆 α] : GradeMinOrder 𝕆ᵒᵈ αᵒᵈ :=
{ OrderDual.gradeOrder with isMin_grade := fun _ => IsMax.grade (α := α) 𝕆 } | instance | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | OrderDual.gradeMinOrder | null |
OrderDual.gradeMaxOrder [GradeMinOrder 𝕆 α] : GradeMaxOrder 𝕆ᵒᵈ αᵒᵈ :=
{ OrderDual.gradeOrder with isMax_grade := fun _ => IsMin.grade (α := α) 𝕆 } | instance | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | OrderDual.gradeMaxOrder | null |
@[simp]
grade_toDual [GradeOrder 𝕆 α] (a : α) : grade 𝕆ᵒᵈ (toDual a) = toDual (grade 𝕆 a) :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_toDual | null |
grade_ofDual [GradeOrder 𝕆 α] (a : αᵒᵈ) : grade 𝕆 (ofDual a) = ofDual (grade 𝕆ᵒᵈ a) :=
rfl
/-! #### Lifting a graded order -/ | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_ofDual | null |
GradeOrder.liftLeft [GradeOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder ℙ α where
grade := f ∘ grade 𝕆
grade_strictMono := hf.comp grade_strictMono
covBy_grade _ _ h := hcovBy _ _ <| h.grade _ | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.liftLeft | Lifts a graded order along a strictly monotone function. |
GradeMinOrder.liftLeft [GradeMinOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder ℙ α :=
{ GradeOrder.liftLeft f hf hcovBy with isMin_grade := fun _ ha => hmin _ <| ha.grade _ } | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMinOrder.liftLeft | Lifts a graded order along a strictly monotone function. |
GradeMaxOrder.liftLeft [GradeMaxOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder ℙ α :=
{ GradeOrder.liftLeft f hf hcovBy with isMax_grade := fun _ ha => hmax _ <| ha.grade _ } | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMaxOrder.liftLeft | Lifts a graded order along a strictly monotone function. |
GradeBoundedOrder.liftLeft [GradeBoundedOrder 𝕆 α] (f : 𝕆 → ℙ) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
(hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder ℙ α :=
{ GradeMinOrder.liftLeft f hf hcovBy hmin, GradeMaxOrder.liftLeft f hf hcovBy hmax with } | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeBoundedOrder.liftLeft | Lifts a graded order along a strictly monotone function. |
GradeOrder.liftRight [GradeOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) : GradeOrder 𝕆 α where
grade := grade 𝕆 ∘ f
grade_strictMono := grade_strictMono.comp hf
covBy_grade _ _ h := (hcovBy _ _ h).grade _ | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.liftRight | Lifts a graded order along a strictly monotone function. |
GradeMinOrder.liftRight [GradeMinOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a)) : GradeMinOrder 𝕆 α :=
{ GradeOrder.liftRight f hf hcovBy with isMin_grade := fun _ ha => (hmin _ ha).grade _ } | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMinOrder.liftRight | Lifts a graded order along a strictly monotone function. |
GradeMaxOrder.liftRight [GradeMaxOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmax : ∀ a, IsMax a → IsMax (f a)) : GradeMaxOrder 𝕆 α :=
{ GradeOrder.liftRight f hf hcovBy with isMax_grade := fun _ ha => (hmax _ ha).grade _ } | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMaxOrder.liftRight | Lifts a graded order along a strictly monotone function. |
GradeBoundedOrder.liftRight [GradeBoundedOrder 𝕆 β] (f : α → β) (hf : StrictMono f)
(hcovBy : ∀ a b, a ⋖ b → f a ⋖ f b) (hmin : ∀ a, IsMin a → IsMin (f a))
(hmax : ∀ a, IsMax a → IsMax (f a)) : GradeBoundedOrder 𝕆 α :=
{ GradeMinOrder.liftRight f hf hcovBy hmin, GradeMaxOrder.liftRight f hf hcovBy hmax with... | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeBoundedOrder.liftRight | Lifts a graded order along a strictly monotone function. |
GradeOrder.finToNat (n : ℕ) [GradeOrder (Fin n) α] : GradeOrder ℕ α :=
(GradeOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono) fun _ _ => CovBy.coe_fin | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.finToNat | A `Fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
inferable. |
GradeMinOrder.finToNat (n : ℕ) [GradeMinOrder (Fin n) α] : GradeMinOrder ℕ α :=
(GradeMinOrder.liftLeft (_ : Fin n → ℕ) Fin.val_strictMono fun _ _ => CovBy.coe_fin) fun a h => by
cases n
· exact a.elim0
rw [h.eq_bot, Fin.bot_eq_zero]
exact isMin_bot | abbrev | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeMinOrder.finToNat | A `Fin n`-graded order is also `ℕ`-graded. We do not mark this an instance because `n` is not
inferable. |
GradeOrder.natToInt [GradeOrder ℕ α] : GradeOrder ℤ α :=
(GradeOrder.liftLeft _ Int.natCast_strictMono) fun _ _ => CovBy.intCast | instance | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.natToInt | null |
GradeOrder.wellFoundedLT (𝕆 : Type*) [Preorder 𝕆] [GradeOrder 𝕆 α]
[WellFoundedLT 𝕆] : WellFoundedLT α :=
(grade_strictMono (𝕆 := 𝕆)).wellFoundedLT | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.wellFoundedLT | null |
GradeOrder.wellFoundedGT (𝕆 : Type*) [Preorder 𝕆] [GradeOrder 𝕆 α]
[WellFoundedGT 𝕆] : WellFoundedGT α :=
(grade_strictMono (𝕆 := 𝕆)).wellFoundedGT | theorem | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | GradeOrder.wellFoundedGT | null |
@[simp, norm_cast]
coe_wcovBy_coe : (a : α) ⩿ b ↔ a ⩿ b := by
refine and_congr_right' ⟨fun h c hac ↦ h hac, fun h c hac hcb ↦
@h ⟨c, mem_iff_forall_le_or_ge.2 fun d hd ↦ ?_⟩ hac hcb⟩
classical
obtain hda | had := le_or_gt (⟨d, hd⟩ : s) a
· exact .inr ((Subtype.coe_le_coe.2 hda).trans hac.le)
obtain hbd | ... | lemma | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | coe_wcovBy_coe | null |
coe_covBy_coe : (a : α) ⋖ b ↔ a ⋖ b := by simp [covBy_iff_wcovBy_and_not_le]
@[simp] | lemma | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | coe_covBy_coe | null |
isMax_coe : IsMax (a : α) ↔ IsMax a where
mp h b hab := h hab
mpr h b hab := by
refine @h ⟨b, mem_iff_forall_le_or_ge.2 fun c hc ↦ ?_⟩ hab
classical
exact .inr <| hab.trans' <| h.isTop ⟨c, hc⟩
@[simp] | lemma | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | isMax_coe | null |
isMin_coe : IsMin (a : α) ↔ IsMin a where
mp h b hba := h hba
mpr h b hba := by
refine @h ⟨b, mem_iff_forall_le_or_ge.2 fun c hc ↦ ?_⟩ hba
classical
exact .inl <| hba.trans <| h.isBot ⟨c, hc⟩
variable [Preorder 𝕆] | lemma | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | isMin_coe | null |
@[simp, norm_cast] grade_coe [GradeOrder 𝕆 α] (a : s) : grade 𝕆 (a : α) = grade 𝕆 a := rfl | lemma | Order | [
"Mathlib.Data.Int.SuccPred",
"Mathlib.Order.Fin.Basic"
] | Mathlib/Order/Grade.lean | grade_coe | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.