statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
exists_succ_iterate_or : (∃ n, succ^[n] a = b) ∨ ∃ n, succ^[n] b = a | (le_total a b).imp exists_succ_iterate_of_le exists_succ_iterate_of_le | lemma | exists_succ_iterate_or | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
succ.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) (a b : α) : p a ↔ p b | (le_total a b).elim (succ.rec_iff hsucc) (λ h, (succ.rec_iff hsucc h).symm) | lemma | succ.rec_linear | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"succ.rec_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_pred_iterate_or : (∃ n, pred^[n] b = a) ∨ ∃ n, pred^[n] a = b | (le_total a b).imp exists_pred_iterate_of_le exists_pred_iterate_of_le | lemma | exists_pred_iterate_or | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pred.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) (a b : α) : p a ↔ p b | (le_total a b).elim (pred.rec_iff hsucc) (λ h, (pred.rec_iff hsucc h).symm) | lemma | pred.rec_linear | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"pred.rec_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_well_order.to_is_pred_archimedean [h : is_well_order α (<)] [pred_order α] :
is_pred_archimedean α | ⟨λ a, begin
refine well_founded.fix h.wf (λ b ih hab, _),
replace hab := hab.eq_or_lt,
rcases hab with rfl | hab,
{ exact ⟨0, rfl⟩ },
cases le_or_lt b (pred b) with hb hb,
{ cases (min_of_le_pred hb).not_lt hab },
obtain ⟨k, hk⟩ := ih (pred b) hb (le_pred_of_lt hab),
refine ⟨k + 1, _⟩,
rw [iterate_add... | instance | is_well_order.to_is_pred_archimedean | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"ih",
"is_pred_archimedean",
"is_well_order",
"pred_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_well_order.to_is_succ_archimedean [h : is_well_order α (>)] [succ_order α] :
is_succ_archimedean α | by convert @order_dual.is_succ_archimedean αᵒᵈ _ _ _ | instance | is_well_order.to_is_succ_archimedean | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"is_succ_archimedean",
"is_well_order",
"succ_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
succ.rec_bot (p : α → Prop) (hbot : p ⊥) (hsucc : ∀ a, p a → p (succ a)) (a : α) : p a | succ.rec hbot (λ x _ h, hsucc x h) (bot_le : ⊥ ≤ a) | lemma | succ.rec_bot | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"bot_le",
"succ.rec"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pred.rec_top (p : α → Prop) (htop : p ⊤) (hpred : ∀ a, p a → p (pred a)) (a : α) : p a | pred.rec htop (λ x _ h, hpred x h) (le_top : a ≤ ⊤) | lemma | pred.rec_top | order.succ_pred | src/order/succ_pred/basic.lean | [
"order.complete_lattice",
"order.cover",
"order.iterate"
] | [
"le_top",
"pred.rec"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bUnion_Ico_Ioc_map_succ [succ_order α] [is_succ_archimedean α]
[linear_order β] {f : α → β} (hf : monotone f) (m n : α) :
(⋃ i ∈ Ico m n, Ioc (f i) (f (succ i))) = Ioc (f m) (f n) | begin
cases le_total n m with hnm hmn,
{ rw [Ico_eq_empty_of_le hnm, Ioc_eq_empty_of_le (hf hnm), bUnion_empty] },
{ refine succ.rec _ _ hmn,
{ simp only [Ioc_self, Ico_self, bUnion_empty] },
{ intros k hmk ihk,
rw [← Ioc_union_Ioc_eq_Ioc (hf hmk) (hf $ le_succ _), union_comm, ← ihk],
by_cases... | lemma | monotone.bUnion_Ico_Ioc_map_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"is_max",
"is_succ_archimedean",
"monotone",
"succ.rec",
"succ_order"
] | If `α` is a linear archimedean succ order and `β` is a linear order, then for any monotone
function `f` and `m n : α`, the union of intervals `set.Ioc (f i) (f (order.succ i))`, `m ≤ i < n`,
is equal to `set.Ioc (f m) (f n)` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioc_succ [succ_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ioc (f n) (f (succ n)))) | (pairwise_disjoint_on _).2 $ λ m n hmn,
disjoint_iff_inf_le.mpr $ λ x ⟨⟨_, h₁⟩, ⟨h₂, _⟩⟩, h₂.not_le $ h₁.trans $ hf $ succ_le_of_lt hmn | lemma | monotone.pairwise_disjoint_on_Ioc_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"pairwise_disjoint_on",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ioc (f n) (f (order.succ n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ico_succ [succ_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ico (f n) (f (succ n)))) | (pairwise_disjoint_on _).2 $ λ m n hmn,
disjoint_iff_inf_le.mpr $ λ x ⟨⟨_, h₁⟩, ⟨h₂, _⟩⟩, h₁.not_le $ (hf $ succ_le_of_lt hmn).trans h₂ | lemma | monotone.pairwise_disjoint_on_Ico_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"pairwise_disjoint_on",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ico (f n) (f (order.succ n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioo_succ [succ_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ioo (f n) (f (succ n)))) | hf.pairwise_disjoint_on_Ico_succ.mono $ λ i j h, h.mono Ioo_subset_Ico_self Ioo_subset_Ico_self | lemma | monotone.pairwise_disjoint_on_Ioo_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ioo (f n) (f (order.succ n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioc_pred [pred_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ioc (f (pred n)) (f n))) | by simpa only [(∘), dual_Ico] using hf.dual.pairwise_disjoint_on_Ico_succ | lemma | monotone.pairwise_disjoint_on_Ioc_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ioc (f order.pred n) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ico_pred [pred_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ico (f (pred n)) (f n))) | by simpa only [(∘), dual_Ioc] using hf.dual.pairwise_disjoint_on_Ioc_succ | lemma | monotone.pairwise_disjoint_on_Ico_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ico (f order.pred n) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioo_pred [pred_order α] [preorder β] {f : α → β} (hf : monotone f) :
pairwise (disjoint on (λ n, Ioo (f (pred n)) (f n))) | by simpa only [(∘), dual_Ioo] using hf.dual.pairwise_disjoint_on_Ioo_succ | lemma | monotone.pairwise_disjoint_on_Ioo_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"disjoint",
"monotone",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `set.Ioo (f order.pred n) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioc_succ [succ_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ioc (f (succ n)) (f n))) | hf.dual_left.pairwise_disjoint_on_Ioc_pred | lemma | antitone.pairwise_disjoint_on_Ioc_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ioc (f (order.succ n)) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ico_succ [succ_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ico (f (succ n)) (f n))) | hf.dual_left.pairwise_disjoint_on_Ico_pred | lemma | antitone.pairwise_disjoint_on_Ico_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ico (f (order.succ n)) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioo_succ [succ_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ioo (f (succ n)) (f n))) | hf.dual_left.pairwise_disjoint_on_Ioo_pred | lemma | antitone.pairwise_disjoint_on_Ioo_succ | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"succ_order"
] | If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ioo (f (order.succ n)) (f n)` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioc_pred [pred_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ioc (f n) (f (pred n)))) | hf.dual_left.pairwise_disjoint_on_Ioc_succ | lemma | antitone.pairwise_disjoint_on_Ioc_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ioc (f n) (f (order.pred n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ico_pred [pred_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ico (f n) (f (pred n)))) | hf.dual_left.pairwise_disjoint_on_Ico_succ | lemma | antitone.pairwise_disjoint_on_Ico_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ico (f n) (f (order.pred n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
pairwise_disjoint_on_Ioo_pred [pred_order α] [preorder β] {f : α → β} (hf : antitone f) :
pairwise (disjoint on (λ n, Ioo (f n) (f (pred n)))) | hf.dual_left.pairwise_disjoint_on_Ioo_succ | lemma | antitone.pairwise_disjoint_on_Ioo_pred | order.succ_pred | src/order/succ_pred/interval_succ.lean | [
"data.set.pairwise.basic",
"order.succ_pred.basic"
] | [
"antitone",
"disjoint",
"pairwise",
"pred_order"
] | If `α` is a linear pred order, `β` is a preorder, and `f : α → β` is an antitone function, then
the intervals `set.Ioo (f n) (f (order.pred n))` are pairwise disjoint. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_succ_limit (a : α) : Prop | ∀ b, ¬ b ⋖ a | def | order.is_succ_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | A successor limit is a value that doesn't cover any other.
It's so named because in a successor order, a successor limit can't be the successor of anything
smaller. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
not_is_succ_limit_iff_exists_covby (a : α) : ¬ is_succ_limit a ↔ ∃ b, b ⋖ a | by simp [is_succ_limit] | lemma | order.not_is_succ_limit_iff_exists_covby | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_of_dense [densely_ordered α] (a : α) : is_succ_limit a | λ b, not_covby | lemma | order.is_succ_limit_of_dense | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"densely_ordered",
"not_covby"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.is_min.is_succ_limit : is_min a → is_succ_limit a | λ h b hab, not_is_min_of_lt hab.lt h | lemma | is_min.is_succ_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min",
"not_is_min_of_lt"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_bot [order_bot α] : is_succ_limit (⊥ : α) | is_min_bot.is_succ_limit | lemma | order.is_succ_limit_bot | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"order_bot"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.is_max (h : is_succ_limit (succ a)) : is_max a | by { by_contra H, exact h a (covby_succ_of_not_is_max H) } | lemma | order.is_succ_limit.is_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"by_contra",
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit_succ_of_not_is_max (ha : ¬ is_max a) : ¬ is_succ_limit (succ a) | by { contrapose! ha, exact ha.is_max } | lemma | order.not_is_succ_limit_succ_of_not_is_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.succ_ne (h : is_succ_limit a) (b : α) : succ b ≠ a | by { rintro rfl, exact not_is_max _ h.is_max } | lemma | order.is_succ_limit.succ_ne | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"not_is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit_succ (a : α) : ¬ is_succ_limit (succ a) | λ h, h.succ_ne _ rfl | lemma | order.not_is_succ_limit_succ | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.is_min_of_no_max [no_max_order α] (h : is_succ_limit a) : is_min a | λ b hb, begin
rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩,
{ exact le_rfl },
{ rw iterate_succ_apply' at h,
exact (not_is_succ_limit_succ _ h).elim }
end | lemma | order.is_succ_limit.is_min_of_no_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min",
"le_rfl",
"no_max_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_iff_of_no_max [no_max_order α] : is_succ_limit a ↔ is_min a | ⟨is_succ_limit.is_min_of_no_max, is_min.is_succ_limit⟩ | lemma | order.is_succ_limit_iff_of_no_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min",
"no_max_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit_of_no_max [no_min_order α] [no_max_order α] : ¬ is_succ_limit a | by simp | lemma | order.not_is_succ_limit_of_no_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"no_max_order",
"no_min_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_of_succ_ne (h : ∀ b, succ b ≠ a) : is_succ_limit a | λ b hba, h b hba.succ_eq | lemma | order.is_succ_limit_of_succ_ne | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit_iff : ¬ is_succ_limit a ↔ ∃ b, ¬ is_max b ∧ succ b = a | begin
rw not_is_succ_limit_iff_exists_covby,
refine exists_congr (λ b, ⟨λ hba, ⟨hba.lt.not_is_max, hba.succ_eq⟩, _⟩),
rintro ⟨h, rfl⟩,
exact covby_succ_of_not_is_max h
end | lemma | order.not_is_succ_limit_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_range_succ_of_not_is_succ_limit (h : ¬ is_succ_limit a) : a ∈ range (@succ α _ _) | by { cases not_is_succ_limit_iff.1 h with b hb, exact ⟨b, hb.2⟩ } | lemma | order.mem_range_succ_of_not_is_succ_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | See `not_is_succ_limit_iff` for a version that states that `a` is a successor of a value other
than itself. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_succ_limit_of_succ_lt (H : ∀ a < b, succ a < b) : is_succ_limit b | λ a hab, (H a hab.lt).ne hab.succ_eq | lemma | order.is_succ_limit_of_succ_lt | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.succ_lt (hb : is_succ_limit b) (ha : a < b) : succ a < b | begin
by_cases h : is_max a,
{ rwa h.succ_eq },
{ rw [lt_iff_le_and_ne, succ_le_iff_of_not_is_max h],
refine ⟨ha, λ hab, _⟩,
subst hab,
exact (h hb.is_max).elim }
end | lemma | order.is_succ_limit.succ_lt | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max",
"lt_iff_le_and_ne"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.succ_lt_iff (hb : is_succ_limit b) : succ a < b ↔ a < b | ⟨λ h, (le_succ a).trans_lt h, hb.succ_lt⟩ | lemma | order.is_succ_limit.succ_lt_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_iff_succ_lt : is_succ_limit b ↔ ∀ a < b, succ a < b | ⟨λ hb a, hb.succ_lt, is_succ_limit_of_succ_lt⟩ | lemma | order.is_succ_limit_iff_succ_lt | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_rec_on (b : α)
(hs : Π a, ¬ is_max a → C (succ a)) (hl : Π a, is_succ_limit a → C a) : C b | begin
by_cases hb : is_succ_limit b,
{ exact hl b hb },
{ have H := classical.some_spec (not_is_succ_limit_iff.1 hb),
rw ←H.2,
exact hs _ H.1 }
end | def | order.is_succ_limit_rec_on | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | A value can be built by building it on successors and successor limits. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_succ_limit_rec_on_limit (hs : Π a, ¬ is_max a → C (succ a))
(hl : Π a, is_succ_limit a → C a) (hb : is_succ_limit b) :
@is_succ_limit_rec_on α _ _ C b hs hl = hl b hb | by { classical, exact dif_pos hb } | lemma | order.is_succ_limit_rec_on_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_rec_on_succ' (hs : Π a, ¬ is_max a → C (succ a))
(hl : Π a, is_succ_limit a → C a) {b : α} (hb : ¬ is_max b) :
@is_succ_limit_rec_on α _ _ C (succ b) hs hl = hs b hb | begin
have hb' := not_is_succ_limit_succ_of_not_is_max hb,
have H := classical.some_spec (not_is_succ_limit_iff.1 hb'),
rw is_succ_limit_rec_on,
simp only [cast_eq_iff_heq, hb', not_false_iff, eq_mpr_eq_cast, dif_neg],
congr,
{ exact (succ_eq_succ_iff_of_not_is_max H.1 hb).1 H.2 },
{ apply proof_irrel_heq... | lemma | order.is_succ_limit_rec_on_succ' | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"cast_eq_iff_heq",
"eq_mpr_eq_cast",
"is_max",
"proof_irrel_heq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_rec_on_succ (hs : Π a, ¬ is_max a → C (succ a))
(hl : Π a, is_succ_limit a → C a) (b : α) :
@is_succ_limit_rec_on α _ _ C (succ b) hs hl = hs b (not_is_max b) | is_succ_limit_rec_on_succ' _ _ _ | lemma | order.is_succ_limit_rec_on_succ | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max",
"not_is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_iff_succ_ne : is_succ_limit a ↔ ∀ b, succ b ≠ a | ⟨is_succ_limit.succ_ne, is_succ_limit_of_succ_ne⟩ | lemma | order.is_succ_limit_iff_succ_ne | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit_iff' : ¬ is_succ_limit a ↔ a ∈ range (@succ α _ _) | by { simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff], refl } | lemma | order.not_is_succ_limit_iff' | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"not_forall",
"not_ne_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit.is_min (h : is_succ_limit a) : is_min a | λ b hb, begin
revert h,
refine succ.rec (λ _, le_rfl) (λ c hbc H hc, _) hb,
have := hc.is_max.succ_eq,
rw this at hc ⊢,
exact H hc
end | lemma | order.is_succ_limit.is_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min",
"le_rfl",
"succ.rec"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_iff : is_succ_limit a ↔ is_min a | ⟨is_succ_limit.is_min, is_min.is_succ_limit⟩ | lemma | order.is_succ_limit_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_succ_limit [no_min_order α] : ¬ is_succ_limit a | by simp | lemma | order.not_is_succ_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"no_min_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit (a : α) : Prop | ∀ b, ¬ a ⋖ b | def | order.is_pred_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | A predecessor limit is a value that isn't covered by any other.
It's so named because in a predecessor order, a predecessor limit can't be the predecessor of
anything greater. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
not_is_pred_limit_iff_exists_covby (a : α) : ¬ is_pred_limit a ↔ ∃ b, a ⋖ b | by simp [is_pred_limit] | lemma | order.not_is_pred_limit_iff_exists_covby | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_of_dense [densely_ordered α] (a : α) : is_pred_limit a | λ b, not_covby | lemma | order.is_pred_limit_of_dense | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"densely_ordered",
"not_covby"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_succ_limit_to_dual_iff : is_succ_limit (to_dual a) ↔ is_pred_limit a | by simp [is_succ_limit, is_pred_limit] | lemma | order.is_succ_limit_to_dual_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_to_dual_iff : is_pred_limit (to_dual a) ↔ is_succ_limit a | by simp [is_succ_limit, is_pred_limit] | lemma | order.is_pred_limit_to_dual_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.is_max.is_pred_limit : is_max a → is_pred_limit a | λ h b hab, not_is_max_of_lt hab.lt h | lemma | is_max.is_pred_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max",
"not_is_max_of_lt"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_top [order_top α] : is_pred_limit (⊤ : α) | is_max_top.is_pred_limit | lemma | order.is_pred_limit_top | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"order_top"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.is_min (h : is_pred_limit (pred a)) : is_min a | by { by_contra H, exact h a (pred_covby_of_not_is_min H) } | lemma | order.is_pred_limit.is_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"by_contra",
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_pred_limit_pred_of_not_is_min (ha : ¬ is_min a) : ¬ is_pred_limit (pred a) | by { contrapose! ha, exact ha.is_min } | lemma | order.not_is_pred_limit_pred_of_not_is_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.pred_ne (h : is_pred_limit a) (b : α) : pred b ≠ a | by { rintro rfl, exact not_is_min _ h.is_min } | lemma | order.is_pred_limit.pred_ne | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"not_is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_pred_limit_pred (a : α) : ¬ is_pred_limit (pred a) | λ h, h.pred_ne _ rfl | lemma | order.not_is_pred_limit_pred | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.is_max_of_no_min [no_min_order α] (h : is_pred_limit a) : is_max a | h.dual.is_min_of_no_max | lemma | order.is_pred_limit.is_max_of_no_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max",
"no_min_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_iff_of_no_min [no_min_order α] : is_pred_limit a ↔ is_max a | is_succ_limit_to_dual_iff.symm.trans is_succ_limit_iff_of_no_max | lemma | order.is_pred_limit_iff_of_no_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max",
"no_min_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_pred_limit_of_no_min [no_min_order α] [no_max_order α] : ¬ is_pred_limit a | by simp | lemma | order.not_is_pred_limit_of_no_min | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"no_max_order",
"no_min_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_of_pred_ne (h : ∀ b, pred b ≠ a) : is_pred_limit a | λ b hba, h b hba.pred_eq | lemma | order.is_pred_limit_of_pred_ne | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_pred_limit_iff : ¬ is_pred_limit a ↔ ∃ b, ¬ is_min b ∧ pred b = a | by { rw ←is_succ_limit_to_dual_iff, exact not_is_succ_limit_iff } | lemma | order.not_is_pred_limit_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_range_pred_of_not_is_pred_limit (h : ¬ is_pred_limit a) : a ∈ range (@pred α _ _) | by { cases not_is_pred_limit_iff.1 h with b hb, exact ⟨b, hb.2⟩ } | lemma | order.mem_range_pred_of_not_is_pred_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | See `not_is_pred_limit_iff` for a version that states that `a` is a successor of a value other
than itself. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_pred_limit_of_pred_lt (H : ∀ a > b, pred a < b) : is_pred_limit b | λ a hab, (H a hab.lt).ne hab.pred_eq | lemma | order.is_pred_limit_of_pred_lt | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.lt_pred (h : is_pred_limit a) : a < b → a < pred b | h.dual.succ_lt | lemma | order.is_pred_limit.lt_pred | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.lt_pred_iff (h : is_pred_limit a) : a < pred b ↔ a < b | h.dual.succ_lt_iff | lemma | order.is_pred_limit.lt_pred_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_iff_lt_pred : is_pred_limit a ↔ ∀ ⦃b⦄, a < b → a < pred b | is_succ_limit_to_dual_iff.symm.trans is_succ_limit_iff_succ_lt | lemma | order.is_pred_limit_iff_lt_pred | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_rec_on (b : α)
(hs : Π a, ¬ is_min a → C (pred a)) (hl : Π a, is_pred_limit a → C a) : C b | @is_succ_limit_rec_on αᵒᵈ _ _ _ _ hs (λ a ha, hl _ ha.dual) | def | order.is_pred_limit_rec_on | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | A value can be built by building it on predecessors and predecessor limits. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_pred_limit_rec_on_limit (hs : Π a, ¬ is_min a → C (pred a))
(hl : Π a, is_pred_limit a → C a) (hb : is_pred_limit b) :
@is_pred_limit_rec_on α _ _ C b hs hl = hl b hb | is_succ_limit_rec_on_limit _ _ hb.dual | lemma | order.is_pred_limit_rec_on_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_rec_on_pred' (hs : Π a, ¬ is_min a → C (pred a))
(hl : Π a, is_pred_limit a → C a) {b : α} (hb : ¬ is_min b) :
@is_pred_limit_rec_on α _ _ C (pred b) hs hl = hs b hb | is_succ_limit_rec_on_succ' _ _ _ | lemma | order.is_pred_limit_rec_on_pred' | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_rec_on_pred (hs : Π a, ¬ is_min a → C (pred a))
(hl : Π a, is_pred_limit a → C a) (b : α) :
@is_pred_limit_rec_on α _ _ C (pred b) hs hl = hs b (not_is_min b) | is_succ_limit_rec_on_succ _ _ _ | theorem | order.is_pred_limit_rec_on_pred | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_min",
"not_is_min"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit.is_max (h : is_pred_limit a) : is_max a | h.dual.is_min | lemma | order.is_pred_limit.is_max | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_pred_limit_iff : is_pred_limit a ↔ is_max a | is_succ_limit_to_dual_iff.symm.trans is_succ_limit_iff | lemma | order.is_pred_limit_iff | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"is_max"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_is_pred_limit [no_max_order α] : ¬ is_pred_limit a | by simp | lemma | order.not_is_pred_limit | order.succ_pred | src/order/succ_pred/limit.lean | [
"order.succ_pred.basic"
] | [
"no_max_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
succ_fn (i : ι) : ι | (exists_glb_Ioi i).some | def | linear_locally_finite_order.succ_fn | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"exists_glb_Ioi"
] | Successor in a linear order. This defines a true successor only when `i` is isolated from above,
i.e. when `i` is not the greatest lower bound of `(i, ∞)`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
succ_fn_spec (i : ι) : is_glb (set.Ioi i) (succ_fn i) | (exists_glb_Ioi i).some_spec | lemma | linear_locally_finite_order.succ_fn_spec | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"exists_glb_Ioi",
"is_glb",
"set.Ioi"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_succ_fn (i : ι) : i ≤ succ_fn i | by { rw [le_is_glb_iff (succ_fn_spec i), mem_lower_bounds], exact λ x hx, (le_of_lt hx), } | lemma | linear_locally_finite_order.le_succ_fn | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"le_is_glb_iff",
"mem_lower_bounds"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_glb_Ioc_of_is_glb_Ioi {i j k : ι} (hij_lt : i < j) (h : is_glb (set.Ioi i) k) :
is_glb (set.Ioc i j) k | begin
simp_rw [is_glb, is_greatest, mem_upper_bounds, mem_lower_bounds] at h ⊢,
refine ⟨λ x hx, h.1 x hx.1, λ x hx, h.2 x _⟩,
intros y hy,
cases le_or_lt y j with h_le h_lt,
{ exact hx y ⟨hy, h_le⟩, },
{ exact le_trans (hx j ⟨hij_lt, le_rfl⟩) h_lt.le, },
end | lemma | linear_locally_finite_order.is_glb_Ioc_of_is_glb_Ioi | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"is_glb",
"is_greatest",
"mem_lower_bounds",
"mem_upper_bounds",
"set.Ioc",
"set.Ioi"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_max_of_succ_fn_le [locally_finite_order ι] (i : ι) (hi : succ_fn i ≤ i) : is_max i | begin
refine λ j hij, not_lt.mp (λ hij_lt, _),
have h_succ_fn_eq : succ_fn i = i := le_antisymm hi (le_succ_fn i),
have h_glb : is_glb (finset.Ioc i j : set ι) i,
{ rw finset.coe_Ioc,
have h := succ_fn_spec i,
rw h_succ_fn_eq at h,
exact is_glb_Ioc_of_is_glb_Ioi hij_lt h, },
have hi_mem : i ∈ fins... | lemma | linear_locally_finite_order.is_max_of_succ_fn_le | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"finset.Ioc",
"finset.coe_Ioc",
"finset.is_glb_mem",
"finset.mem_Ioc",
"is_glb",
"is_max",
"locally_finite_order"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
succ_fn_le_of_lt (i j : ι) (hij : i < j) : succ_fn i ≤ j | by { have h := succ_fn_spec i, rw [is_glb, is_greatest, mem_lower_bounds] at h, exact h.1 j hij, } | lemma | linear_locally_finite_order.succ_fn_le_of_lt | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"is_glb",
"is_greatest",
"mem_lower_bounds"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_of_lt_succ_fn (j i : ι) (hij : j < succ_fn i) : j ≤ i | begin
rw lt_is_glb_iff (succ_fn_spec i) at hij,
obtain ⟨k, hk_lb, hk⟩ := hij,
rw mem_lower_bounds at hk_lb,
exact not_lt.mp (λ hi_lt_j, not_le.mpr hk (hk_lb j hi_lt_j)),
end | lemma | linear_locally_finite_order.le_of_lt_succ_fn | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"lt_is_glb_iff",
"mem_lower_bounds"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
linear_locally_finite_order.is_succ_archimedean [locally_finite_order ι] :
is_succ_archimedean ι | { exists_succ_iterate_of_le := λ i j hij,
begin
rw le_iff_lt_or_eq at hij,
cases hij,
swap, { refine ⟨0, _⟩, simpa only [function.iterate_zero, id.def] using hij, },
by_contra h,
push_neg at h,
have h_lt : ∀ n, succ^[n] i < j,
{ intro n,
induction n with n hn,
{ simpa only [fun... | instance | linear_locally_finite_order.is_succ_archimedean | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"by_contra",
"finite.exists_ne_map_eq_of_infinite",
"finset.Icc",
"function.iterate_succ'",
"function.iterate_zero",
"is_max",
"is_succ_archimedean",
"locally_finite_order",
"subtype.mk_eq_mk"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
linear_order.pred_archimedean_of_succ_archimedean [succ_order ι] [pred_order ι]
[is_succ_archimedean ι] :
is_pred_archimedean ι | { exists_pred_iterate_of_le := λ i j hij,
begin
have h_exists := exists_succ_iterate_of_le hij,
obtain ⟨n, hn_eq, hn_lt_ne⟩ : ∃ n, (succ^[n] i = j) ∧ (∀ m < n, succ^[m] i ≠ j),
from ⟨nat.find h_exists, nat.find_spec h_exists, λ m hmn, nat.find_min h_exists hmn⟩,
refine ⟨n, _⟩,
rw ← hn_eq,
in... | instance | linear_order.pred_archimedean_of_succ_archimedean | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"function.iterate_succ'",
"function.iterate_zero",
"is_pred_archimedean",
"is_succ_archimedean",
"not_is_max_of_lt",
"pred_order",
"succ_order",
"tsub_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z (i0 i : ι) : ℤ | dite (i0 ≤ i) (λ hi, nat.find (exists_succ_iterate_of_le hi))
(λ hi, - nat.find (exists_pred_iterate_of_le (not_le.mp hi).le)) | def | to_Z | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [] | `to_Z` numbers elements of `ι` according to their order, starting from `i0`. We prove in
`order_iso_range_to_Z_of_linear_succ_pred_arch` that this defines an `order_iso` between `ι` and
the range of `to_Z`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_Z_of_ge (hi : i0 ≤ i) : to_Z i0 i = nat.find (exists_succ_iterate_of_le hi) | dif_pos hi | lemma | to_Z_of_ge | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"to_Z"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_of_lt (hi : i < i0) : to_Z i0 i = - nat.find (exists_pred_iterate_of_le hi.le) | dif_neg (not_le.mpr hi) | lemma | to_Z_of_lt | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"to_Z"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_of_eq : to_Z i0 i0 = 0 | begin
rw to_Z_of_ge le_rfl,
norm_cast,
refine le_antisymm (nat.find_le _) (zero_le _),
rw [function.iterate_zero, id.def],
end | lemma | to_Z_of_eq | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"function.iterate_zero",
"le_rfl",
"nat.find_le",
"to_Z",
"to_Z_of_ge"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
iterate_succ_to_Z (i : ι) (hi : i0 ≤ i) : succ^[(to_Z i0 i).to_nat] i0 = i | by { rw [to_Z_of_ge hi, int.to_nat_coe_nat], exact nat.find_spec (exists_succ_iterate_of_le hi), } | lemma | iterate_succ_to_Z | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"int.to_nat_coe_nat",
"to_Z",
"to_Z_of_ge",
"to_nat"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
iterate_pred_to_Z (i : ι) (hi : i < i0) : pred^[(- to_Z i0 i).to_nat] i0 = i | begin
rw [to_Z_of_lt hi, neg_neg, int.to_nat_coe_nat],
exact nat.find_spec (exists_pred_iterate_of_le hi.le),
end | lemma | iterate_pred_to_Z | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"int.to_nat_coe_nat",
"to_Z",
"to_Z_of_lt",
"to_nat"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_nonneg (hi : i0 ≤ i) : 0 ≤ to_Z i0 i | by { rw to_Z_of_ge hi, exact nat.cast_nonneg _, } | lemma | to_Z_nonneg | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"nat.cast_nonneg",
"to_Z",
"to_Z_of_ge"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_neg (hi : i < i0) : to_Z i0 i < 0 | begin
refine lt_of_le_of_ne _ _,
{ rw [to_Z_of_lt hi, neg_nonpos], exact nat.cast_nonneg _, },
{ by_contra,
have h_eq := iterate_pred_to_Z i hi,
rw [← h_eq, h] at hi,
simpa only [neg_zero, int.to_nat_zero, function.iterate_zero, id.def, lt_self_iff_false]
using hi, },
end | lemma | to_Z_neg | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"by_contra",
"function.iterate_zero",
"int.to_nat_zero",
"iterate_pred_to_Z",
"lt_self_iff_false",
"nat.cast_nonneg",
"to_Z",
"to_Z_of_lt"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_iterate_succ_le (n : ℕ) : to_Z i0 (succ^[n] i0) ≤ n | begin
rw to_Z_of_ge (le_succ_iterate _ _),
norm_cast,
exact nat.find_min' (exists_succ_iterate_of_le _) rfl,
end | lemma | to_Z_iterate_succ_le | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"to_Z",
"to_Z_of_ge"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_iterate_pred_ge (n : ℕ) : -(n : ℤ) ≤ to_Z i0 (pred^[n] i0) | begin
cases le_or_lt i0 (pred^[n] i0) with h h,
{ have h_eq : (pred^[n] i0) = i0 := le_antisymm (pred_iterate_le _ _) h,
rw [h_eq, to_Z_of_eq],
simp only [right.neg_nonpos_iff, nat.cast_nonneg],},
{ rw [to_Z_of_lt h, neg_le_neg_iff],
norm_cast,
exact nat.find_min' (exists_pred_iterate_of_le _) rfl... | lemma | to_Z_iterate_pred_ge | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"nat.cast_nonneg",
"to_Z",
"to_Z_of_eq",
"to_Z_of_lt"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_iterate_succ_of_not_is_max (n : ℕ) (hn : ¬ is_max (succ^[n] i0)) :
to_Z i0 (succ^[n] i0) = n | begin
let m := (to_Z i0 (succ^[n] i0)).to_nat,
have h_eq : (succ^[m] i0) = (succ^[n] i0) := iterate_succ_to_Z _ (le_succ_iterate _ _),
by_cases hmn : m = n,
{ nth_rewrite 1 ← hmn,
simp_rw [m],
rw [int.to_nat_eq_max, to_Z_of_ge (le_succ_iterate _ _), max_eq_left],
exact nat.cast_nonneg _, },
suffic... | lemma | to_Z_iterate_succ_of_not_is_max | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"int.to_nat_eq_max",
"is_max",
"iterate_succ_to_Z",
"nat.cast_nonneg",
"to_Z",
"to_Z_of_ge",
"to_nat"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_iterate_pred_of_not_is_min (n : ℕ) (hn : ¬ is_min (pred^[n] i0)) :
to_Z i0 (pred^[n] i0) = -n | begin
cases n,
{ simp only [function.iterate_zero, id.def, to_Z_of_eq, nat.cast_zero, neg_zero], },
have : (pred^[n.succ] i0) < i0,
{ refine lt_of_le_of_ne (pred_iterate_le _ _) (λ h_pred_iterate_eq, hn _),
have h_pred_eq_pred : (pred^[n.succ] i0) = (pred^[0] i0),
{ rwa [function.iterate_zero, id.def], ... | lemma | to_Z_iterate_pred_of_not_is_min | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"function.iterate_zero",
"int.to_nat_eq_max",
"is_min",
"iterate_pred_to_Z",
"nat.cast_nonneg",
"nat.cast_zero",
"to_Z",
"to_Z_of_eq",
"to_Z_of_lt",
"to_nat"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_of_to_Z_le {j : ι} (h_le : to_Z i0 i ≤ to_Z i0 j) : i ≤ j | begin
cases le_or_lt i0 i with hi hi; cases le_or_lt i0 j with hj hj,
{ rw [← iterate_succ_to_Z i hi, ← iterate_succ_to_Z j hj],
exact monotone.monotone_iterate_of_le_map succ_mono (le_succ _) (int.to_nat_le_to_nat h_le), },
{ exact absurd ((to_Z_neg hj).trans_le (to_Z_nonneg hi)) (not_lt.mpr h_le), },
{ ex... | lemma | le_of_to_Z_le | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"int.to_nat_le_to_nat",
"iterate_pred_to_Z",
"iterate_succ_to_Z",
"monotone.antitone_iterate_of_map_le",
"monotone.monotone_iterate_of_le_map",
"to_Z",
"to_Z_neg",
"to_Z_nonneg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_Z_mono {i j : ι} (h_le : i ≤ j) : to_Z i0 i ≤ to_Z i0 j | begin
by_cases hi_max : is_max i,
{ rw le_antisymm h_le (hi_max h_le), },
by_cases hj_min : is_min j,
{ rw le_antisymm h_le (hj_min h_le), },
cases le_or_lt i0 i with hi hi; cases le_or_lt i0 j with hj hj,
{ let m := nat.find (exists_succ_iterate_of_le h_le),
have hm : (succ^[m] i = j) := nat.find_spec ... | lemma | to_Z_mono | order.succ_pred | src/order/succ_pred/linear_locally_finite.lean | [
"order.locally_finite",
"order.succ_pred.basic",
"order.hom.basic",
"data.countable.basic",
"logic.encodable.basic"
] | [
"by_contra",
"function.iterate_add",
"function.iterate_succ'",
"function.iterate_zero",
"is_max",
"is_min",
"iterate_pred_to_Z",
"iterate_succ_to_Z",
"le_of_to_Z_le",
"monotone.antitone_iterate_of_map_le",
"monotone.monotone_iterate_of_le_map",
"to_Z",
"to_Z_neg",
"to_Z_nonneg",
"to_nat"... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.