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 ⌀ |
|---|---|---|---|---|---|---|
@[simps]
insertNth (p : RelSeries r) (i : Fin p.length) (a : α)
(prev_connect : p (Fin.castSucc i) ~[r] a) (connect_next : a ~[r] p i.succ) : RelSeries r where
length := p.length + 1
toFun := (Fin.castSucc i.succ).insertNth a p
step m := by
set x := _; set y := _; change x ~[r] y
obtain hm | hm | hm :... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | insertNth | If `a₀ -r→ a₁ -r→ ... -r→ aₙ` is an `r`-series and `a` is such that
`aᵢ -r→ a -r→ a_ᵢ₊₁`, then
`a₀ -r→ a₁ -r→ ... -r→ aᵢ -r→ a -r→ aᵢ₊₁ -r→ ... -r→ aₙ`
is another `r`-series |
@[simps length]
reverse (p : RelSeries r) : RelSeries r.inv where
length := p.length
toFun := p ∘ Fin.rev
step i := by
rw [Function.comp_apply, Function.comp_apply, SetRel.mem_inv]
have hi : i.1 + 1 ≤ p.length := by omega
convert p.step ⟨p.length - (i.1 + 1), Nat.sub_lt_self (by omega) hi⟩
· ext; ... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | reverse | A relation series `a₀ -r→ a₁ -r→ ... -r→ aₙ` of `r` gives a relation series of the reverse of `r`
by reversing the series `aₙ ←r- aₙ₋₁ ←r- ... ←r- a₁ ←r- a₀`. |
@[simps! length]
cons (p : RelSeries r) (newHead : α) (rel : newHead ~[r] p.head) : RelSeries r :=
(singleton r newHead).append p rel
@[simp] lemma head_cons (p : RelSeries r) (newHead : α) (rel : newHead ~[r] p.head) :
(p.cons newHead rel).head = newHead := rfl
@[simp] lemma last_cons (p : RelSeries r) (newHead ... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | cons | Given a series `a₀ -r→ a₁ -r→ ... -r→ aₙ` and an `a` such that `a₀ -r→ a` holds, there is
a series of length `n+1`: `a -r→ a₀ -r→ a₁ -r→ ... -r→ aₙ`. |
cons_cast_succ (s : RelSeries r) (a : α) (h : a ~[r] s.head) (i : Fin (s.length + 1)) :
(s.cons a h) (.cast (by simp) (.succ i)) = s i := by
dsimp [cons]
convert append_apply_right (singleton r a) s h i
ext1
dsimp
omega
@[simp] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | cons_cast_succ | null |
append_singleton_left (p : RelSeries r) (x : α) (hx : x ~[r] p.head) :
(singleton r x).append p hx = p.cons x hx :=
rfl
@[simp] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | append_singleton_left | null |
toList_cons (p : RelSeries r) (x : α) (hx : x ~[r] p.head) :
(p.cons x hx).toList = x :: p.toList := by
rw [cons, toList_append]
simp | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | toList_cons | null |
fromListIsChain_cons (l : List α) (l_ne_nil : l ≠ [])
(hl : l.IsChain (· ~[r] ·)) (x : α) (hx : x ~[r] l.head l_ne_nil) :
fromListIsChain (x :: l) (by simp) (hl.cons_of_ne_nil l_ne_nil hx) =
(fromListIsChain l l_ne_nil hl).cons x (by simpa) := by
apply toList_injective
simp
@[deprecated (since := "202... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | fromListIsChain_cons | null |
append_cons {p q : RelSeries r} {x : α} (hx : x ~[r] p.head) (hq : p.last ~[r] q.head) :
(p.cons x hx).append q (by simpa) = (p.append q hq).cons x (by simpa) := by
simp only [cons]
rw [append_assoc] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | append_cons | null |
@[simps! length]
snoc (p : RelSeries r) (newLast : α) (rel : p.last ~[r] newLast) : RelSeries r :=
p.append (singleton r newLast) rel
@[simp] lemma head_snoc (p : RelSeries r) (newLast : α) (rel : p.last ~[r] newLast) :
(p.snoc newLast rel).head = p.head := by
delta snoc; rw [head_append]
@[simp] lemma last_sno... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | snoc | Given a series `a₀ -r→ a₁ -r→ ... -r→ aₙ` and an `a` such that `aₙ -r→ a` holds, there is
a series of length `n+1`: `a₀ -r→ a₁ -r→ ... -r→ aₙ -r→ a`. |
snoc_cast_castSucc (s : RelSeries r) (a : α) (h : s.last ~[r] a) (i : Fin (s.length + 1)) :
(s.snoc a h) (.cast (by simp) (.castSucc i)) = s i :=
append_apply_left s (singleton r a) h i
@[simp] lemma last_snoc' (p : RelSeries r) (newLast : α) (rel : p.last ~[r] newLast) :
p.snoc newLast rel (Fin.last (p.lengt... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | snoc_cast_castSucc | null |
mem_snoc {p : RelSeries r} {newLast : α} {rel : p.last ~[r] newLast} {x : α} :
x ∈ p.snoc newLast rel ↔ x ∈ p ∨ x = newLast := by
simp only [snoc, append, singleton_length, Nat.add_zero, Nat.reduceAdd, Fin.cast_refl,
Function.comp_id, mem_def, Set.mem_range]
constructor
· rintro ⟨i, rfl⟩
exact Fin.las... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | mem_snoc | null |
@[simps]
tail (p : RelSeries r) (len_pos : p.length ≠ 0) : RelSeries r where
length := p.length - 1
toFun := Fin.tail p ∘ (Fin.cast <| Nat.succ_pred_eq_of_pos <| Nat.pos_of_ne_zero len_pos)
step i := p.step ⟨i.1 + 1, Nat.lt_pred_iff.mp i.2⟩
@[simp] lemma head_tail (p : RelSeries r) (len_pos : p.length ≠ 0) :
... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | tail | If a series `a₀ -r→ a₁ -r→ ...` has positive length, then `a₁ -r→ ...` is another series |
toList_tail {p : RelSeries r} (hp : p.length ≠ 0) : (p.tail hp).toList = p.toList.tail := by
refine List.ext_getElem ?_ fun i h1 h2 ↦ ?_
· simp
cutsat
· rw [List.getElem_tail, toList_getElem_eq_apply_of_lt_length (by simp_all),
toList_getElem_eq_apply_of_lt_length (by simp_all)]
simp_all [Fin.tail]
... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | toList_tail | null |
tail_cons (p : RelSeries r) (x : α) (hx : x ~[r] p.head) :
(p.cons x hx).tail (by simp) = p := by
apply toList_injective
simp | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | tail_cons | null |
cons_self_tail {p : RelSeries r} (hp : p.length ≠ 0) :
(p.tail hp).cons p.head (p.3 ⟨0, Nat.zero_lt_of_ne_zero hp⟩) = p := by
apply toList_injective
simp [← head_toList] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | cons_self_tail | null |
@[elab_as_elim]
inductionOn (motive : RelSeries r → Sort*)
(singleton : (x : α) → motive (RelSeries.singleton r x))
(cons : (p : RelSeries r) → (x : α) → (hx : x ~[r] p.head) → (hp : motive p) →
motive (p.cons x hx)) (p : RelSeries r) :
motive p := by
let this {n : ℕ} (heq : p.length = n) : motive p... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | inductionOn | To show a proposition `p` for `xs : RelSeries r` it suffices to show it for all singletons
and to show that when `p` holds for `xs` it also holds for `xs` prepended with one element.
Note: This can also be used to construct data, but it does not have good definitional properties,
since `(p.cons x hx).tail _ = p` is no... |
toList_snoc (p : RelSeries r) (newLast : α) (rel : p.last ~[r] newLast) :
(p.snoc newLast rel).toList = p.toList ++ [newLast] := by
simp [snoc] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | toList_snoc | null |
@[simps]
eraseLast (p : RelSeries r) : RelSeries r where
length := p.length - 1
toFun i := p ⟨i, lt_of_lt_of_le i.2 (Nat.succ_le_succ (Nat.sub_le _ _))⟩
step i := p.step ⟨i, lt_of_lt_of_le i.2 (Nat.sub_le _ _)⟩
@[simp] lemma head_eraseLast (p : RelSeries r) : p.eraseLast.head = p.head := rfl
@[simp] lemma last_er... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | eraseLast | If a series ``a₀ -r→ a₁ -r→ ... -r→ aₙ``, then `a₀ -r→ a₁ -r→ ... -r→ aₙ₋₁` is
another series |
eraseLast_last_rel_last (p : RelSeries r) (h : p.length ≠ 0) :
p.eraseLast.last ~[r] p.last := by
simp only [last, Fin.last, eraseLast_length, eraseLast_toFun]
convert p.step ⟨p.length - 1, by cutsat⟩
simp only [Fin.succ_mk]; cutsat
@[simp] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | eraseLast_last_rel_last | In a non-trivial series `p`, the last element of `p.eraseLast` is related to `p.last` |
toList_eraseLast (p : RelSeries r) (hp : p.length ≠ 0) :
p.eraseLast.toList = p.toList.dropLast := by
apply List.ext_getElem
· simpa using Nat.succ_pred_eq_of_ne_zero hp
· intro i hi h2
rw [toList_getElem_eq_apply_of_lt_length (hi.trans_eq (by simp))]
simp [← toList_getElem_eq_apply_of_lt_length] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | toList_eraseLast | null |
snoc_self_eraseLast (p : RelSeries r) (h : p.length ≠ 0) :
p.eraseLast.snoc p.last (p.eraseLast_last_rel_last h) = p := by
apply toList_injective
rw [toList_snoc, ← getLast_toList, toList_eraseLast _ h, List.dropLast_append_getLast] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | snoc_self_eraseLast | null |
@[elab_as_elim]
inductionOn' (motive : RelSeries r → Sort*)
(singleton : (x : α) → motive (RelSeries.singleton r x))
(snoc : (p : RelSeries r) → (x : α) → (hx : p.last ~[r] x) → (hp : motive p) →
motive (p.snoc x hx)) (p : RelSeries r) :
motive p := by
let this {n : ℕ} (heq : p.length = n) : motive ... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | inductionOn' | To show a proposition `p` for `xs : RelSeries r` it suffices to show it for all singletons
and to show that when `p` holds for `xs` it also holds for `xs` appended with one element. |
@[simps length]
smash (p q : RelSeries r) (connect : p.last = q.head) : RelSeries r where
length := p.length + q.length
toFun := Fin.addCases (m := p.length) (n := q.length + 1) (p ∘ Fin.castSucc) q
step := by
apply Fin.addCases <;> intro i
· simp_rw [Fin.castSucc_castAdd, Fin.addCases_left, Fin.succ_cast... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash | Given two series of the form `a₀ -r→ ... -r→ X` and `X -r→ b ---> ...`,
then `a₀ -r→ ... -r→ X -r→ b ...` is another series obtained by combining the given two. |
smash_castLE {p q : RelSeries r} (h : p.last = q.head) (i : Fin (p.length + 1)) :
p.smash q h (i.castLE (by simp)) = p i := by
refine i.lastCases ?_ fun _ ↦ by dsimp only [smash]; apply Fin.addCases_left
change p.smash q h (Fin.natAdd p.length (0 : Fin (q.length + 1))) = _
simpa only [smash, Fin.addCases_righ... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash_castLE | null |
smash_castAdd {p q : RelSeries r} (h : p.last = q.head) (i : Fin p.length) :
p.smash q h (i.castAdd q.length).castSucc = p i.castSucc :=
smash_castLE h i.castSucc | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash_castAdd | null |
smash_succ_castAdd {p q : RelSeries r} (h : p.last = q.head)
(i : Fin p.length) : p.smash q h (i.castAdd q.length).succ = p i.succ :=
smash_castLE h i.succ | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash_succ_castAdd | null |
smash_natAdd {p q : RelSeries r} (h : p.last = q.head) (i : Fin q.length) :
smash p q h (i.natAdd p.length).castSucc = q i.castSucc := by
dsimp only [smash, Fin.castSucc_natAdd]
apply Fin.addCases_right | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash_natAdd | null |
smash_succ_natAdd {p q : RelSeries r} (h : p.last = q.head) (i : Fin q.length) :
smash p q h (i.natAdd p.length).succ = q i.succ := by
dsimp only [smash, Fin.succ_natAdd]
apply Fin.addCases_right
@[simp] lemma head_smash {p q : RelSeries r} (h : p.last = q.head) :
(smash p q h).head = p.head := by
obtain ... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | smash_succ_natAdd | null |
@[simps! length]
take {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length + 1)) : RelSeries r where
length := i
toFun := fun ⟨j, h⟩ => p.toFun ⟨j, by omega⟩
step := fun ⟨j, h⟩ => p.step ⟨j, by omega⟩
@[simp] | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | take | Given the series `a₀ -r→ … -r→ aᵢ -r→ … -r→ aₙ`, the series `a₀ -r→ … -r→ aᵢ`. |
head_take (p : RelSeries r) (i : Fin (p.length + 1)) :
(p.take i).head = p.head := by simp [take, head]
@[simp] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_take | null |
last_take (p : RelSeries r) (i : Fin (p.length + 1)) :
(p.take i).last = p i := by simp [take, last, Fin.last] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | last_take | null |
@[simps! length]
drop (p : RelSeries r) (i : Fin (p.length + 1)) : RelSeries r where
length := p.length - i
toFun := fun ⟨j, h⟩ => p.toFun ⟨j+i, by omega⟩
step := fun ⟨j, h⟩ => by
convert p.step ⟨j+i.1, by omega⟩
simp only [Fin.succ_mk]; omega
@[simp] | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | drop | Given the series `a₀ -r→ … -r→ aᵢ -r→ … -r→ aₙ`, the series `aᵢ₊₁ -r→ … -r→ aₙ`. |
head_drop (p : RelSeries r) (i : Fin (p.length + 1)) : (p.drop i).head = p.toFun i := by
simp [drop, head]
@[simp] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_drop | null |
last_drop (p : RelSeries r) (i : Fin (p.length + 1)) : (p.drop i).last = p.last := by
simp only [last, drop, Fin.last]
congr
cutsat | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | last_drop | null |
SetRel.not_finiteDimensional_iff [Nonempty α] :
¬ r.FiniteDimensional ↔ r.InfiniteDimensional := by
rw [finiteDimensional_iff, infiniteDimensional_iff]
push_neg
constructor
· intro H n
induction n with
| zero => refine ⟨⟨0, ![_root_.Nonempty.some ‹_›], by simp⟩, by simp⟩
| succ n IH =>
obt... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.not_finiteDimensional_iff | null |
SetRel.not_infiniteDimensional_iff [Nonempty α] :
¬ r.InfiniteDimensional ↔ r.FiniteDimensional := by
rw [← not_finiteDimensional_iff, not_not] | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.not_infiniteDimensional_iff | null |
SetRel.finiteDimensional_or_infiniteDimensional [Nonempty α] :
r.FiniteDimensional ∨ r.InfiniteDimensional := by
rw [← not_finiteDimensional_iff]
exact em r.FiniteDimensional | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.finiteDimensional_or_infiniteDimensional | null |
SetRel.FiniteDimensional.inv [FiniteDimensional r] : FiniteDimensional r.inv :=
⟨.reverse (.longestOf r), fun s ↦ s.reverse.length_le_length_longestOf r⟩
variable {r} in
@[simp] | instance | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.FiniteDimensional.inv | null |
SetRel.finiteDimensional_inv : FiniteDimensional r.inv ↔ FiniteDimensional r :=
⟨fun _ ↦ .inv r.inv, fun _ ↦ .inv _⟩
@[deprecated (since := "2025-07-06")]
alias SetRel.finiteDimensional_swap_iff := SetRel.finiteDimensional_inv | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.finiteDimensional_inv | null |
SetRel.InfiniteDimensional.inv [InfiniteDimensional r] : InfiniteDimensional r.inv :=
⟨fun n ↦ ⟨.reverse (.withLength r n), RelSeries.length_withLength r n⟩⟩
variable {r} in
@[simp] | instance | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.InfiniteDimensional.inv | null |
SetRel.infiniteDimensional_inv : InfiniteDimensional r.inv ↔ InfiniteDimensional r :=
⟨fun _ ↦ .inv r.inv, fun _ ↦ .inv _⟩
@[deprecated (since := "2025-07-06")]
alias SetRel.infiniteDimensional_swap_iff := SetRel.infiniteDimensional_inv | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.infiniteDimensional_inv | null |
SetRel.IsWellFounded.inv_of_finiteDimensional [r.FiniteDimensional] :
r.inv.IsWellFounded := by
rw [IsWellFounded, wellFounded_iff_isEmpty_descending_chain]
refine ⟨fun ⟨f, hf⟩ ↦ ?_⟩
let s := RelSeries.mk (r := r) ((RelSeries.longestOf r).length + 1) (f ·) (hf ·)
exact (RelSeries.longestOf r).length.lt_succ... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.IsWellFounded.inv_of_finiteDimensional | null |
SetRel.IsWellFounded.of_finiteDimensional [r.FiniteDimensional] : r.IsWellFounded :=
.inv_of_finiteDimensional r.inv
@[deprecated (since := "2025-07-06")]
alias SetRel.wellFounded_of_finiteDimensional := SetRel.IsWellFounded.of_finiteDimensional | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | SetRel.IsWellFounded.of_finiteDimensional | null |
FiniteDimensionalOrder (γ : Type*) [Preorder γ] :=
SetRel.FiniteDimensional {(a, b) : γ × γ | a < b} | abbrev | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | FiniteDimensionalOrder | A type is finite dimensional if its `LTSeries` has bounded length. |
FiniteDimensionalOrder.ofUnique (γ : Type*) [Preorder γ] [Unique γ] :
FiniteDimensionalOrder γ where
exists_longest_relSeries := ⟨.singleton _ default, fun x ↦ by
by_contra! r
exact (x.step ⟨0, by omega⟩).ne <| Subsingleton.elim _ _⟩ | instance | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | FiniteDimensionalOrder.ofUnique | null |
InfiniteDimensionalOrder (γ : Type*) [Preorder γ] :=
SetRel.InfiniteDimensional {(a, b) : γ × γ | a < b} | abbrev | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | InfiniteDimensionalOrder | A type is infinite dimensional if it has `LTSeries` of at least arbitrary length |
LTSeries := RelSeries {(a, b) : α × α | a < b} | abbrev | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | LTSeries | If `α` is a preorder, a LTSeries is a relation series of the less than relation. |
protected noncomputable longestOf [FiniteDimensionalOrder α] : LTSeries α :=
RelSeries.longestOf _ | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | longestOf | The longest `<`-series when a type is finite dimensional |
protected noncomputable withLength [InfiniteDimensionalOrder α] (n : ℕ) : LTSeries α :=
RelSeries.withLength _ n
@[simp] lemma length_withLength [InfiniteDimensionalOrder α] (n : ℕ) :
(LTSeries.withLength α n).length = n :=
RelSeries.length_withLength _ _ | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | withLength | A `<`-series with length `n` if the relation is infinite dimensional |
nonempty_of_infiniteDimensionalOrder [InfiniteDimensionalOrder α] : Nonempty α :=
⟨LTSeries.withLength α 0 0⟩
@[deprecated (since := "2025-03-01")]
alias nonempty_of_infiniteDimensionalType := nonempty_of_infiniteDimensionalOrder | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | nonempty_of_infiniteDimensionalOrder | if `α` is infinite dimensional, then `α` is nonempty. |
nonempty_of_finiteDimensionalOrder [FiniteDimensionalOrder α] : Nonempty α := by
obtain ⟨p, _⟩ := (SetRel.finiteDimensional_iff _).mp ‹_›
exact ⟨p 0⟩
variable {α} | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | nonempty_of_finiteDimensionalOrder | null |
longestOf_is_longest [FiniteDimensionalOrder α] (x : LTSeries α) :
x.length ≤ (LTSeries.longestOf α).length :=
RelSeries.length_le_length_longestOf _ _ | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | longestOf_is_longest | null |
longestOf_len_unique [FiniteDimensionalOrder α] (p : LTSeries α)
(is_longest : ∀ (q : LTSeries α), q.length ≤ p.length) :
p.length = (LTSeries.longestOf α).length :=
le_antisymm (longestOf_is_longest _) (is_longest _) | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | longestOf_len_unique | null |
strictMono (x : LTSeries α) : StrictMono x :=
fun _ _ h => x.rel_of_lt h | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | strictMono | null |
monotone (x : LTSeries α) : Monotone x :=
x.strictMono.monotone | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | monotone | null |
head_le (x : LTSeries α) (n : Fin (x.length + 1)) : x.head ≤ x n :=
x.monotone (Fin.zero_le n) | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_le | null |
head_le_last (x : LTSeries α) : x.head ≤ x.last := x.head_le _ | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_le_last | null |
@[simps]
mk (length : ℕ) (toFun : Fin (length + 1) → α) (strictMono : StrictMono toFun) :
LTSeries α where
length := length
toFun := toFun
step i := strictMono <| lt_add_one i.1 | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | mk | An alternative constructor of `LTSeries` from a strictly monotone function. |
injStrictMono (n : ℕ) :
{f : (l : Fin n) × (Fin (l + 1) → α) // StrictMono f.2} ↪ LTSeries α where
toFun f := mk f.1.1 f.1.2 f.2
inj' f g e := by
obtain ⟨⟨lf, f⟩, mf⟩ := f
obtain ⟨⟨lg, g⟩, mg⟩ := g
dsimp only at mf mg e
have leq := congr($(e).length)
rw [mk_length lf f mf, mk_length lg g mg,... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | injStrictMono | An injection from the type of strictly monotone functions with limited length to `LTSeries`. |
@[simps!]
map (p : LTSeries α) (f : α → β) (hf : StrictMono f) : LTSeries β :=
LTSeries.mk p.length (f.comp p) (hf.comp p.strictMono)
@[simp] lemma head_map (p : LTSeries α) (f : α → β) (hf : StrictMono f) :
(p.map f hf).head = f p.head := rfl
@[simp] lemma last_map (p : LTSeries α) (f : α → β) (hf : StrictMono f... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | map | For two preorders `α, β`, if `f : α → β` is strictly monotonic, then a strict chain of `α`
can be pushed out to a strict chain of `β` by
`a₀ < a₁ < ... < aₙ ↦ f a₀ < f a₁ < ... < f aₙ` |
@[simps!]
noncomputable comap (p : LTSeries β) (f : α → β)
(comap : ∀ ⦃x y⦄, f x < f y → x < y)
(surjective : Function.Surjective f) :
LTSeries α :=
mk p.length (fun i ↦ (surjective (p i)).choose)
(fun i j h ↦ comap (by simpa only [(surjective _).choose_spec] using p.strictMono h)) | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | comap | For two preorders `α, β`, if `f : α → β` is surjective and strictly comonotonic, then a
strict series of `β` can be pulled back to a strict chain of `α` by
`b₀ < b₁ < ... < bₙ ↦ f⁻¹ b₀ < f⁻¹ b₁ < ... < f⁻¹ bₙ` where `f⁻¹ bᵢ` is an arbitrary element in the
preimage of `f⁻¹ {bᵢ}`. |
range (n : ℕ) : LTSeries ℕ where
length := n
toFun := fun i => i
step i := Nat.lt_add_one i
@[simp] lemma length_range (n : ℕ) : (range n).length = n := rfl
@[simp] lemma range_apply (n : ℕ) (i : Fin (n + 1)) : (range n) i = i := rfl
@[simp] lemma head_range (n : ℕ) : (range n).head = 0 := rfl
@[simp] lemma last_... | def | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | range | The strict series `0 < … < n` in `ℕ`. |
exists_relSeries_covBy
{α} [PartialOrder α] [WellFoundedLT α] [WellFoundedGT α] (s : LTSeries α) :
∃ (t : RelSeries {(a, b) : α × α | a ⋖ b}) (i : Fin (s.length + 1) ↪ Fin (t.length + 1)),
t ∘ i = s ∧ i 0 = 0 ∧ i (.last _) = .last _ := by
obtain ⟨n, s, h⟩ := s
induction n with
| zero => exact ⟨⟨0, s... | theorem | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | exists_relSeries_covBy | Any `LTSeries` can be refined to a `CovBy`-`RelSeries`
in a bidirectionally well-founded order. |
exists_relSeries_covBy_and_head_eq_bot_and_last_eq_bot
{α} [PartialOrder α] [BoundedOrder α] [WellFoundedLT α] [WellFoundedGT α] (s : LTSeries α) :
∃ (t : RelSeries {(a, b) : α × α | a ⋖ b}) (i : Fin (s.length + 1) ↪ Fin (t.length + 1)),
t ∘ i = s ∧ t.head = ⊥ ∧ t.last = ⊤ := by
wlog h₁ : s.head = ⊥
·... | theorem | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | exists_relSeries_covBy_and_head_eq_bot_and_last_eq_bot | null |
apply_add_index_le_apply_add_index_nat (p : LTSeries ℕ) (i j : Fin (p.length + 1))
(hij : i ≤ j) : p i + j ≤ p j + i := by
have ⟨i, hi⟩ := i
have ⟨j, hj⟩ := j
simp only [Fin.mk_le_mk] at hij
simp only at *
induction j, hij using Nat.le_induction with
| base => simp
| succ j _hij ih =>
specialize i... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | apply_add_index_le_apply_add_index_nat | In ℕ, two entries in an `LTSeries` differ by at least the difference of their indices.
(Expressed in a way that avoids subtraction). |
apply_add_index_le_apply_add_index_int (p : LTSeries ℤ) (i j : Fin (p.length + 1))
(hij : i ≤ j) : p i + j ≤ p j + i := by
have ⟨i, hi⟩ := i
have ⟨j, hj⟩ := j
simp only [Fin.mk_le_mk] at hij
simp only at *
induction j, hij using Nat.le_induction with
| base => simp
| succ j _hij ih =>
specialize i... | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | apply_add_index_le_apply_add_index_int | In ℤ, two entries in an `LTSeries` differ by at least the difference of their indices.
(Expressed in a way that avoids subtraction). |
head_add_length_le_nat (p : LTSeries ℕ) : p.head + p.length ≤ p.last :=
LTSeries.apply_add_index_le_apply_add_index_nat _ _ (Fin.last _) (Fin.zero_le _) | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_add_length_le_nat | In ℕ, the head and tail of an `LTSeries` differ at least by the length of the series |
head_add_length_le_int (p : LTSeries ℤ) : p.head + p.length ≤ p.last := by
simpa using LTSeries.apply_add_index_le_apply_add_index_int _ _ (Fin.last _) (Fin.zero_le _) | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | head_add_length_le_int | In ℤ, the head and tail of an `LTSeries` differ at least by the length of the series |
length_lt_card (s : LTSeries α) : s.length < Fintype.card α := by
by_contra! h
obtain ⟨i, j, hn, he⟩ := Fintype.exists_ne_map_eq_of_card_lt s (by rw [Fintype.card_fin]; cutsat)
wlog hl : i < j generalizing i j
· exact this j i hn.symm he.symm (by cutsat)
exact absurd he (s.strictMono hl).ne | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | length_lt_card | null |
not_finiteDimensionalOrder_iff [Preorder α] [Nonempty α] :
¬ FiniteDimensionalOrder α ↔ InfiniteDimensionalOrder α :=
SetRel.not_finiteDimensional_iff | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | not_finiteDimensionalOrder_iff | null |
not_infiniteDimensionalOrder_iff [Preorder α] [Nonempty α] :
¬ InfiniteDimensionalOrder α ↔ FiniteDimensionalOrder α :=
SetRel.not_infiniteDimensional_iff
variable (α) in | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | not_infiniteDimensionalOrder_iff | null |
finiteDimensionalOrder_or_infiniteDimensionalOrder [Preorder α] [Nonempty α] :
FiniteDimensionalOrder α ∨ InfiniteDimensionalOrder α :=
SetRel.finiteDimensional_or_infiniteDimensional _ | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | finiteDimensionalOrder_or_infiniteDimensionalOrder | null |
infiniteDimensionalOrder_of_strictMono [Preorder α] [Preorder β]
(f : α → β) (hf : StrictMono f) [InfiniteDimensionalOrder α] :
InfiniteDimensionalOrder β :=
⟨fun n ↦ ⟨(LTSeries.withLength _ n).map f hf, LTSeries.length_withLength α n⟩⟩ | lemma | Order | [
"Mathlib.Algebra.Order.Ring.Nat",
"Mathlib.Data.Fin.VecNotation",
"Mathlib.Data.Fintype.Pi",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Data.Fintype.Sigma",
"Mathlib.Data.Rel",
"Mathlib.Order.OrderIsoNat"
] | Mathlib/Order/RelSeries.lean | infiniteDimensionalOrder_of_strictMono | If `f : α → β` is a strictly monotonic function and `α` is an infinite-dimensional type then so
is `β`. |
restrictLe (a : α) := (Iic a).restrict (π := π)
@[simp] | def | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe | Restrict domain of a function `f` indexed by `α` to elements `≤ a`. |
restrictLe_apply (a : α) (f : (a : α) → π a) (i : Iic a) : restrictLe a f i = f i := rfl | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe_apply | null |
restrictLe₂ {a b : α} (hab : a ≤ b) := Set.restrict₂ (π := π) (Iic_subset_Iic.2 hab)
@[simp] | def | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe₂ | If a function `f` indexed by `α` is restricted to elements `≤ π`, and `a ≤ b`,
this is the restriction to elements `≤ a`. |
restrictLe₂_apply {a b : α} (hab : a ≤ b) (f : (i : Iic b) → π i) (i : Iic a) :
restrictLe₂ hab f i = f ⟨i.1, Iic_subset_Iic.2 hab i.2⟩ := rfl | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe₂_apply | null |
restrictLe₂_comp_restrictLe {a b : α} (hab : a ≤ b) :
(restrictLe₂ (π := π) hab) ∘ (restrictLe b) = restrictLe a := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe₂_comp_restrictLe | null |
restrictLe₂_comp_restrictLe₂ {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) :
(restrictLe₂ (π := π) hab) ∘ (restrictLe₂ hbc) = restrictLe₂ (hab.trans hbc) := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | restrictLe₂_comp_restrictLe₂ | null |
dependsOn_restrictLe (a : α) : DependsOn (restrictLe (π := π) a) (Iic a) :=
(Iic a).dependsOn_restrict | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | dependsOn_restrictLe | null |
frestrictLe (a : α) := (Iic a).restrict (π := π)
@[simp] | def | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe | Restrict domain of a function `f` indexed by `α` to elements `≤ a`, seen as a finite set. |
frestrictLe_apply (a : α) (f : (a : α) → π a) (i : Iic a) : frestrictLe a f i = f i := rfl | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe_apply | null |
frestrictLe₂ {a b : α} (hab : a ≤ b) := restrict₂ (π := π) (Iic_subset_Iic.2 hab)
@[simp] | def | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe₂ | If a function `f` indexed by `α` is restricted to elements `≤ b`, and `a ≤ b`,
this is the restriction to elements `≤ b`. Intervals are seen as finite sets. |
frestrictLe₂_apply {a b : α} (hab : a ≤ b) (f : (i : Iic b) → π i) (i : Iic a) :
frestrictLe₂ hab f i = f ⟨i.1, Iic_subset_Iic.2 hab i.2⟩ := rfl | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe₂_apply | null |
frestrictLe₂_comp_frestrictLe {a b : α} (hab : a ≤ b) :
(frestrictLe₂ (π := π) hab) ∘ (frestrictLe b) = frestrictLe a := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe₂_comp_frestrictLe | null |
frestrictLe₂_comp_frestrictLe₂ {a b c : α} (hab : a ≤ b) (hbc : b ≤ c) :
(frestrictLe₂ (π := π) hab) ∘ (frestrictLe₂ hbc) = frestrictLe₂ (hab.trans hbc) := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe₂_comp_frestrictLe₂ | null |
piCongrLeft_comp_restrictLe {a : α} :
((Equiv.IicFinsetSet a).symm.piCongrLeft (fun i : Iic a ↦ π i)) ∘ (restrictLe a) =
frestrictLe a := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | piCongrLeft_comp_restrictLe | null |
piCongrLeft_comp_frestrictLe {a : α} :
((Equiv.IicFinsetSet a).piCongrLeft (fun i : Set.Iic a ↦ π i)) ∘ (frestrictLe a) =
restrictLe a := rfl | theorem | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | piCongrLeft_comp_frestrictLe | null |
frestrictLe_updateFinset_of_le {a b : α} (hab : a ≤ b) (x : Π c, π c) (y : Π c : Iic b, π c) :
frestrictLe a (updateFinset x _ y) = frestrictLe₂ hab y :=
restrict_updateFinset_of_subset (Iic_subset_Iic.2 hab) .. | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe_updateFinset_of_le | null |
frestrictLe_updateFinset {a : α} (x : Π a, π a) (y : Π b : Iic a, π b) :
frestrictLe a (updateFinset x _ y) = y := restrict_updateFinset ..
@[simp] | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | frestrictLe_updateFinset | null |
updateFinset_frestrictLe (a : α) (x : Π a, π a) : updateFinset x _ (frestrictLe a x) = x := by
simp [frestrictLe] | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | updateFinset_frestrictLe | null |
dependsOn_frestrictLe (a : α) : DependsOn (frestrictLe (π := π) a) (Set.Iic a) :=
coe_Iic a ▸ (Finset.Iic a).dependsOn_restrict | lemma | Order | [
"Mathlib.Data.Finset.Update",
"Mathlib.Order.Interval.Finset.Basic"
] | Mathlib/Order/Restriction.lean | dependsOn_frestrictLe | null |
ScottContinuousOn (D : Set (Set α)) (f : α → β) : Prop :=
∀ ⦃d : Set α⦄, d ∈ D → d.Nonempty → DirectedOn (· ≤ ·) d → ∀ ⦃a⦄, IsLUB d a → IsLUB (f '' d) (f a) | def | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuousOn | A function between preorders is said to be Scott continuous on a set `D` of directed sets if it
preserves `IsLUB` on elements of `D`.
The dual notion
```lean
∀ ⦃d : Set α⦄, d ∈ D → d.Nonempty → DirectedOn (· ≥ ·) d → ∀ ⦃a⦄, IsGLB d a → IsGLB (f '' d) (f a)
```
does not appear to play a significant role in the liter... |
ScottContinuousOn.mono (hD : D₁ ⊆ D₂) (hf : ScottContinuousOn D₂ f) :
ScottContinuousOn D₁ f := fun _ hdD₁ hd₁ hd₂ _ hda => hf (hD hdD₁) hd₁ hd₂ hda | lemma | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuousOn.mono | null |
protected ScottContinuousOn.monotone (D : Set (Set α)) (hD : ∀ a b : α, a ≤ b → {a, b} ∈ D)
(h : ScottContinuousOn D f) : Monotone f := by
refine fun a b hab =>
(h (hD a b hab) (insert_nonempty _ _) (directedOn_pair le_refl hab) ?_).1
(mem_image_of_mem _ <| mem_insert _ _)
rw [IsLUB, upperBounds_inser... | theorem | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuousOn.monotone | null |
ScottContinuousOn.prodMk (hD : ∀ a b : α, a ≤ b → {a, b} ∈ D)
(hf : ScottContinuousOn D f) (hg : ScottContinuousOn D g) :
ScottContinuousOn D fun x => (f x, g x) := fun d hd₁ hd₂ hd₃ a hda => by
rw [IsLUB, IsLeast, upperBounds]
constructor
· simp only [mem_image, forall_exists_index, and_imp, forall_apply... | lemma | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuousOn.prodMk | null |
ScottContinuous (f : α → β) : Prop :=
∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → ∀ ⦃a⦄, IsLUB d a → IsLUB (f '' d) (f a)
@[simp] lemma scottContinuousOn_univ : ScottContinuousOn univ f ↔ ScottContinuous f := by
simp [ScottContinuousOn, ScottContinuous] | def | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuous | A function between preorders is said to be Scott continuous if it preserves `IsLUB` on directed
sets. It can be shown that a function is Scott continuous if and only if it is continuous w.r.t. the
Scott topology. |
ScottContinuous.scottContinuousOn {D : Set (Set α)} :
ScottContinuous f → ScottContinuousOn D f := fun h _ _ d₂ d₃ _ hda => h d₂ d₃ hda | lemma | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuous.scottContinuousOn | null |
protected ScottContinuous.monotone (h : ScottContinuous f) : Monotone f :=
h.scottContinuousOn.monotone univ (fun _ _ _ ↦ mem_univ _)
@[simp] lemma ScottContinuous.id : ScottContinuous (id : α → α) := by simp [ScottContinuous] | theorem | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuous.monotone | null |
ScottContinuous.sup₂ :
ScottContinuous fun b : β × β => (b.1 ⊔ b.2 : β) := fun d _ _ ⟨p₁, p₂⟩ hdp => by
simp only [IsLUB, IsLeast, upperBounds, Prod.forall, mem_setOf_eq, Prod.mk_le_mk] at hdp
simp only [IsLUB, IsLeast, upperBounds, mem_image, Prod.exists, forall_exists_index, and_imp]
have e1 : (p₁, p₂) ∈ lo... | lemma | Order | [
"Mathlib.Order.Bounds.Basic"
] | Mathlib/Order/ScottContinuity.lean | ScottContinuous.sup₂ | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.