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 ⌀ |
|---|---|---|---|---|---|---|
isAntisymm [IsAntisymm α r] {f : β → α} (hf : f.Injective) :
IsAntisymm β (f ⁻¹'o r) :=
⟨fun _ _ h₁ h₂ ↦ hf <| antisymm_of r h₁ h₂⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | isAntisymm | null |
IsNonstrictStrictOrder (α : Type*) (r : semiOutParam (α → α → Prop)) (s : α → α → Prop) :
Prop where
/-- The relation `r` is the nonstrict relation corresponding to the strict relation `s`. -/
right_iff_left_not_left (a b : α) : s a b ↔ r a b ∧ ¬r b a | class | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsNonstrictStrictOrder | An unbundled relation class stating that `r` is the nonstrict relation corresponding to the
strict relation `s`. Compare `Preorder.lt_iff_le_not_ge`. This is mostly meant to provide dot
notation on `(⊆)` and `(⊂)`. |
right_iff_left_not_left {r s : α → α → Prop} [IsNonstrictStrictOrder α r s] {a b : α} :
s a b ↔ r a b ∧ ¬r b a :=
IsNonstrictStrictOrder.right_iff_left_not_left _ _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | right_iff_left_not_left | null |
right_iff_left_not_left_of (r s : α → α → Prop) [IsNonstrictStrictOrder α r s] {a b : α} :
s a b ↔ r a b ∧ ¬r b a :=
right_iff_left_not_left | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | right_iff_left_not_left_of | A version of `right_iff_left_not_left` with explicit `r` and `s`. |
subset_of_eq_of_subset (hab : a = b) (hbc : b ⊆ c) : a ⊆ c := by rwa [hab] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_of_eq_of_subset | null |
subset_of_subset_of_eq (hab : a ⊆ b) (hbc : b = c) : a ⊆ c := by rwa [← hbc]
@[refl, simp] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_of_subset_of_eq | null |
subset_refl [IsRefl α (· ⊆ ·)] (a : α) : a ⊆ a := refl _ | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_refl | null |
subset_rfl [IsRefl α (· ⊆ ·)] : a ⊆ a := refl _ | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_rfl | null |
subset_of_eq [IsRefl α (· ⊆ ·)] : a = b → a ⊆ b := fun h => h ▸ subset_rfl | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_of_eq | null |
superset_of_eq [IsRefl α (· ⊆ ·)] : a = b → b ⊆ a := fun h => h ▸ subset_rfl | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | superset_of_eq | null |
ne_of_not_subset [IsRefl α (· ⊆ ·)] : ¬a ⊆ b → a ≠ b := mt subset_of_eq | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ne_of_not_subset | null |
ne_of_not_superset [IsRefl α (· ⊆ ·)] : ¬a ⊆ b → b ≠ a := mt superset_of_eq
@[trans] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ne_of_not_superset | null |
subset_trans [IsTrans α (· ⊆ ·)] {a b c : α} : a ⊆ b → b ⊆ c → a ⊆ c := _root_.trans | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_trans | null |
subset_antisymm [IsAntisymm α (· ⊆ ·)] : a ⊆ b → b ⊆ a → a = b := antisymm | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_antisymm | null |
superset_antisymm [IsAntisymm α (· ⊆ ·)] : a ⊆ b → b ⊆ a → b = a := antisymm'
alias Eq.trans_subset := subset_of_eq_of_subset
alias HasSubset.subset.trans_eq := subset_of_subset_of_eq
alias Eq.subset' := subset_of_eq --TODO: Fix it and kill `Eq.subset`
alias Eq.superset := superset_of_eq
alias HasSubset.Subset.trans :=... | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | superset_antisymm | null |
subset_antisymm_iff [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] : a = b ↔ a ⊆ b ∧ b ⊆ a :=
⟨fun h => ⟨h.subset', h.superset⟩, fun h => h.1.antisymm h.2⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_antisymm_iff | null |
superset_antisymm_iff [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] : a = b ↔ b ⊆ a ∧ a ⊆ b :=
⟨fun h => ⟨h.superset, h.subset'⟩, fun h => h.1.antisymm' h.2⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | superset_antisymm_iff | null |
ssubset_of_eq_of_ssubset (hab : a = b) (hbc : b ⊂ c) : a ⊂ c := by rwa [hab] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_eq_of_ssubset | null |
ssubset_of_ssubset_of_eq (hab : a ⊂ b) (hbc : b = c) : a ⊂ c := by rwa [← hbc] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_ssubset_of_eq | null |
ssubset_irrefl [IsIrrefl α (· ⊂ ·)] (a : α) : ¬a ⊂ a := irrefl _ | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_irrefl | null |
ssubset_irrfl [IsIrrefl α (· ⊂ ·)] {a : α} : ¬a ⊂ a := irrefl _ | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_irrfl | null |
ne_of_ssubset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → a ≠ b := ne_of_irrefl | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ne_of_ssubset | null |
ne_of_ssuperset [IsIrrefl α (· ⊂ ·)] {a b : α} : a ⊂ b → b ≠ a := ne_of_irrefl'
@[trans] | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ne_of_ssuperset | null |
ssubset_trans [IsTrans α (· ⊂ ·)] {a b c : α} : a ⊂ b → b ⊂ c → a ⊂ c := _root_.trans | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_trans | null |
ssubset_asymm [IsAsymm α (· ⊂ ·)] {a b : α} : a ⊂ b → ¬b ⊂ a := asymm
alias Eq.trans_ssubset := ssubset_of_eq_of_ssubset
alias HasSSubset.SSubset.trans_eq := ssubset_of_ssubset_of_eq
alias HasSSubset.SSubset.false := ssubset_irrfl
alias HasSSubset.SSubset.ne := ne_of_ssubset
alias HasSSubset.SSubset.ne' := ne_of_ssuper... | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_asymm | null |
ssubset_iff_subset_not_subset : a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a :=
right_iff_left_not_left | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_iff_subset_not_subset | null |
subset_of_ssubset (h : a ⊂ b) : a ⊆ b :=
(ssubset_iff_subset_not_subset.1 h).1 | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_of_ssubset | null |
not_subset_of_ssubset (h : a ⊂ b) : ¬b ⊆ a :=
(ssubset_iff_subset_not_subset.1 h).2 | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | not_subset_of_ssubset | null |
not_ssubset_of_subset (h : a ⊆ b) : ¬b ⊂ a := fun h' => not_subset_of_ssubset h' h | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | not_ssubset_of_subset | null |
ssubset_of_subset_not_subset (h₁ : a ⊆ b) (h₂ : ¬b ⊆ a) : a ⊂ b :=
ssubset_iff_subset_not_subset.2 ⟨h₁, h₂⟩
alias HasSSubset.SSubset.subset := subset_of_ssubset
alias HasSSubset.SSubset.not_subset := not_subset_of_ssubset
alias HasSubset.Subset.not_ssubset := not_ssubset_of_subset
alias HasSubset.Subset.ssubset_of_no... | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_subset_not_subset | null |
ssubset_of_subset_of_ssubset [IsTrans α (· ⊆ ·)] (h₁ : a ⊆ b) (h₂ : b ⊂ c) : a ⊂ c :=
(h₁.trans h₂.subset).ssubset_of_not_subset fun h => h₂.not_subset <| h.trans h₁ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_subset_of_ssubset | null |
ssubset_of_ssubset_of_subset [IsTrans α (· ⊆ ·)] (h₁ : a ⊂ b) (h₂ : b ⊆ c) : a ⊂ c :=
(h₁.subset.trans h₂).ssubset_of_not_subset fun h => h₁.not_subset <| h₂.trans h | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_ssubset_of_subset | null |
ssubset_of_subset_of_ne [IsAntisymm α (· ⊆ ·)] (h₁ : a ⊆ b) (h₂ : a ≠ b) : a ⊂ b :=
h₁.ssubset_of_not_subset <| mt h₁.antisymm h₂ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_subset_of_ne | null |
ssubset_of_ne_of_subset [IsAntisymm α (· ⊆ ·)] (h₁ : a ≠ b) (h₂ : a ⊆ b) : a ⊂ b :=
ssubset_of_subset_of_ne h₂ h₁ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_of_ne_of_subset | null |
eq_or_ssubset_of_subset [IsAntisymm α (· ⊆ ·)] (h : a ⊆ b) : a = b ∨ a ⊂ b :=
(em (b ⊆ a)).imp h.antisymm h.ssubset_of_not_subset | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | eq_or_ssubset_of_subset | null |
ssubset_or_eq_of_subset [IsAntisymm α (· ⊆ ·)] (h : a ⊆ b) : a ⊂ b ∨ a = b :=
(eq_or_ssubset_of_subset h).symm | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_or_eq_of_subset | null |
eq_of_subset_of_not_ssubset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) : a = b :=
(eq_or_ssubset_of_subset hab).resolve_right hba | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | eq_of_subset_of_not_ssubset | null |
eq_of_superset_of_not_ssuperset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) :
b = a := ((eq_or_ssubset_of_subset hab).resolve_right hba).symm
alias HasSubset.Subset.trans_ssubset := ssubset_of_subset_of_ssubset
alias HasSSubset.SSubset.trans_subset := ssubset_of_ssubset_of_subset
alias HasSubset.Subset.ssu... | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | eq_of_superset_of_not_ssuperset | null |
ssubset_iff_subset_ne [IsAntisymm α (· ⊆ ·)] : a ⊂ b ↔ a ⊆ b ∧ a ≠ b :=
⟨fun h => ⟨h.subset, h.ne⟩, fun h => h.1.ssubset_of_ne h.2⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_iff_subset_ne | null |
subset_iff_ssubset_or_eq [IsRefl α (· ⊆ ·)] [IsAntisymm α (· ⊆ ·)] :
a ⊆ b ↔ a ⊂ b ∨ a = b :=
⟨fun h => h.ssubset_or_eq, fun h => h.elim subset_of_ssubset subset_of_eq⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | subset_iff_ssubset_or_eq | null |
@[gcongr]
ssubset_imp_ssubset (h₁ : c ⊆ a) (h₂ : b ⊆ d) : a ⊂ b → c ⊂ d :=
fun h => (h₁.trans_ssubset h).trans_subset h₂
@[gcongr] | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssubset_imp_ssubset | null |
ssuperset_imp_ssuperset (h₁ : a ⊆ c) (h₂ : d ⊆ b) : a ⊃ b → c ⊃ d :=
ssubset_imp_ssubset h₂ h₁ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | ssuperset_imp_ssuperset | null |
@[gcongr_forward] exactSubsetOfSSubset : Mathlib.Tactic.GCongr.ForwardExt where
eval h goal := do goal.assignIfDefEq (← Lean.Meta.mkAppM ``subset_of_ssubset #[h]) | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | exactSubsetOfSSubset | See if the term is `a ⊂ b` and the goal is `a ⊆ b`. |
LE.isTotal [LinearOrder α] : IsTotal α (· ≤ ·) :=
⟨le_total⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | LE.isTotal | null |
transitive_le [Preorder α] : Transitive (@LE.le α _) :=
transitive_of_trans _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | transitive_le | null |
transitive_lt [Preorder α] : Transitive (@LT.lt α _) :=
transitive_of_trans _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | transitive_lt | null |
transitive_ge [Preorder α] : Transitive (@GE.ge α _) :=
transitive_of_trans _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | transitive_ge | null |
transitive_gt [Preorder α] : Transitive (@GT.gt α _) :=
transitive_of_trans _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | transitive_gt | null |
OrderDual.isTotal_le [LE α] [h : IsTotal α (· ≤ ·)] : IsTotal αᵒᵈ (· ≤ ·) :=
@IsTotal.swap α _ h | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | OrderDual.isTotal_le | null |
RelSeries where
/-- The number of inequalities in the series -/
length : ℕ
/-- The underlying function of a relation series -/
toFun : Fin (length + 1) → α
/-- Adjacent elements are related -/
step : ∀ (i : Fin length), toFun (Fin.castSucc i) ~[r] toFun i.succ | structure | 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 | RelSeries | Let `r` be a relation on `α`, a relation series of `r` of length `n` is a series
`a_0, a_1, ..., a_n` such that `r a_i a_{i+1}` for all `i < n` |
@[simps!] singleton (a : α) : RelSeries r where
length := 0
toFun _ := a
step := Fin.elim0 | 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 | singleton | For any type `α`, each term of `α` gives a relation series with the right most index to be 0. |
@[ext (iff := false)]
ext {x y : RelSeries r} (length_eq : x.length = y.length)
(toFun_eq : x.toFun = y.toFun ∘ Fin.cast (by rw [length_eq])) : x = y := by
rcases x with ⟨nx, fx⟩
dsimp only at length_eq
subst length_eq
simp_all | 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 | ext | null |
rel_of_lt [r.IsTrans] (x : RelSeries r) {i j : Fin (x.length + 1)} (h : i < j) :
x i ~[r] x j :=
(Fin.liftFun_iff_succ (· ~[r] ·)).mpr x.step 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 | rel_of_lt | null |
rel_or_eq_of_le [r.IsTrans] (x : RelSeries r) {i j : Fin (x.length + 1)} (h : i ≤ j) :
x i ~[r] x j ∨ x i = x j :=
(Fin.lt_or_eq_of_le h).imp (x.rel_of_lt ·) (by rw [·]) | 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 | rel_or_eq_of_le | null |
@[simps!]
ofLE (x : RelSeries r) {s : SetRel α α} (h : r ≤ s) : RelSeries s where
length := x.length
toFun := x
step _ := h <| x.step _ | 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 | ofLE | Given two relations `r, s` on `α` such that `r ≤ s`, any relation series of `r` induces a relation
series of `s` |
coe_ofLE (x : RelSeries r) {s : SetRel α α} (h : r ≤ s) :
(x.ofLE h : _ → _) = x := rfl | 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 | coe_ofLE | null |
toList (x : RelSeries r) : List α := List.ofFn x
@[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 | toList | Every relation series gives a list |
length_toList (x : RelSeries r) : x.toList.length = x.length + 1 :=
List.length_ofFn
@[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 | length_toList | null |
toList_singleton (x : α) : (singleton r x).toList = [x] :=
rfl | 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_singleton | null |
isChain_toList (x : RelSeries r) : x.toList.IsChain (· ~[r] ·) := by
rw [List.isChain_iff_get]
intro i h
convert x.step ⟨i, by simpa [toList] using h⟩ <;> apply List.get_ofFn
@[deprecated (since := "2025-09-24")] alias toList_chain' := isChain_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 | isChain_toList | null |
toList_ne_nil (x : RelSeries r) : x.toList ≠ [] := fun m =>
List.eq_nil_iff_forall_not_mem.mp m (x 0) <| List.mem_ofFn.mpr ⟨_, rfl⟩ | 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_ne_nil | null |
@[simps]
fromListIsChain (x : List α) (x_ne_nil : x ≠ []) (hx : x.IsChain (· ~[r] ·)) : RelSeries r where
length := x.length - 1
toFun i := x[Fin.cast (Nat.succ_pred_eq_of_pos <| List.length_pos_iff.mpr x_ne_nil) i]
step i := List.isChain_iff_get.mp hx i _
@[deprecated (since := "2025-09-24")] alias fromListChain... | 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 | fromListIsChain | Every nonempty list satisfying the chain condition gives a relation series |
protected Equiv : RelSeries r ≃ {x : List α | x ≠ [] ∧ x.IsChain (· ~[r] ·)} where
toFun x := ⟨_, x.toList_ne_nil, x.isChain_toList⟩
invFun x := fromListIsChain _ x.2.1 x.2.2
left_inv x := ext (by simp [toList]) <| by ext; dsimp; apply List.get_ofFn
right_inv x := by
refine Subtype.ext (List.ext_get ?_ fun ... | 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 | Equiv | Relation series of `r` and nonempty list of `α` satisfying `r`-chain condition bijectively
corresponds to each other. |
toList_injective : Function.Injective (RelSeries.toList (r := r)) :=
fun _ _ h ↦ (RelSeries.Equiv).injective <| Subtype.ext 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 | toList_injective | null |
@[mk_iff]
FiniteDimensional : Prop where
/-- A relation `r` is said to be finite dimensional iff there is a relation series of `r` with the
maximum length. -/
exists_longest_relSeries : ∃ x : RelSeries r, ∀ y : RelSeries r, y.length ≤ x.length | class | 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 | FiniteDimensional | A relation `r` is said to be finite dimensional iff there is a relation series of `r` with the
maximum length. |
@[mk_iff]
InfiniteDimensional : Prop where
/-- A relation `r` is said to be infinite dimensional iff there exists relation series of
arbitrary length. -/
exists_relSeries_with_length : ∀ n : ℕ, ∃ x : RelSeries r, x.length = n | class | 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 | InfiniteDimensional | A relation `r` is said to be infinite dimensional iff there exists relation series of arbitrary
length. |
protected noncomputable longestOf [r.FiniteDimensional] : RelSeries r :=
SetRel.FiniteDimensional.exists_longest_relSeries.choose | 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 relational series when a relation is finite dimensional |
length_le_length_longestOf [r.FiniteDimensional] (x : RelSeries r) :
x.length ≤ (RelSeries.longestOf r).length :=
SetRel.FiniteDimensional.exists_longest_relSeries.choose_spec _ | 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_le_length_longestOf | null |
protected noncomputable withLength [r.InfiniteDimensional] (n : ℕ) : RelSeries r :=
(SetRel.InfiniteDimensional.exists_relSeries_with_length n).choose
@[simp] lemma length_withLength [r.InfiniteDimensional] (n : ℕ) :
(RelSeries.withLength r n).length = n :=
(SetRel.InfiniteDimensional.exists_relSeries_with_leng... | 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 relation series with length `n` if the relation is infinite dimensional |
nonempty_of_infiniteDimensional [r.InfiniteDimensional] : Nonempty α :=
⟨RelSeries.withLength r 0 0⟩ | 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_infiniteDimensional | If a relation on `α` is infinite dimensional, then `α` is nonempty. |
nonempty_of_finiteDimensional [r.FiniteDimensional] : Nonempty α := by
obtain ⟨p, _⟩ := (r.finiteDimensional_iff).mp ‹_›
exact ⟨p 0⟩ | 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_finiteDimensional | null |
membership : Membership α (RelSeries r) :=
⟨Function.swap (· ∈ Set.range ·)⟩ | 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 | membership | null |
mem_def : x ∈ s ↔ x ∈ Set.range s := Iff.rfl
@[simp] theorem mem_toList : x ∈ s.toList ↔ x ∈ s := by
rw [RelSeries.toList, List.mem_ofFn', RelSeries.mem_def] | 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 | mem_def | null |
subsingleton_of_length_eq_zero (hs : s.length = 0) : {x | x ∈ s}.Subsingleton := by
rintro - ⟨i, rfl⟩ - ⟨j, rfl⟩
congr!
exact finCongr (by rw [hs, zero_add]) |>.injective <| Subsingleton.elim (α := Fin 1) _ _ | 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 | subsingleton_of_length_eq_zero | null |
length_ne_zero_of_nontrivial (h : {x | x ∈ s}.Nontrivial) : s.length ≠ 0 :=
fun hs ↦ h.not_subsingleton <| subsingleton_of_length_eq_zero hs | 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 | length_ne_zero_of_nontrivial | null |
length_pos_of_nontrivial (h : {x | x ∈ s}.Nontrivial) : 0 < s.length :=
Nat.pos_iff_ne_zero.mpr <| length_ne_zero_of_nontrivial h | 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 | length_pos_of_nontrivial | null |
length_ne_zero [r.IsIrrefl] : s.length ≠ 0 ↔ {x | x ∈ s}.Nontrivial := by
refine ⟨fun h ↦ ⟨s 0, by simp [mem_def], s 1, by simp [mem_def],
fun rid ↦ r.irrefl (s 0) ?_⟩, length_ne_zero_of_nontrivial⟩
nth_rw 2 [rid]
convert s.step ⟨0, by cutsat⟩
ext
simpa [Nat.pos_iff_ne_zero] | 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 | length_ne_zero | null |
length_pos [r.IsIrrefl] : 0 < s.length ↔ {x | x ∈ s}.Nontrivial :=
Nat.pos_iff_ne_zero.trans length_ne_zero | 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 | length_pos | null |
length_eq_zero [r.IsIrrefl] : s.length = 0 ↔ {x | x ∈ s}.Subsingleton := by
rw [← not_ne_iff, length_ne_zero, Set.not_nontrivial_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 | length_eq_zero | null |
head (x : RelSeries r) : α := x 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 | head | Start of a series, i.e. for `a₀ -r→ a₁ -r→ ... -r→ aₙ`, its head is `a₀`.
Since a relation series is assumed to be non-empty, this is well defined. |
last (x : RelSeries r) : α := x <| Fin.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 | last | End of a series, i.e. for `a₀ -r→ a₁ -r→ ... -r→ aₙ`, its last element is `aₙ`.
Since a relation series is assumed to be non-empty, this is well defined. |
apply_zero (p : RelSeries r) : p 0 = p.head := rfl | 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_zero | null |
apply_last (x : RelSeries r) : x (Fin.last <| x.length) = x.last := rfl | 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_last | null |
head_mem (x : RelSeries r) : x.head ∈ x := ⟨_, rfl⟩ | 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_mem | null |
last_mem (x : RelSeries r) : x.last ∈ x := ⟨_, 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 | last_mem | null |
head_singleton {r : SetRel α α} (x : α) : (singleton r x).head = x := by
simp [singleton, 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_singleton | null |
last_singleton {r : SetRel α α} (x : α) : (singleton r x).last = x := by
simp [singleton, last]
@[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 | last_singleton | null |
head_toList (p : RelSeries r) : p.toList.head p.toList_ne_nil = p.head := by
simp [toList, apply_zero]
@[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_toList | null |
toList_getElem_eq_apply (p : RelSeries r) (i : Fin (p.length + 1)) :
p.toList[(i : ℕ)] = p i := by
simp only [toList, List.getElem_ofFn] | 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_getElem_eq_apply | null |
toList_getElem_eq_apply_of_lt_length {p : RelSeries r} {i : ℕ} (hi : i < p.length + 1) :
p.toList[i]'(by simpa using hi) = p ⟨i, hi⟩ :=
p.toList_getElem_eq_apply ⟨i, hi⟩
@[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_getElem_eq_apply_of_lt_length | null |
toList_getElem_zero_eq_head (p : RelSeries r) : p.toList[0] = p.head :=
p.toList_getElem_eq_apply_of_lt_length (by simp)
@[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_getElem_zero_eq_head | null |
toList_fromListIsChain (l : List α) (l_ne_nil : l ≠ []) (hl : l.IsChain (· ~[r] ·)) :
(fromListIsChain l l_ne_nil hl).toList = l :=
Subtype.ext_iff.mp <| RelSeries.Equiv.right_inv ⟨l, ⟨l_ne_nil, hl⟩⟩
@[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_fromListIsChain | null |
head_fromListIsChain (l : List α) (l_ne_nil : l ≠ []) (hl : l.IsChain (· ~[r] ·)) :
(fromListIsChain l l_ne_nil hl).head = l.head l_ne_nil := by
simp [← apply_zero, List.getElem_zero_eq_head]
@[deprecated (since := "2025-09-24")] alias toList_fromListChain' := toList_fromListIsChain
@[deprecated (since := "2025-0... | 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_fromListIsChain | null |
getLast_toList (p : RelSeries r) : p.toList.getLast (by simp [toList]) = p.last := by
simp [last, ← toList_getElem_eq_apply, List.getLast_eq_getElem] | 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 | getLast_toList | null |
@[simps length]
append (p q : RelSeries r) (connect : p.last ~[r] q.head) : RelSeries r where
length := p.length + q.length + 1
toFun := Fin.append p q ∘ Fin.cast (by omega)
step i := by
obtain hi | rfl | hi :=
lt_trichotomy i (Fin.castLE (by omega) (Fin.last _ : Fin (p.length + 1)))
· convert p.ste... | 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 | append | If `a₀ -r→ a₁ -r→ ... -r→ aₙ` and `b₀ -r→ b₁ -r→ ... -r→ bₘ` are two strict series
such that `r aₙ b₀`, then there is a chain of length `n + m + 1` given by
`a₀ -r→ a₁ -r→ ... -r→ aₙ -r→ b₀ -r→ b₁ -r→ ... -r→ bₘ`. |
append_apply_left (p q : RelSeries r) (connect : p.last ~[r] q.head)
(i : Fin (p.length + 1)) :
p.append q connect
((i.castAdd (q.length + 1)).cast (by dsimp; cutsat) : Fin ((p.append q connect).length + 1))
= p i := by
delta append
simp only [Function.comp_apply]
convert Fin.append_left _ _... | 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_apply_left | null |
append_apply_right (p q : RelSeries r) (connect : p.last ~[r] q.head)
(i : Fin (q.length + 1)) :
p.append q connect
((i.natAdd (p.length + 1)).cast (by dsimp; cutsat) : Fin ((p.append q connect).length + 1))
= q i :=
Fin.append_right _ _ _
@[simp] lemma head_append (p q : RelSeries r) (connect :... | 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_apply_right | null |
append_assoc (p q w : RelSeries r) (hpq : p.last ~[r] q.head) (hqw : q.last ~[r] w.head) :
(p.append q hpq).append w (by simpa) = p.append (q.append w hqw) (by simpa) := by
ext
· simp only [append_length, Nat.add_left_inj]
cutsat
· simp [append, Fin.append_assoc]
@[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_assoc | null |
toList_append (p q : RelSeries r) (connect : p.last ~[r] q.head) :
(p.append q connect).toList = p.toList ++ q.toList := by
apply List.ext_getElem
· simp
cutsat
· intro i h1 h2
have h3' : i < p.length + 1 + (q.length + 1) := by simp_all
rw [toList_getElem_eq_apply_of_lt_length (by simp; 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 | toList_append | null |
@[simps length]
map (p : RelSeries r) (f : r.Hom s) : RelSeries s where
length := p.length
toFun := f.1.comp p
step := (f.2 <| p.step ·)
@[simp] lemma map_apply (p : RelSeries r) (f : r.Hom s) (i : Fin (p.length + 1)) :
p.map f i = f (p i) := rfl
@[simp] lemma head_map (p : RelSeries r) (f : r.Hom s) : (p.map... | 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 types `α, β` and relation on them `r, s`, if `f : α → β` preserves relation `r`, then an
`r`-series can be pushed out to an `s`-series by
`a₀ -r→ a₁ -r→ ... -r→ aₙ ↦ f a₀ -s→ f a₁ -s→ ... -s→ f aₙ` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.