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 ⌀ |
|---|---|---|---|---|---|---|
infPrime_ofDual {a : αᵒᵈ} : InfPrime (ofDual a) ↔ SupPrime a :=
Iff.rfl
alias ⟨_, InfIrred.dual⟩ := supIrred_toDual
alias ⟨_, InfPrime.dual⟩ := supPrime_toDual
alias ⟨_, SupIrred.ofDual⟩ := infIrred_ofDual
alias ⟨_, SupPrime.ofDual⟩ := infPrime_ofDual | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | infPrime_ofDual | null |
@[simp]
supPrime_iff_supIrred : SupPrime a ↔ SupIrred a :=
⟨SupPrime.supIrred,
And.imp_right fun h b c => by simp_rw [← inf_eq_left, inf_sup_left]; exact @h _ _⟩
@[simp] | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | supPrime_iff_supIrred | null |
infPrime_iff_infIrred : InfPrime a ↔ InfIrred a :=
⟨InfPrime.infIrred,
And.imp_right fun h b c => by simp_rw [← sup_eq_left, sup_inf_left]; exact @h _ _⟩
protected alias ⟨_, SupIrred.supPrime⟩ := supPrime_iff_supIrred
protected alias ⟨_, InfIrred.infPrime⟩ := infPrime_iff_infIrred | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | infPrime_iff_infIrred | null |
supPrime_iff_not_isMin : SupPrime a ↔ ¬IsMin a :=
and_iff_left <| by simp | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | supPrime_iff_not_isMin | null |
infPrime_iff_not_isMax : InfPrime a ↔ ¬IsMax a :=
and_iff_left <| by simp
@[simp] | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | infPrime_iff_not_isMax | null |
supIrred_iff_not_isMin : SupIrred a ↔ ¬IsMin a :=
and_iff_left fun _ _ => by simpa only [max_eq_iff] using Or.imp And.left And.left
@[simp] | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | supIrred_iff_not_isMin | null |
infIrred_iff_not_isMax : InfIrred a ↔ ¬IsMax a :=
and_iff_left fun _ _ => by simpa only [min_eq_iff] using Or.imp And.left And.left | theorem | Order | [
"Mathlib.Data.Finset.Lattice.Fold"
] | Mathlib/Order/Irreducible.lean | infIrred_iff_not_isMax | null |
@[mk_iff isNormal_iff']
IsNormal [LinearOrder α] [LinearOrder β] (f : α → β) : Prop where
strictMono : StrictMono f
/-- This condition is the RHS of the `IsLUB (f '' Iio a) (f a)` predicate, which is sufficient
since the LHS is implied by monotonicity. -/
mem_lowerBounds_upperBounds_of_isSuccLimit {a : α} (ha :... | structure | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | IsNormal | A normal function between well-orders is a strictly monotonic continuous function. |
isNormal_iff [LinearOrder α] [LinearOrder β] {f : α → β} :
IsNormal f ↔ StrictMono f ∧ ∀ o, IsSuccLimit o → ∀ a, (∀ b < o, f b ≤ a) → f o ≤ a := by
simp [isNormal_iff', mem_lowerBounds, mem_upperBounds] | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | isNormal_iff | null |
isLUB_image_Iio_of_isSuccLimit {f : α → β} (hf : IsNormal f) {a : α} (ha : IsSuccLimit a) :
IsLUB (f '' Iio a) (f a) := by
refine ⟨?_, hf.2 ha⟩
rintro - ⟨b, hb, rfl⟩
exact (hf.1 hb).le
@[deprecated "use the default constructor of `IsNormal` directly" (since := "2025-07-08")] | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | isLUB_image_Iio_of_isSuccLimit | null |
of_mem_lowerBounds_upperBounds {f : α → β} (hf : StrictMono f)
(hl : ∀ {a}, IsSuccLimit a → f a ∈ lowerBounds (upperBounds (f '' Iio a))) : IsNormal f :=
⟨hf, hl⟩ | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | of_mem_lowerBounds_upperBounds | null |
le_iff_forall_le (hf : IsNormal f) (ha : IsSuccLimit a) {b : β} :
f a ≤ b ↔ ∀ a' < a, f a' ≤ b := by
simpa [mem_upperBounds] using isLUB_le_iff (hf.isLUB_image_Iio_of_isSuccLimit ha) | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | le_iff_forall_le | null |
lt_iff_exists_lt (hf : IsNormal f) (ha : IsSuccLimit a) {b : β} :
b < f a ↔ ∃ a' < a, b < f a' := by
simpa [mem_upperBounds] using lt_isLUB_iff (hf.isLUB_image_Iio_of_isSuccLimit ha) | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | lt_iff_exists_lt | null |
map_isSuccLimit (hf : IsNormal f) (ha : IsSuccLimit a) : IsSuccLimit (f a) := by
refine ⟨?_, fun b hb ↦ ?_⟩
· obtain ⟨b, hb⟩ := not_isMin_iff.1 ha.not_isMin
exact not_isMin_iff.2 ⟨_, hf.strictMono hb⟩
· obtain ⟨c, hc, hc'⟩ := (hf.lt_iff_exists_lt ha).1 hb.lt
have hc' := hb.ge_of_gt hc'
rw [hf.strictMo... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | map_isSuccLimit | null |
map_isLUB (hf : IsNormal f) {s : Set α} (hs : IsLUB s a) (hs' : s.Nonempty) :
IsLUB (f '' s) (f a) := by
refine ⟨?_, fun b hb ↦ ?_⟩
· simpa [mem_upperBounds, hf.strictMono.le_iff_le] using hs.1
· by_cases ha : a ∈ s
· simp_all [mem_upperBounds]
· have ha' := hs.isSuccLimit_of_notMem hs' ha
rw [l... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | map_isLUB | null |
_root_.InitialSeg.isNormal (f : α ≤i β) : IsNormal f where
strictMono := f.strictMono
mem_lowerBounds_upperBounds_of_isSuccLimit ha := by
rw [f.image_Iio]
exact (f.map_isSuccLimit ha).isLUB_Iio.2 | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | _root_.InitialSeg.isNormal | null |
_root_.PrincipalSeg.isNormal (f : α <i β) : IsNormal f :=
(f : α ≤i β).isNormal | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | _root_.PrincipalSeg.isNormal | null |
_root_.OrderIso.isNormal (f : α ≃o β) : IsNormal f :=
f.toInitialSeg.isNormal | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | _root_.OrderIso.isNormal | null |
protected id : IsNormal (@id α) :=
(OrderIso.refl _).isNormal | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | id | null |
comp (hg : IsNormal g) (hf : IsNormal f) : IsNormal (g ∘ f) := by
refine ⟨hg.strictMono.comp hf.strictMono, fun ha b hb ↦ ?_⟩
simp_rw [Function.comp_apply, mem_upperBounds, forall_mem_image] at hb
simpa [hg.le_iff_forall_le (hf.map_isSuccLimit ha), hf.lt_iff_exists_lt ha] using
fun c d hd hc ↦ (hg.strictMono ... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | comp | null |
of_succ_lt
(hs : ∀ a, f a < f (succ a)) (hl : ∀ {a}, IsSuccLimit a → IsLUB (f '' Iio a) (f a)) :
IsNormal f := by
refine ⟨fun a b ↦ ?_, fun ha ↦ (hl ha).2⟩
induction b using SuccOrder.limitRecOn with
| isMin b hb => exact hb.not_lt.elim
| succ b hb IH =>
intro hab
obtain rfl | h := (lt_succ_iff_... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | of_succ_lt | null |
protected ext [OrderBot α] {g : α → β} (hf : IsNormal f) (hg : IsNormal g) :
f = g ↔ f ⊥ = g ⊥ ∧ ∀ a, f a = g a → f (succ a) = g (succ a) := by
constructor
· simp_all
rintro ⟨H₁, H₂⟩
ext a
induction a using SuccOrder.limitRecOn with
| isMin a ha => rw [ha.eq_bot, H₁]
| succ a ha IH => exact H₂ a IH
... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | ext | null |
map_sSup (hf : IsNormal f) {s : Set α} (hs : s.Nonempty) (hs' : BddAbove s) :
f (sSup s) = sSup (f '' s) :=
((hf.map_isLUB (isLUB_csSup hs hs') hs).csSup_eq (hs.image f)).symm | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | map_sSup | null |
map_iSup {ι} [Nonempty ι] {g : ι → α} (hf : IsNormal f) (hg : BddAbove (range g)) :
f (⨆ i, g i) = ⨆ i, f (g i) := by
unfold iSup
convert map_sSup hf (range_nonempty g) hg
ext
simp | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | map_iSup | null |
preimage_Iic (hf : IsNormal f) {x : β}
(h₁ : (f ⁻¹' Iic x).Nonempty) (h₂ : BddAbove (f ⁻¹' Iic x)) :
f ⁻¹' Iic x = Iic (sSup (f ⁻¹' Iic x)) := by
refine le_antisymm (fun _ ↦ le_csSup h₂) (fun y hy ↦ ?_)
obtain hy | rfl := hy.lt_or_eq
· rw [lt_csSup_iff h₂ h₁] at hy
obtain ⟨z, hz, hyz⟩ := hy
exact ... | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | preimage_Iic | null |
apply_of_isSuccLimit (hf : IsNormal f) (ha : IsSuccLimit a) :
f a = ⨆ b : Iio a, f b := by
convert map_iSup hf _
· exact ha.iSup_Iio.symm
· exact ⟨⊥, ha.bot_lt⟩
· use a
rintro _ ⟨⟨x, hx⟩, rfl⟩
exact hx.le | theorem | Order | [
"Mathlib.Order.SuccPred.CompleteLinearOrder",
"Mathlib.Order.SuccPred.InitialSeg"
] | Mathlib/Order/IsNormal.lean | apply_of_isSuccLimit | null |
seq_le_seq (hf : Monotone f) (n : ℕ) (h₀ : x 0 ≤ y 0) (hx : ∀ k < n, x (k + 1) ≤ f (x k))
(hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n ≤ y n := by
induction n with
| zero => exact h₀
| succ n ihn =>
refine (hx _ n.lt_succ_self).trans ((hf <| ihn ?_ ?_).trans (hy _ n.lt_succ_self))
· exact fun k hk => hx ... | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | seq_le_seq | null |
seq_pos_lt_seq_of_lt_of_le (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
(hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
induction n with
| zero => exact hn.false.elim
| succ n ihn =>
suffices x n ≤ y n from (hx n n.lt_succ_self).trans_le ((hf this).trans ... | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | seq_pos_lt_seq_of_lt_of_le | null |
seq_pos_lt_seq_of_le_of_lt (hf : Monotone f) {n : ℕ} (hn : 0 < n) (h₀ : x 0 ≤ y 0)
(hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
hf.dual.seq_pos_lt_seq_of_lt_of_le hn h₀ hy hx | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | seq_pos_lt_seq_of_le_of_lt | null |
seq_lt_seq_of_lt_of_le (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
(hx : ∀ k < n, x (k + 1) < f (x k)) (hy : ∀ k < n, f (y k) ≤ y (k + 1)) : x n < y n := by
cases n
exacts [h₀, hf.seq_pos_lt_seq_of_lt_of_le (Nat.zero_lt_succ _) h₀.le hx hy] | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | seq_lt_seq_of_lt_of_le | null |
seq_lt_seq_of_le_of_lt (hf : Monotone f) (n : ℕ) (h₀ : x 0 < y 0)
(hx : ∀ k < n, x (k + 1) ≤ f (x k)) (hy : ∀ k < n, f (y k) < y (k + 1)) : x n < y n :=
hf.dual.seq_lt_seq_of_lt_of_le n h₀ hy hx
/-! | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | seq_lt_seq_of_le_of_lt | null |
le_iterate_comp_of_le (hf : Monotone f) (H : h ∘ g ≤ f ∘ h) (n : ℕ) :
h ∘ g^[n] ≤ f^[n] ∘ h := fun x => by
apply hf.seq_le_seq n <;> intros <;>
simp [iterate_succ', -iterate_succ, comp_apply, id_eq, le_refl]
case hx => exact H _ | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | le_iterate_comp_of_le | null |
iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : ℕ) :
f^[n] ∘ h ≤ h ∘ g^[n] :=
hf.dual.le_iterate_comp_of_le H n | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_comp_le_of_le | null |
iterate_le_of_le {g : α → α} (hf : Monotone f) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
hf.iterate_comp_le_of_le h n | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_le_of_le | If `f ≤ g` and `f` is monotone, then `f^[n] ≤ g^[n]`. |
le_iterate_of_le {g : α → α} (hg : Monotone g) (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] :=
hg.dual.iterate_le_of_le h n | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | le_iterate_of_le | If `f ≤ g` and `g` is monotone, then `f^[n] ≤ g^[n]`. |
id_le_iterate_of_id_le (h : id ≤ f) (n : ℕ) : id ≤ f^[n] := by
simpa only [iterate_id] using monotone_id.iterate_le_of_le h n | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | id_le_iterate_of_id_le | If $x ≤ f x$ for all $x$ (we write this as `id ≤ f`), then the same is true for any iterate
`f^[n]` of `f`. |
iterate_le_id_of_le_id (h : f ≤ id) (n : ℕ) : f^[n] ≤ id :=
@id_le_iterate_of_id_le αᵒᵈ _ f h n | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_le_id_of_le_id | null |
monotone_iterate_of_id_le (h : id ≤ f) : Monotone fun m => f^[m] :=
monotone_nat_of_le_succ fun n x => by
rw [iterate_succ_apply']
exact h _ | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | monotone_iterate_of_id_le | null |
antitone_iterate_of_le_id (h : f ≤ id) : Antitone fun m => f^[m] := fun m n hmn =>
@monotone_iterate_of_id_le αᵒᵈ _ f h m n hmn | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | antitone_iterate_of_le_id | null |
iterate_le_of_map_le (h : Commute f g) (hf : Monotone f) (hg : Monotone g) {x}
(hx : f x ≤ g x) (n : ℕ) : f^[n] x ≤ g^[n] x := by
apply hf.seq_le_seq n
· rfl
· intros; rw [iterate_succ_apply']
· simp [h.iterate_right _ _, hg.iterate _ hx] | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_le_of_map_le | null |
iterate_pos_lt_of_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x}
(hx : f x < g x) {n} (hn : 0 < n) : f^[n] x < g^[n] x := by
apply hf.seq_pos_lt_seq_of_le_of_lt hn
· rfl
· intros; rw [iterate_succ_apply']
· simp [h.iterate_right _ _, hg.iterate _ hx] | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_lt_of_map_lt | null |
iterate_pos_lt_of_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x}
(hx : f x < g x) {n} (hn : 0 < n) : f^[n] x < g^[n] x :=
@iterate_pos_lt_of_map_lt αᵒᵈ _ g f h.symm hg.dual hf.dual x hx n hn | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_lt_of_map_lt' | null |
iterate_pos_lt_iff_map_lt (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
(hn : 0 < n) : f^[n] x < g^[n] x ↔ f x < g x := by
rcases lt_trichotomy (f x) (g x) with (H | H | H)
· simp only [*, iterate_pos_lt_of_map_lt]
· simp only [*, h.iterate_eq_of_map_eq, lt_irrefl]
· simp only [lt_asymm H, l... | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_lt_iff_map_lt | null |
iterate_pos_lt_iff_map_lt' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
(hn : 0 < n) : f^[n] x < g^[n] x ↔ f x < g x :=
@iterate_pos_lt_iff_map_lt αᵒᵈ _ _ _ h.symm hg.dual hf.dual x n hn | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_lt_iff_map_lt' | null |
iterate_pos_le_iff_map_le (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
(hn : 0 < n) : f^[n] x ≤ g^[n] x ↔ f x ≤ g x := by
simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn) | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_le_iff_map_le | null |
iterate_pos_le_iff_map_le' (h : Commute f g) (hf : StrictMono f) (hg : Monotone g) {x n}
(hn : 0 < n) : f^[n] x ≤ g^[n] x ↔ f x ≤ g x := by
simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn) | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_le_iff_map_le' | null |
iterate_pos_eq_iff_map_eq (h : Commute f g) (hf : Monotone f) (hg : StrictMono g) {x n}
(hn : 0 < n) : f^[n] x = g^[n] x ↔ f x = g x := by
simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
h.symm.iterate_pos_le_iff_map_le' hg hf hn] | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | iterate_pos_eq_iff_map_eq | null |
monotone_iterate_of_le_map (hf : Monotone f) (hx : x ≤ f x) : Monotone fun n => f^[n] x :=
monotone_nat_of_le_succ fun n => by
rw [iterate_succ_apply]
exact hf.iterate n hx | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | monotone_iterate_of_le_map | If `f` is a monotone map and `x ≤ f x` at some point `x`, then the iterates `f^[n] x` form
a monotone sequence. |
antitone_iterate_of_map_le (hf : Monotone f) (hx : f x ≤ x) : Antitone fun n => f^[n] x :=
hf.dual.monotone_iterate_of_le_map hx | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | antitone_iterate_of_map_le | If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
an antitone sequence. |
strictMono_iterate_of_lt_map (hf : StrictMono f) (hx : x < f x) :
StrictMono fun n => f^[n] x :=
strictMono_nat_of_lt_succ fun n => by
rw [iterate_succ_apply]
exact hf.iterate n hx | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | strictMono_iterate_of_lt_map | If `f` is a strictly monotone map and `x < f x` at some point `x`, then the iterates `f^[n] x`
form a strictly monotone sequence. |
strictAnti_iterate_of_map_lt (hf : StrictMono f) (hx : f x < x) :
StrictAnti fun n => f^[n] x :=
hf.dual.strictMono_iterate_of_lt_map hx | theorem | Order | [
"Mathlib.Logic.Function.Iterate",
"Mathlib.Order.Monotone.Basic"
] | Mathlib/Order/Iterate.lean | strictAnti_iterate_of_map_lt | If `f` is a strictly antitone map and `f x < x` at some point `x`, then the iterates `f^[n] x`
form a strictly antitone sequence. |
JordanHolderLattice (X : Type u) [Lattice X] where
IsMaximal : X → X → Prop
lt_of_isMaximal : ∀ {x y}, IsMaximal x y → x < y
sup_eq_of_isMaximal : ∀ {x y z}, IsMaximal x z → IsMaximal y z → x ≠ y → x ⊔ y = z
isMaximal_inf_left_of_isMaximal_sup :
∀ {x y}, IsMaximal x (x ⊔ y) → IsMaximal y (x ⊔ y) → IsMaximal... | class | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | JordanHolderLattice | A `JordanHolderLattice` is the class for which the Jordan Hölder theorem is proved. A
Jordan Hölder lattice is a lattice equipped with a notion of maximality, `IsMaximal`, and a notion
of isomorphism of pairs `Iso`. In the example of subgroups of a group, `IsMaximal H K` means that
`H` is a maximal normal subgroup of `... |
isMaximal_inf_right_of_isMaximal_sup {x y : X} (hxz : IsMaximal x (x ⊔ y))
(hyz : IsMaximal y (x ⊔ y)) : IsMaximal (x ⊓ y) y := by
rw [inf_comm]
rw [sup_comm] at hxz hyz
exact isMaximal_inf_left_of_isMaximal_sup hyz hxz | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | isMaximal_inf_right_of_isMaximal_sup | null |
isMaximal_of_eq_inf (x b : X) {a y : X} (ha : x ⊓ y = a) (hxy : x ≠ y) (hxb : IsMaximal x b)
(hyb : IsMaximal y b) : IsMaximal a y := by
have hb : x ⊔ y = b := sup_eq_of_isMaximal hxb hyb hxy
substs a b
exact isMaximal_inf_right_of_isMaximal_sup hxb hyb | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | isMaximal_of_eq_inf | null |
second_iso_of_eq {x y a b : X} (hm : IsMaximal x a) (ha : x ⊔ y = a) (hb : x ⊓ y = b) :
Iso (x, a) (b, y) := by substs a b; exact second_iso hm | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | second_iso_of_eq | null |
IsMaximal.iso_refl {x y : X} (h : IsMaximal x y) : Iso (x, y) (x, y) :=
second_iso_of_eq h (sup_eq_right.2 (le_of_lt (lt_of_isMaximal h)))
(inf_eq_left.2 (le_of_lt (lt_of_isMaximal h))) | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | IsMaximal.iso_refl | null |
CompositionSeries (X : Type u) [Lattice X] [JordanHolderLattice X] : Type u :=
RelSeries {(x, y) : X × X | IsMaximal x y} | abbrev | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | CompositionSeries | A `CompositionSeries X` is a finite nonempty series of elements of a
`JordanHolderLattice` such that each element is maximal inside the next. The length of a
`CompositionSeries X` is one less than the number of elements in the series.
Note that there is no stipulation that a series start from the bottom of the lattice ... |
lt_succ (s : CompositionSeries X) (i : Fin s.length) :
s (Fin.castSucc i) < s (Fin.succ i) :=
lt_of_isMaximal (s.step _) | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | lt_succ | null |
protected strictMono (s : CompositionSeries X) : StrictMono s :=
Fin.strictMono_iff_lt_succ.2 s.lt_succ | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | strictMono | null |
protected injective (s : CompositionSeries X) : Function.Injective s :=
s.strictMono.injective
@[simp] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | injective | null |
protected inj (s : CompositionSeries X) {i j : Fin s.length.succ} : s i = s j ↔ i = j :=
s.injective.eq_iff | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | inj | null |
total {s : CompositionSeries X} {x y : X} (hx : x ∈ s) (hy : y ∈ s) : x ≤ y ∨ y ≤ x := by
rcases Set.mem_range.1 hx with ⟨i, rfl⟩
rcases Set.mem_range.1 hy with ⟨j, rfl⟩
rw [s.strictMono.le_iff_le, s.strictMono.le_iff_le]
exact le_total i j | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | total | null |
toList_sorted (s : CompositionSeries X) : s.toList.Sorted (· < ·) :=
List.pairwise_iff_get.2 fun i j h => by
dsimp only [RelSeries.toList]
rw [List.get_ofFn, List.get_ofFn]
exact s.strictMono h | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | toList_sorted | null |
toList_nodup (s : CompositionSeries X) : s.toList.Nodup :=
s.toList_sorted.nodup | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | toList_nodup | null |
@[ext]
ext {s₁ s₂ : CompositionSeries X} (h : ∀ x, x ∈ s₁ ↔ x ∈ s₂) : s₁ = s₂ :=
toList_injective <|
List.eq_of_perm_of_sorted
(by
classical
exact List.perm_of_nodup_nodup_toFinset_eq s₁.toList_nodup s₂.toList_nodup
(Finset.ext <| by simpa only [List.mem_toFinset, RelSeries.mem_toL... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | ext | Two `CompositionSeries` are equal if they have the same elements. See also `ext_fun`. |
le_last {s : CompositionSeries X} (i : Fin (s.length + 1)) : s i ≤ s.last :=
s.strictMono.monotone (Fin.le_last _) | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | le_last | null |
le_last_of_mem {s : CompositionSeries X} {x : X} (hx : x ∈ s) : x ≤ s.last :=
let ⟨_i, hi⟩ := Set.mem_range.2 hx
hi ▸ le_last _
@[simp] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | le_last_of_mem | null |
head_le {s : CompositionSeries X} (i : Fin (s.length + 1)) : s.head ≤ s i :=
s.strictMono.monotone (Fin.zero_le _) | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | head_le | null |
head_le_of_mem {s : CompositionSeries X} {x : X} (hx : x ∈ s) : s.head ≤ x :=
let ⟨_i, hi⟩ := Set.mem_range.2 hx
hi ▸ head_le _ | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | head_le_of_mem | null |
last_eraseLast_le (s : CompositionSeries X) : s.eraseLast.last ≤ s.last := by
simp [eraseLast, last, s.strictMono.le_iff_le, Fin.le_iff_val_le_val] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | last_eraseLast_le | null |
mem_eraseLast_of_ne_of_mem {s : CompositionSeries X} {x : X}
(hx : x ≠ s.last) (hxs : x ∈ s) : x ∈ s.eraseLast := by
rcases hxs with ⟨i, rfl⟩
have hi : (i : ℕ) < (s.length - 1).succ := by
conv_rhs => rw [← Nat.succ_sub (length_pos_of_nontrivial ⟨_, ⟨i, rfl⟩, _, s.last_mem, hx⟩),
Nat.add_one_sub_one]
... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | mem_eraseLast_of_ne_of_mem | null |
mem_eraseLast {s : CompositionSeries X} {x : X} (h : 0 < s.length) :
x ∈ s.eraseLast ↔ x ≠ s.last ∧ x ∈ s := by
simp only [RelSeries.mem_def, eraseLast]
constructor
· rintro ⟨i, rfl⟩
have hi : (i : ℕ) < s.length := by omega
simp [last, Fin.ext_iff, ne_of_lt hi, -Set.mem_range, Set.mem_range_self]
· ... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | mem_eraseLast | null |
lt_last_of_mem_eraseLast {s : CompositionSeries X} {x : X} (h : 0 < s.length)
(hx : x ∈ s.eraseLast) : x < s.last :=
lt_of_le_of_ne (le_last_of_mem ((mem_eraseLast h).1 hx).2) ((mem_eraseLast h).1 hx).1 | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | lt_last_of_mem_eraseLast | null |
isMaximal_eraseLast_last {s : CompositionSeries X} (h : 0 < s.length) :
IsMaximal s.eraseLast.last s.last := by
rw [last_eraseLast, last]
have := s.step ⟨s.length - 1, by cutsat⟩
simp only [Fin.castSucc_mk, Fin.succ_mk, mem_setOf_eq] at this
convert this using 3
exact (tsub_add_cancel_of_le h).symm | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | isMaximal_eraseLast_last | null |
eq_snoc_eraseLast {s : CompositionSeries X} (h : 0 < s.length) :
s = snoc (eraseLast s) s.last (isMaximal_eraseLast_last h) := by
ext x
simp only [mem_snoc, mem_eraseLast h, ne_eq]
by_cases h : x = s.last <;> simp [*, s.last_mem]
@[simp] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | eq_snoc_eraseLast | null |
snoc_eraseLast_last {s : CompositionSeries X} (h : IsMaximal s.eraseLast.last s.last) :
s.eraseLast.snoc s.last h = s :=
have h : 0 < s.length :=
Nat.pos_of_ne_zero (fun hs => ne_of_gt (lt_of_isMaximal h) <| by simp [last, Fin.ext_iff, hs])
(eq_snoc_eraseLast h).symm | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | snoc_eraseLast_last | null |
Equivalent (s₁ s₂ : CompositionSeries X) : Prop :=
∃ f : Fin s₁.length ≃ Fin s₂.length,
∀ i : Fin s₁.length, Iso (s₁ (Fin.castSucc i), s₁ i.succ)
(s₂ (Fin.castSucc (f i)), s₂ (Fin.succ (f i))) | def | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | Equivalent | Two `CompositionSeries X`, `s₁` and `s₂` are equivalent if there is a bijection
`e : Fin s₁.length ≃ Fin s₂.length` such that for any `i`,
`Iso (s₁ i) (s₁ i.succ) (s₂ (e i), s₂ (e i.succ))` |
@[refl]
refl (s : CompositionSeries X) : Equivalent s s :=
⟨Equiv.refl _, fun _ => (s.step _).iso_refl⟩
@[symm] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | refl | null |
symm {s₁ s₂ : CompositionSeries X} (h : Equivalent s₁ s₂) : Equivalent s₂ s₁ :=
⟨h.choose.symm, fun i => iso_symm (by simpa using h.choose_spec (h.choose.symm i))⟩
@[trans] | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | symm | null |
trans {s₁ s₂ s₃ : CompositionSeries X} (h₁ : Equivalent s₁ s₂) (h₂ : Equivalent s₂ s₃) :
Equivalent s₁ s₃ :=
⟨h₁.choose.trans h₂.choose,
fun i => iso_trans (h₁.choose_spec i) (h₂.choose_spec (h₁.choose i))⟩ | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | trans | null |
protected smash {s₁ s₂ t₁ t₂ : CompositionSeries X}
(hs : s₁.last = s₂.head) (ht : t₁.last = t₂.head)
(h₁ : Equivalent s₁ t₁) (h₂ : Equivalent s₂ t₂) :
Equivalent (smash s₁ s₂ hs) (smash t₁ t₂ ht) :=
let e : Fin (s₁.length + s₂.length) ≃ Fin (t₁.length + t₂.length) :=
calc
Fin (s₁.length + s₂.le... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | smash | null |
protected snoc {s₁ s₂ : CompositionSeries X} {x₁ x₂ : X} {hsat₁ : IsMaximal s₁.last x₁}
{hsat₂ : IsMaximal s₂.last x₂} (hequiv : Equivalent s₁ s₂)
(hlast : Iso (s₁.last, x₁) (s₂.last, x₂)) : Equivalent (s₁.snoc x₁ hsat₁) (s₂.snoc x₂ hsat₂) :=
let e : Fin s₁.length.succ ≃ Fin s₂.length.succ :=
calc
F... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | snoc | null |
length_eq {s₁ s₂ : CompositionSeries X} (h : Equivalent s₁ s₂) : s₁.length = s₂.length := by
simpa using Fintype.card_congr h.choose | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | length_eq | null |
snoc_snoc_swap {s : CompositionSeries X} {x₁ x₂ y₁ y₂ : X} {hsat₁ : IsMaximal s.last x₁}
{hsat₂ : IsMaximal s.last x₂} {hsaty₁ : IsMaximal (snoc s x₁ hsat₁).last y₁}
{hsaty₂ : IsMaximal (snoc s x₂ hsat₂).last y₂} (hr₁ : Iso (s.last, x₁) (x₂, y₂))
(hr₂ : Iso (x₁, y₁) (s.last, x₂)) :
Equivalent (snoc (sno... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | snoc_snoc_swap | null |
length_eq_zero_of_head_eq_head_of_last_eq_last_of_length_eq_zero
{s₁ s₂ : CompositionSeries X} (hb : s₁.head = s₂.head)
(ht : s₁.last = s₂.last) (hs₁ : s₁.length = 0) : s₂.length = 0 := by
have : Fin.last s₂.length = (0 : Fin s₂.length.succ) :=
s₂.injective (hb.symm.trans ((congr_arg s₁ (Fin.ext (by simp ... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | length_eq_zero_of_head_eq_head_of_last_eq_last_of_length_eq_zero | null |
length_pos_of_head_eq_head_of_last_eq_last_of_length_pos {s₁ s₂ : CompositionSeries X}
(hb : s₁.head = s₂.head) (ht : s₁.last = s₂.last) : 0 < s₁.length → 0 < s₂.length :=
not_imp_not.1
(by
simpa only [pos_iff_ne_zero, ne_eq, Decidable.not_not] using
length_eq_zero_of_head_eq_head_of_last_eq_las... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | length_pos_of_head_eq_head_of_last_eq_last_of_length_pos | null |
eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero {s₁ s₂ : CompositionSeries X}
(hb : s₁.head = s₂.head) (ht : s₁.last = s₂.last) (hs₁0 : s₁.length = 0) : s₁ = s₂ := by
have : ∀ x, x ∈ s₁ ↔ x = s₁.last := fun x =>
⟨fun hx => subsingleton_of_length_eq_zero hs₁0 hx s₁.last_mem, fun hx => hx.symm ▸ s₁.last_m... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero | null |
exists_last_eq_snoc_equivalent (s : CompositionSeries X) (x : X) (hm : IsMaximal x s.last)
(hb : s.head ≤ x) :
∃ t : CompositionSeries X,
t.head = s.head ∧ t.length + 1 = s.length ∧
∃ htx : t.last = x,
Equivalent s (snoc t s.last (show IsMaximal t.last _ from htx.symm ▸ hm)) := by
inductio... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | exists_last_eq_snoc_equivalent | Given a `CompositionSeries`, `s`, and an element `x`
such that `x` is maximal inside `s.last` there is a series, `t`,
such that `t.last = x`, `t.head = s.head`
and `snoc t s.last _` is equivalent to `s`. |
jordan_holder (s₁ s₂ : CompositionSeries X)
(hb : s₁.head = s₂.head) (ht : s₁.last = s₂.last) :
Equivalent s₁ s₂ := by
induction hle : s₁.length generalizing s₁ s₂ with
| zero => rw [eq_of_head_eq_head_of_last_eq_last_of_length_eq_zero hb ht hle]
| succ n ih =>
have h0s₂ : 0 < s₂.length :=
lengt... | theorem | Order | [
"Mathlib.Order.Lattice",
"Mathlib.Data.List.Sort",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.Logic.Equiv.Functor",
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.RelSeries"
] | Mathlib/Order/JordanHolder.lean | jordan_holder | The **Jordan-Hölder** theorem, stated for any `JordanHolderLattice`.
If two composition series start and finish at the same place, they are equivalent. |
exists_seq_covby_of_forall_covby_finite (hfin : ∀ (a : α), {x | a ⋖ x}.Finite)
(hb : (Ici b).Infinite) : ∃ f : ℕ → α, f 0 = b ∧ ∀ i, f i ⋖ f (i+1) :=
let h := fun a : {a : α // (Ici a).Infinite} ↦
exists_covby_infinite_Ici_of_infinite_Ici a.2 (hfin a)
let ks : ℕ → {a : α // (Ici a).Infinite} := Nat.rec ⟨b, ... | theorem | Order | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.Grade",
"Mathlib.Tactic.ApplyFun"
] | Mathlib/Order/KonigLemma.lean | exists_seq_covby_of_forall_covby_finite | **Kőnig's infinity lemma** : if each element in a strongly atomic order
is covered by only finitely many others, and `b` is an element with infinitely many things above it,
then there is a sequence starting with `b` in which each element is covered by the next. |
exists_orderEmbedding_covby_of_forall_covby_finite (hfin : ∀ (a : α), {x | a ⋖ x}.Finite)
(hb : (Ici b).Infinite) : ∃ f : ℕ ↪o α, f 0 = b ∧ ∀ i, f i ⋖ f (i+1) := by
obtain ⟨f, hf⟩ := exists_seq_covby_of_forall_covby_finite hfin hb
exact ⟨OrderEmbedding.ofStrictMono f (strictMono_nat_of_lt_succ (fun i ↦ (hf.2 i)... | theorem | Order | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.Grade",
"Mathlib.Tactic.ApplyFun"
] | Mathlib/Order/KonigLemma.lean | exists_orderEmbedding_covby_of_forall_covby_finite | The sequence given by Kőnig's lemma as an order embedding |
exists_orderEmbedding_covby_of_forall_covby_finite_of_bot [OrderBot α] [Infinite α]
(hfin : ∀ (a : α), {x | a ⋖ x}.Finite) : ∃ f : ℕ ↪o α, f 0 = ⊥ ∧ ∀ i, f i ⋖ f (i+1) :=
exists_orderEmbedding_covby_of_forall_covby_finite hfin (by simpa using infinite_univ) | theorem | Order | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.Grade",
"Mathlib.Tactic.ApplyFun"
] | Mathlib/Order/KonigLemma.lean | exists_orderEmbedding_covby_of_forall_covby_finite_of_bot | A version of Kőnig's lemma where the sequence starts at the minimum of an infinite order. |
GradeMinOrder.exists_nat_orderEmbedding_of_forall_covby_finite
[GradeMinOrder ℕ α] [OrderBot α] [Infinite α] (hfin : ∀ (a : α), {x | a ⋖ x}.Finite) :
∃ f : ℕ ↪o α, f 0 = ⊥ ∧ (∀ i, f i ⋖ f (i+1)) ∧ ∀ i, grade ℕ (f i) = i := by
obtain ⟨f, h0, hf⟩ := exists_orderEmbedding_covby_of_forall_covby_finite_of_bot hfin... | theorem | Order | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.Grade",
"Mathlib.Tactic.ApplyFun"
] | Mathlib/Order/KonigLemma.lean | GradeMinOrder.exists_nat_orderEmbedding_of_forall_covby_finite | null |
exists_seq_forall_proj_of_forall_finite {α : ℕ → Type*} [Finite (α 0)] [∀ i, Nonempty (α i)]
(π : {i j : ℕ} → (hij : i ≤ j) → α j → α i)
(π_refl : ∀ ⦃i⦄ (a : α i), π rfl.le a = a)
(π_trans : ∀ ⦃i j k⦄ (hij : i ≤ j) (hjk : j ≤ k) a, π hij (π hjk a) = π (hij.trans hjk) a)
(hfin : ∀ i a, {b : α (i+1) | π (... | theorem | Order | [
"Mathlib.Data.Fintype.Pigeonhole",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.Grade",
"Mathlib.Tactic.ApplyFun"
] | Mathlib/Order/KonigLemma.lean | exists_seq_forall_proj_of_forall_finite | A formulation of Kőnig's infinity lemma, useful in applications.
Given a sequence `α 0, α 1, ...` of nonempty types with `α 0` finite,
and a well-behaved family of projections `π : α j → α i` for all `i ≤ j`,
if each term in each `α i` is the projection of only finitely many terms in `α (i+1)`,
then we can find a seque... |
noncomputable krullDim (α : Type*) [Preorder α] : WithBot ℕ∞ :=
⨆ (p : LTSeries α), p.length | def | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | krullDim | The **Krull dimension** of a preorder `α` is the supremum of the rightmost index of all relation
series of `α` ordered by `<`. If there is no series `a₀ < a₁ < ... < aₙ` in `α`, then its Krull
dimension is defined to be negative infinity; if the length of all series `a₀ < a₁ < ... < aₙ` is
unbounded, its Krull dimensio... |
noncomputable height {α : Type*} [Preorder α] (a : α) : ℕ∞ :=
⨆ (p : LTSeries α) (_ : p.last ≤ a), p.length | def | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | height | The **height** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and ending below or at `a`. In other words, it is
the largest `n` such that there's a series `a₀ < a₁ < ... < aₙ = a` (or `∞` if there is
no largest `n`). |
noncomputable coheight {α : Type*} [Preorder α] (a : α) : ℕ∞ := height (α := αᵒᵈ) a | def | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | coheight | The **coheight** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and beginning with `a`. In other words, it is
the largest `n` such that there's a series `a = a₀ < a₁ < ... < aₙ` (or `∞` if there is
no largest `n`).
The definition of `coheight` is... |
@[simp] height_toDual (x : α) : height (OrderDual.toDual x) = coheight x := rfl
@[simp] lemma height_ofDual (x : αᵒᵈ) : height (OrderDual.ofDual x) = coheight x := rfl
@[simp] lemma coheight_toDual (x : α) : coheight (OrderDual.toDual x) = height x := rfl
@[simp] lemma coheight_ofDual (x : αᵒᵈ) : coheight (OrderDual.of... | lemma | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | height_toDual | null |
coheight_eq (a : α) :
coheight a = ⨆ (p : LTSeries α) (_ : a ≤ p.head), (p.length : ℕ∞) := by
apply Equiv.iSup_congr ⟨RelSeries.reverse, RelSeries.reverse, fun _ ↦ RelSeries.reverse_reverse _,
fun _ ↦ RelSeries.reverse_reverse _⟩
congr! 1 | lemma | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | coheight_eq | The **coheight** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and beginning with `a`.
This is not the definition of `coheight`. The definition of `coheight` is via the `height` in the
dual order, in order to easily transfer theorems between `he... |
height_le_iff {a : α} {n : ℕ∞} :
height a ≤ n ↔ ∀ ⦃p : LTSeries α⦄, p.last ≤ a → p.length ≤ n := by
rw [height, iSup₂_le_iff] | lemma | Order | [
"Mathlib.Algebra.Order.Group.Int",
"Mathlib.Algebra.Order.SuccPred.WithBot",
"Mathlib.Data.ENat.Lattice",
"Mathlib.Order.Atoms",
"Mathlib.Order.RelSeries",
"Mathlib.Tactic.FinCases"
] | Mathlib/Order/KrullDimension.lean | height_le_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.