Locally finite orders

This file defines locally finite orders.

A locally finite order is an order for which all bounded intervals are finite. This allows to make sense of Icc/Ico/Ioc/Ioo as lists, multisets, or finsets. Further, if the order is bounded above (resp. below), then we can also make sense of the "unbounded" intervals Ici/Ioi (resp. Iic/Iio).

Many theorems about these intervals can be found in Data.Finset.LocallyFinite.

Examples

Naturally occurring locally finite orders are ℕ, ℤ, ℕ+, Fin n, α × β the product of two locally finite orders, α →₀ β the finitely supported functions to a locally finite order β...

Main declarations

In a LocallyFiniteOrder,

• Finset.Icc: Closed-closed interval as a finset.
• Finset.Ico: Closed-open interval as a finset.
• Finset.Ioc: Open-closed interval as a finset.
• Finset.Ioo: Open-open interval as a finset.
• Finset.uIcc: Unordered closed interval as a finset.
• Multiset.Icc: Closed-closed interval as a multiset.
• Multiset.Ico: Closed-open interval as a multiset.
• Multiset.Ioc: Open-closed interval as a multiset.
• Multiset.Ioo: Open-open interval as a multiset.

In a LocallyFiniteOrderTop,

• Finset.Ici: Closed-infinite interval as a finset.
• Finset.Ioi: Open-infinite interval as a finset.
• Multiset.Ici: Closed-infinite interval as a multiset.
• Multiset.Ioi: Open-infinite interval as a multiset.

In a LocallyFiniteOrderBot,

• Finset.Iic: Infinite-open interval as a finset.
• Finset.Iio: Infinite-closed interval as a finset.
• Multiset.Iic: Infinite-open interval as a multiset.
• Multiset.Iio: Infinite-closed interval as a multiset.

Instances

A LocallyFiniteOrder instance can be built

• for a subtype of a locally finite order. See Subtype.locallyFiniteOrder.
• for the product of two locally finite orders. See Prod.locallyFiniteOrder.
• for any fintype (but not as an instance). See Fintype.toLocallyFiniteOrder.
• from a definition of Finset.Icc alone. See LocallyFiniteOrder.ofIcc.
• by pulling back LocallyFiniteOrder β through an order embedding f : α →o β. See OrderEmbedding.locallyFiniteOrder.

Instances for concrete types are proved in their respective files:

• ℕ is in Data.Nat.Interval
• ℤ is in Data.Int.Interval
• ℕ+ is in Data.PNat.Interval
• Fin n is in Data.Fin.Interval
• Finset α is in Data.Finset.Interval
• Σ i, α i is in Data.Sigma.Interval Along, you will find lemmas about the cardinality of those finite intervals.

TODO

Provide the LocallyFiniteOrder instance for α ×ₗ β where LocallyFiniteOrder α and Fintype β.

Provide the LocallyFiniteOrder instance for α →₀ β where β is locally finite. Provide the LocallyFiniteOrder instance for Π₀ i, β i where all the β i are locally finite.

From LinearOrder α, NoMaxOrder α, LocallyFiniteOrder α, we can also define an order isomorphism α ≃ ℕ or α ≃ ℤ, depending on whether we have OrderBot α or NoMinOrder α and Nonempty α. When OrderBot α, we can match a : α to (Iio a).card.

We can provide SuccOrder α from LinearOrder α and LocallyFiniteOrder α using

lemma exists_min_greater [LinearOrder α] [LocallyFiniteOrder α] {x ub : α} (hx : x < ub) :
    ∃ lub, x < lub ∧ ∀ y, x < y → lub ≤ y := by
  -- very non golfed
  have h : (Finset.Ioc x ub).Nonempty := ⟨ub, Finset.mem_Ioc.2 ⟨hx, le_rfl⟩⟩
  use Finset.min' (Finset.Ioc x ub) h
  constructor
  · exact (Finset.mem_Ioc.mp <| Finset.min'_mem _ h).1
  rintro y hxy
  obtain hy | hy := le_total y ub
  · refine Finset.min'_le (Ioc x ub) y ?_
    simp [*] at *
  · exact (Finset.min'_le _ _ (Finset.mem_Ioc.2 ⟨hx, le_rfl⟩)).trans hy

Note that the converse is not true. Consider {-2^z | z : ℤ} ∪ {2^z | z : ℤ}. Any element has a successor (and actually a predecessor as well), so it is a SuccOrder, but it's not locally finite as Icc (-1) 1 is infinite.

class LocallyFiniteOrder (α : Type u_1) [Preorder α] : Type u_1

• finsetIcc : α → α → Finset α

  Left-closed right-closed interval

• finsetIco : α → α → Finset α

  Left-closed right-open interval

• finsetIoc : α → α → Finset α

  Left-open right-closed interval

• finsetIoo : α → α → Finset α

  Left-open right-open interval

• finset_mem_Icc : ∀ (a b x : α), x ∈ LocallyFiniteOrder.finsetIcc a b ↔ a ≤ x ∧ x ≤ b

  x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b

• finset_mem_Ico : ∀ (a b x : α), x ∈ LocallyFiniteOrder.finsetIco a b ↔ a ≤ x ∧ x < b

  x ∈ finsetIco a b ↔ a ≤ x ∧ x < b

• finset_mem_Ioc : ∀ (a b x : α), x ∈ LocallyFiniteOrder.finsetIoc a b ↔ a < x ∧ x ≤ b

  x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b

• finset_mem_Ioo : ∀ (a b x : α), x ∈ LocallyFiniteOrder.finsetIoo a b ↔ a < x ∧ x < b

  x ∈ finsetIoo a b ↔ a < x ∧ x < b

This is a mixin class describing a locally finite order, that is, is an order where bounded intervals are finite. When you don't care too much about definitional equality, you can use LocallyFiniteOrder.ofIcc or LocallyFiniteOrder.ofFiniteIcc to build a locally finite order from just Finset.Icc.

class LocallyFiniteOrderTop (α : Type u_1) [Preorder α] : Type u_1

• finsetIoi : α → Finset α

  Left-open right-infinite interval

• finsetIci : α → Finset α

  Left-closed right-infinite interval

• finset_mem_Ici : ∀ (a x : α), x ∈ LocallyFiniteOrderTop.finsetIci a ↔ a ≤ x

  x ∈ finsetIci a ↔ a ≤ x

• finset_mem_Ioi : ∀ (a x : α), x ∈ LocallyFiniteOrderTop.finsetIoi a ↔ a < x

  x ∈ finsetIoi a ↔ a < x

This mixin class describes an order where all intervals bounded below are finite. This is slightly weaker than LocallyFiniteOrder + OrderTop as it allows empty types.

class LocallyFiniteOrderBot (α : Type u_1) [Preorder α] : Type u_1

• finsetIio : α → Finset α

  Left-infinite right-open interval

• finsetIic : α → Finset α

  Left-infinite right-closed interval

• finset_mem_Iic : ∀ (a x : α), x ∈ LocallyFiniteOrderBot.finsetIic a ↔ x ≤ a

  x ∈ finsetIic a ↔ x ≤ a

• finset_mem_Iio : ∀ (a x : α), x ∈ LocallyFiniteOrderBot.finsetIio a ↔ x < a

  x ∈ finsetIio a ↔ x < a

This mixin class describes an order where all intervals bounded above are finite. This is slightly weaker than LocallyFiniteOrder + OrderBot as it allows empty types.

def LocallyFiniteOrder.ofIcc' (α : Type u_1) [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (finsetIcc : α → α → Finset α) (mem_Icc : ∀ (a b x : α), x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b) : LocallyFiniteOrder α

A constructor from a definition of Finset.Icc alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrder.ofIcc, this one requires DecidableRel (· ≤ ·) but only Preorder.

def LocallyFiniteOrder.ofIcc (α : Type u_1) [PartialOrder α] [DecidableEq α] (finsetIcc : α → α → Finset α) (mem_Icc : ∀ (a b x : α), x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b) : LocallyFiniteOrder α

A constructor from a definition of Finset.Icc alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrder.ofIcc, this one requires PartialOrder but only DecidableEq.

def LocallyFiniteOrderTop.ofIci' (α : Type u_1) [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (finsetIci : α → Finset α) (mem_Ici : ∀ (a x : α), x ∈ finsetIci a ↔ a ≤ x) : LocallyFiniteOrderTop α

A constructor from a definition of Finset.Iic alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrderTop.ofIci, this one requires DecidableRel (· ≤ ·) but only Preorder.

def LocallyFiniteOrderTop.ofIci (α : Type u_1) [PartialOrder α] [DecidableEq α] (finsetIci : α → Finset α) (mem_Ici : ∀ (a x : α), x ∈ finsetIci a ↔ a ≤ x) : LocallyFiniteOrderTop α

A constructor from a definition of Finset.Iic alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrderTop.ofIci', this one requires PartialOrder but only DecidableEq.

def LocallyFiniteOrderBot.ofIic' (α : Type u_1) [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] (finsetIic : α → Finset α) (mem_Iic : ∀ (a x : α), x ∈ finsetIic a ↔ x ≤ a) : LocallyFiniteOrderBot α

A constructor from a definition of Finset.Iic alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrder.ofIcc, this one requires DecidableRel (· ≤ ·) but only Preorder.

def LocallyFiniteOrderTop.ofIic (α : Type u_1) [PartialOrder α] [DecidableEq α] (finsetIic : α → Finset α) (mem_Iic : ∀ (a x : α), x ∈ finsetIic a ↔ x ≤ a) : LocallyFiniteOrderBot α

A constructor from a definition of Finset.Iic alone, the other ones being derived by removing the ends. As opposed to LocallyFiniteOrderTop.ofIci', this one requires PartialOrder but only DecidableEq.

@[reducible]

def IsEmpty.toLocallyFiniteOrder {α : Type u_1} [Preorder α] [IsEmpty α] : LocallyFiniteOrder α

An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances.

@[reducible]

def IsEmpty.toLocallyFiniteOrderTop {α : Type u_1} [Preorder α] [IsEmpty α] : LocallyFiniteOrderTop α

An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances.

@[reducible]

def IsEmpty.toLocallyFiniteOrderBot {α : Type u_1} [Preorder α] [IsEmpty α] : LocallyFiniteOrderBot α

An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances.

Intervals as finsets

def Finset.Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset α

The finset of elements x such that a ≤ x and x ≤ b. Basically Set.Icc a b as a finset.

def Finset.Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset α

The finset of elements x such that a ≤ x and x < b. Basically Set.Ico a b as a finset.

def Finset.Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset α

The finset of elements x such that a < x and x ≤ b. Basically Set.Ioc a b as a finset.

def Finset.Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset α

The finset of elements x such that a < x and x < b. Basically Set.Ioo a b as a finset.

@[simp]

theorem Finset.mem_Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Finset.Icc a b ↔ a ≤ x ∧ x ≤ b

@[simp]

theorem Finset.mem_Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Finset.Ico a b ↔ a ≤ x ∧ x < b

@[simp]

theorem Finset.mem_Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Finset.Ioc a b ↔ a < x ∧ x ≤ b

@[simp]

theorem Finset.mem_Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Finset.Ioo a b ↔ a < x ∧ x < b

@[simp]

theorem Finset.coe_Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : ↑(Finset.Icc a b) = Set.Icc a b

@[simp]

theorem Finset.coe_Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : ↑(Finset.Ico a b) = Set.Ico a b

@[simp]

theorem Finset.coe_Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : ↑(Finset.Ioc a b) = Set.Ioc a b

@[simp]

theorem Finset.coe_Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : ↑(Finset.Ioo a b) = Set.Ioo a b

def Finset.Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Finset α

The finset of elements x such that a ≤ x. Basically Set.Ici a as a finset.

def Finset.Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Finset α

The finset of elements x such that a < x. Basically Set.Ioi a as a finset.

@[simp]

theorem Finset.mem_Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] {a : α} {x : α} : x ∈ Finset.Ici a ↔ a ≤ x

@[simp]

theorem Finset.mem_Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] {a : α} {x : α} : x ∈ Finset.Ioi a ↔ a < x

@[simp]

theorem Finset.coe_Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : ↑(Finset.Ici a) = Set.Ici a

@[simp]

theorem Finset.coe_Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : ↑(Finset.Ioi a) = Set.Ioi a

def Finset.Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : Finset α

The finset of elements x such that a ≤ x. Basically Set.Iic a as a finset.

def Finset.Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : Finset α

The finset of elements x such that a < x. Basically Set.Iio a as a finset.

@[simp]

theorem Finset.mem_Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] {a : α} {x : α} : x ∈ Finset.Iic a ↔ x ≤ a

@[simp]

theorem Finset.mem_Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] {a : α} {x : α} : x ∈ Finset.Iio a ↔ x < a

@[simp]

theorem Finset.coe_Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : ↑(Finset.Iic a) = Set.Iic a

@[simp]

theorem Finset.coe_Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : ↑(Finset.Iio a) = Set.Iio a

instance LocallyFiniteOrder.toLocallyFiniteOrderTop {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] [OrderTop α] : LocallyFiniteOrderTop α

theorem Finset.Ici_eq_Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] [OrderTop α] (a : α) : Finset.Ici a = Finset.Icc a ⊤

theorem Finset.Ioi_eq_Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] [OrderTop α] (a : α) : Finset.Ioi a = Finset.Ioc a ⊤

instance Finset.LocallyFiniteOrder.toLocallyFiniteOrderBot {α : Type u_1} [Preorder α] [OrderBot α] [LocallyFiniteOrder α] : LocallyFiniteOrderBot α

theorem Finset.Iic_eq_Icc {α : Type u_1} [Preorder α] [OrderBot α] [LocallyFiniteOrder α] : Finset.Iic = Finset.Icc ⊥

theorem Finset.Iio_eq_Ico {α : Type u_1} [Preorder α] [OrderBot α] [LocallyFiniteOrder α] : Finset.Iio = Finset.Ico ⊥

def Finset.uIcc {α : Type u_1} [Lattice α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset α

Finset.uIcc a b is the set of elements lying between a and b, with a and b included. Note that we define it more generally in a lattice as Finset.Icc (a ⊓ b) (a ⊔ b). In a product type, Finset.uIcc corresponds to the bounding box of the two elements.

def FinsetInterval.«term[[_,_]]» : Lean.ParserDescr

Finset.uIcc a b is the set of elements lying between a and b, with a and b included. Note that we define it more generally in a lattice as Finset.Icc (a ⊓ b) (a ⊔ b). In a product type, Finset.uIcc corresponds to the bounding box of the two elements.

@[simp]

theorem Finset.mem_uIcc {α : Type u_1} [Lattice α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Finset.uIcc a b ↔ a ⊓ b ≤ x ∧ x ≤ a ⊔ b

@[simp]

theorem Finset.coe_uIcc {α : Type u_1} [Lattice α] [LocallyFiniteOrder α] (a : α) (b : α) : ↑(Finset.uIcc a b) = Set.uIcc a b

Intervals as multisets

def Multiset.Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Multiset α

The multiset of elements x such that a ≤ x and x ≤ b. Basically Set.Icc a b as a multiset.

def Multiset.Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Multiset α

The multiset of elements x such that a ≤ x and x < b. Basically Set.Ico a b as a multiset.

def Multiset.Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Multiset α

The multiset of elements x such that a < x and x ≤ b. Basically Set.Ioc a b as a multiset.

def Multiset.Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Multiset α

The multiset of elements x such that a < x and x < b. Basically Set.Ioo a b as a multiset.

@[simp]

theorem Multiset.mem_Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Multiset.Icc a b ↔ a ≤ x ∧ x ≤ b

@[simp]

theorem Multiset.mem_Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Multiset.Ico a b ↔ a ≤ x ∧ x < b

@[simp]

theorem Multiset.mem_Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Multiset.Ioc a b ↔ a < x ∧ x ≤ b

@[simp]

theorem Multiset.mem_Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] {a : α} {b : α} {x : α} : x ∈ Multiset.Ioo a b ↔ a < x ∧ x < b

def Multiset.Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Multiset α

The multiset of elements x such that a ≤ x. Basically Set.Ici a as a multiset.

def Multiset.Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Multiset α

The multiset of elements x such that a < x. Basically Set.Ioi a as a multiset.

@[simp]

theorem Multiset.mem_Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] {a : α} {x : α} : x ∈ Multiset.Ici a ↔ a ≤ x

@[simp]

theorem Multiset.mem_Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] {a : α} {x : α} : x ∈ Multiset.Ioi a ↔ a < x

def Multiset.Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Multiset α

The multiset of elements x such that x ≤ b. Basically Set.Iic b as a multiset.

def Multiset.Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Multiset α

The multiset of elements x such that x < b. Basically Set.Iio b as a multiset.

@[simp]

theorem Multiset.mem_Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] {b : α} {x : α} : x ∈ Multiset.Iic b ↔ x ≤ b

@[simp]

theorem Multiset.mem_Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] {b : α} {x : α} : x ∈ Multiset.Iio b ↔ x < b

Finiteness of Set intervals

instance Set.fintypeIcc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Fintype ↑(Set.Icc a b)

instance Set.fintypeIco {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Fintype ↑(Set.Ico a b)

instance Set.fintypeIoc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Fintype ↑(Set.Ioc a b)

instance Set.fintypeIoo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Fintype ↑(Set.Ioo a b)

theorem Set.finite_Icc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Set.Finite (Set.Icc a b)

theorem Set.finite_Ico {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Set.Finite (Set.Ico a b)

theorem Set.finite_Ioc {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Set.Finite (Set.Ioc a b)

theorem Set.finite_Ioo {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Set.Finite (Set.Ioo a b)

instance Set.fintypeIci {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Fintype ↑(Set.Ici a)

instance Set.fintypeIoi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Fintype ↑(Set.Ioi a)

theorem Set.finite_Ici {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Set.Finite (Set.Ici a)

theorem Set.finite_Ioi {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Set.Finite (Set.Ioi a)

instance Set.fintypeIic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Fintype ↑(Set.Iic b)

instance Set.fintypeIio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Fintype ↑(Set.Iio b)

theorem Set.finite_Iic {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Set.Finite (Set.Iic b)

theorem Set.finite_Iio {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (b : α) : Set.Finite (Set.Iio b)

instance Set.fintypeUIcc {α : Type u_1} [Lattice α] [LocallyFiniteOrder α] (a : α) (b : α) : Fintype ↑(Set.uIcc a b)

@[simp]

theorem Set.finite_interval {α : Type u_1} [Lattice α] [LocallyFiniteOrder α] (a : α) (b : α) : Set.Finite (Set.uIcc a b)

Instances

noncomputable def LocallyFiniteOrder.ofFiniteIcc {α : Type u_1} [Preorder α] (h : ∀ (a b : α), Set.Finite (Set.Icc a b)) : LocallyFiniteOrder α

A noncomputable constructor from the finiteness of all closed intervals.

@[reducible]

def Fintype.toLocallyFiniteOrder {α : Type u_1} [Preorder α] [Fintype α] [DecidableRel fun x x_1 => x < x_1] [DecidableRel fun x x_1 => x ≤ x_1] : LocallyFiniteOrder α

A fintype is a locally finite order.

This is not an instance as it would not be defeq to better instances such as Fin.locallyFiniteOrder.

instance instSubsingletonLocallyFiniteOrder {α : Type u_1} [Preorder α] : Subsingleton (LocallyFiniteOrder α)

instance instSubsingletonLocallyFiniteOrderTop {α : Type u_1} [Preorder α] : Subsingleton (LocallyFiniteOrderTop α)

instance instSubsingletonLocallyFiniteOrderBot {α : Type u_1} [Preorder α] : Subsingleton (LocallyFiniteOrderBot α)

noncomputable def OrderEmbedding.locallyFiniteOrder {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder β] (f : α ↪o β) : LocallyFiniteOrder α

Given an order embedding α ↪o β, pulls back the LocallyFiniteOrder on β to α.

instance OrderDual.locallyFiniteOrder {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] : LocallyFiniteOrder αᵒᵈ

Note we define Icc (toDual a) (toDual b) as Icc α _ _ b a (which has type Finset α not Finset αᵒᵈ!) instead of (Icc b a).map toDual.toEmbedding as this means the following is defeq:

lemma this : (Icc (toDual (toDual a)) (toDual (toDual b)) : _) = (Icc a b : _) := rfl

theorem Icc_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Icc (↑OrderDual.toDual a) (↑OrderDual.toDual b) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Icc b a)

theorem Ico_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ico (↑OrderDual.toDual a) (↑OrderDual.toDual b) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Ioc b a)

theorem Ioc_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioc (↑OrderDual.toDual a) (↑OrderDual.toDual b) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Ico b a)

theorem Ioo_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioo (↑OrderDual.toDual a) (↑OrderDual.toDual b) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Ioo b a)

theorem Icc_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : αᵒᵈ) (b : αᵒᵈ) : Finset.Icc (↑OrderDual.ofDual a) (↑OrderDual.ofDual b) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Icc b a)

theorem Ico_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : αᵒᵈ) (b : αᵒᵈ) : Finset.Ico (↑OrderDual.ofDual a) (↑OrderDual.ofDual b) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Ioc b a)

theorem Ioc_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : αᵒᵈ) (b : αᵒᵈ) : Finset.Ioc (↑OrderDual.ofDual a) (↑OrderDual.ofDual b) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Ico b a)

theorem Ioo_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrder α] (a : αᵒᵈ) (b : αᵒᵈ) : Finset.Ioo (↑OrderDual.ofDual a) (↑OrderDual.ofDual b) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Ioo b a)

instance instLocallyFiniteOrderBotOrderDualInstPreorder {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] : LocallyFiniteOrderBot αᵒᵈ

Note we define Iic (toDual a) as Ici a (which has type Finset α not Finset αᵒᵈ!) instead of (Ici a).map toDual.toEmbedding as this means the following is defeq:

lemma this : (Iic (toDual (toDual a)) : _) = (Iic a : _) := rfl

theorem Iic_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Finset.Iic (↑OrderDual.toDual a) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Ici a)

theorem Iio_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : α) : Finset.Iio (↑OrderDual.toDual a) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Ioi a)

theorem Ici_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : αᵒᵈ) : Finset.Ici (↑OrderDual.ofDual a) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Iic a)

theorem Ioi_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderTop α] (a : αᵒᵈ) : Finset.Ioi (↑OrderDual.ofDual a) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Iio a)

instance instLocallyFiniteOrderTopOrderDualInstPreorder {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] : LocallyFiniteOrderTop αᵒᵈ

Note we define Ici (toDual a) as Iic a (which has type Finset α not Finset αᵒᵈ!) instead of (Iic a).map toDual.toEmbedding as this means the following is defeq:

lemma this : (Ici (toDual (toDual a)) : _) = (Ici a : _) := rfl

theorem Ici_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : Finset.Ici (↑OrderDual.toDual a) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Iic a)

theorem Ioi_toDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : α) : Finset.Ioi (↑OrderDual.toDual a) = Finset.map (Equiv.toEmbedding OrderDual.toDual) (Finset.Iio a)

theorem Iic_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : αᵒᵈ) : Finset.Iic (↑OrderDual.ofDual a) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Ici a)

theorem Iio_ofDual {α : Type u_1} [Preorder α] [LocallyFiniteOrderBot α] (a : αᵒᵈ) : Finset.Iio (↑OrderDual.ofDual a) = Finset.map (Equiv.toEmbedding OrderDual.ofDual) (Finset.Ioi a)

instance Prod.instLocallyFiniteOrderProdInstPreorderProd {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] : LocallyFiniteOrder (α × β)

instance Prod.instLocallyFiniteOrderTopProdInstPreorderProd {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrderTop α] [LocallyFiniteOrderTop β] [DecidableRel fun x x_1 => x ≤ x_1] : LocallyFiniteOrderTop (α × β)

instance Prod.instLocallyFiniteOrderBotProdInstPreorderProd {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrderBot α] [LocallyFiniteOrderBot β] [DecidableRel fun x x_1 => x ≤ x_1] : LocallyFiniteOrderBot (α × β)

theorem Prod.Icc_eq {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (p : α × β) (q : α × β) : Finset.Icc p q = Finset.Icc p.fst q.fst ×ˢ Finset.Icc p.snd q.snd

@[simp]

theorem Prod.Icc_mk_mk {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β) : Finset.Icc (a₁, b₁) (a₂, b₂) = Finset.Icc a₁ a₂ ×ˢ Finset.Icc b₁ b₂

theorem Prod.card_Icc {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (p : α × β) (q : α × β) : Finset.card (Finset.Icc p q) = Finset.card (Finset.Icc p.fst q.fst) * Finset.card (Finset.Icc p.snd q.snd)

theorem Prod.uIcc_eq {α : Type u_1} {β : Type u_2} [Lattice α] [Lattice β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (p : α × β) (q : α × β) : Finset.uIcc p q = Finset.uIcc p.fst q.fst ×ˢ Finset.uIcc p.snd q.snd

@[simp]

theorem Prod.uIcc_mk_mk {α : Type u_1} {β : Type u_2} [Lattice α] [Lattice β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β) : Finset.uIcc (a₁, b₁) (a₂, b₂) = Finset.uIcc a₁ a₂ ×ˢ Finset.uIcc b₁ b₂

theorem Prod.card_uIcc {α : Type u_1} {β : Type u_2} [Lattice α] [Lattice β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] [DecidableRel fun x x_1 => x ≤ x_1] (p : α × β) (q : α × β) : Finset.card (Finset.uIcc p q) = Finset.card (Finset.uIcc p.fst q.fst) * Finset.card (Finset.uIcc p.snd q.snd)

WithTop, WithBot

Adding a ⊤ to a locally finite OrderTop keeps it locally finite. Adding a ⊥ to a locally finite OrderBot keeps it locally finite.

instance WithTop.locallyFiniteOrder (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] : LocallyFiniteOrder (WithTop α)

theorem WithTop.Icc_coe_top (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) : Finset.Icc ↑a ⊤ = ↑Finset.insertNone (Finset.Ici a)

theorem WithTop.Icc_coe_coe (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Icc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Icc a b)

theorem WithTop.Ico_coe_top (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) : Finset.Ico ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ici a)

theorem WithTop.Ico_coe_coe (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ico ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ico a b)

theorem WithTop.Ioc_coe_top (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) : Finset.Ioc ↑a ⊤ = ↑Finset.insertNone (Finset.Ioi a)

theorem WithTop.Ioc_coe_coe (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioc a b)

theorem WithTop.Ioo_coe_top (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) : Finset.Ioo ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ioi a)

theorem WithTop.Ioo_coe_coe (α : Type u_1) [PartialOrder α] [OrderTop α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioo ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioo a b)

instance WithBot.instLocallyFiniteOrderWithBotPreorderToPreorder (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] : LocallyFiniteOrder (WithBot α)

theorem WithBot.Icc_bot_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (b : α) : Finset.Icc ⊥ ↑b = ↑Finset.insertNone (Finset.Iic b)

theorem WithBot.Icc_coe_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Icc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Icc a b)

theorem WithBot.Ico_bot_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (b : α) : Finset.Ico ⊥ ↑b = ↑Finset.insertNone (Finset.Iio b)

theorem WithBot.Ico_coe_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ico ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ico a b)

theorem WithBot.Ioc_bot_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (b : α) : Finset.Ioc ⊥ ↑b = Finset.map Function.Embedding.some (Finset.Iic b)

theorem WithBot.Ioc_coe_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioc a b)

theorem WithBot.Ioo_bot_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (b : α) : Finset.Ioo ⊥ ↑b = Finset.map Function.Embedding.some (Finset.Iio b)

theorem WithBot.Ioo_coe_coe (α : Type u_1) [PartialOrder α] [OrderBot α] [LocallyFiniteOrder α] (a : α) (b : α) : Finset.Ioo ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioo a b)

Transfer locally finite orders across order isomorphisms

@[reducible]

def OrderIso.locallyFiniteOrder {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder β] (f : α ≃o β) : LocallyFiniteOrder α

Transfer LocallyFiniteOrder across an OrderIso.

@[reducible]

def OrderIso.locallyFiniteOrderTop {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrderTop β] (f : α ≃o β) : LocallyFiniteOrderTop α

Transfer LocallyFiniteOrderTop across an OrderIso.

@[reducible]

def OrderIso.locallyFiniteOrderBot {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrderBot β] (f : α ≃o β) : LocallyFiniteOrderBot α

Transfer LocallyFiniteOrderBot across an OrderIso.

Subtype of a locally finite order

instance Subtype.instLocallyFiniteOrder {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] : LocallyFiniteOrder (Subtype p)

instance Subtype.instLocallyFiniteOrderTop {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderTop α] : LocallyFiniteOrderTop (Subtype p)

instance Subtype.instLocallyFiniteOrderBot {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderBot α] : LocallyFiniteOrderBot (Subtype p)

theorem Finset.subtype_Icc_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) : Finset.Icc a b = Finset.subtype p (Finset.Icc ↑a ↑b)

theorem Finset.subtype_Ico_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) : Finset.Ico a b = Finset.subtype p (Finset.Ico ↑a ↑b)

theorem Finset.subtype_Ioc_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) : Finset.Ioc a b = Finset.subtype p (Finset.Ioc ↑a ↑b)

theorem Finset.subtype_Ioo_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) : Finset.Ioo a b = Finset.subtype p (Finset.Ioo ↑a ↑b)

theorem Finset.map_subtype_embedding_Icc {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) (hp : ⦃a b x : α⦄ → a ≤ x → x ≤ b → p a → p b → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Icc a b) = Finset.Icc ↑a ↑b

theorem Finset.map_subtype_embedding_Ico {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) (hp : ⦃a b x : α⦄ → a ≤ x → x ≤ b → p a → p b → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Ico a b) = Finset.Ico ↑a ↑b

theorem Finset.map_subtype_embedding_Ioc {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) (hp : ⦃a b x : α⦄ → a ≤ x → x ≤ b → p a → p b → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Ioc a b) = Finset.Ioc ↑a ↑b

theorem Finset.map_subtype_embedding_Ioo {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrder α] (a : Subtype p) (b : Subtype p) (hp : ⦃a b x : α⦄ → a ≤ x → x ≤ b → p a → p b → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Ioo a b) = Finset.Ioo ↑a ↑b

theorem Finset.subtype_Ici_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderTop α] (a : Subtype p) : Finset.Ici a = Finset.subtype p (Finset.Ici ↑a)

theorem Finset.subtype_Ioi_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderTop α] (a : Subtype p) : Finset.Ioi a = Finset.subtype p (Finset.Ioi ↑a)

theorem Finset.map_subtype_embedding_Ici {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderTop α] (a : Subtype p) (hp : ⦃a x : α⦄ → a ≤ x → p a → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Ici a) = Finset.Ici ↑a

theorem Finset.map_subtype_embedding_Ioi {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderTop α] (a : Subtype p) (hp : ⦃a x : α⦄ → a ≤ x → p a → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Ioi a) = Finset.Ioi ↑a

theorem Finset.subtype_Iic_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderBot α] (a : Subtype p) : Finset.Iic a = Finset.subtype p (Finset.Iic ↑a)

theorem Finset.subtype_Iio_eq {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderBot α] (a : Subtype p) : Finset.Iio a = Finset.subtype p (Finset.Iio ↑a)

theorem Finset.map_subtype_embedding_Iic {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderBot α] (a : Subtype p) (hp : ⦃a x : α⦄ → x ≤ a → p a → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Iic a) = Finset.Iic ↑a

theorem Finset.map_subtype_embedding_Iio {α : Type u_1} [Preorder α] (p : α → Prop) [DecidablePred p] [LocallyFiniteOrderBot α] (a : Subtype p) (hp : ⦃a x : α⦄ → x ≤ a → p a → p x) : Finset.map (Function.Embedding.subtype p) (Finset.Iio a) = Finset.Iio ↑a

theorem Set.finite_iff_bddAbove {α : Type u_3} {s : Set α} [SemilatticeSup α] [LocallyFiniteOrder α] [OrderBot α] : Set.Finite s ↔ BddAbove s

theorem Set.finite_iff_bddBelow {α : Type u_3} {s : Set α} [SemilatticeInf α] [LocallyFiniteOrder α] [OrderTop α] : Set.Finite s ↔ BddBelow s

theorem Set.finite_iff_bddBelow_bddAbove {α : Type u_3} {s : Set α} [Nonempty α] [Lattice α] [LocallyFiniteOrder α] : Set.Finite s ↔ BddBelow s ∧ BddAbove s

We make the instances below low priority so when alternative constructions are available they are preferred.

instance instLocallyFiniteOrderTopSubtypeLeToLEPreorder {α : Type u_1} {y : α} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] [LocallyFiniteOrder α] : LocallyFiniteOrderTop { x // x ≤ y }

instance instLocallyFiniteOrderTopSubtypeLtToLTPreorder {α : Type u_1} {y : α} [Preorder α] [DecidableRel fun x x_1 => x < x_1] [LocallyFiniteOrder α] : LocallyFiniteOrderTop { x // x < y }

instance instLocallyFiniteOrderBotSubtypeLeToLEPreorder {α : Type u_1} {y : α} [Preorder α] [DecidableRel fun x x_1 => x ≤ x_1] [LocallyFiniteOrder α] : LocallyFiniteOrderBot { x // y ≤ x }

instance instLocallyFiniteOrderBotSubtypeLtToLTPreorder {α : Type u_1} {y : α} [Preorder α] [DecidableRel fun x x_1 => x < x_1] [LocallyFiniteOrder α] : LocallyFiniteOrderBot { x // y < x }

instance instFiniteSubtypeLeToLE {α : Type u_1} {y : α} [Preorder α] [LocallyFiniteOrderBot α] : Finite { x // x ≤ y }

instance instFiniteSubtypeLtToLT {α : Type u_1} {y : α} [Preorder α] [LocallyFiniteOrderBot α] : Finite { x // x < y }

instance instFiniteSubtypeLeToLE_1 {α : Type u_1} {y : α} [Preorder α] [LocallyFiniteOrderTop α] : Finite { x // y ≤ x }

instance instFiniteSubtypeLtToLT_1 {α : Type u_1} {y : α} [Preorder α] [LocallyFiniteOrderTop α] : Finite { x // y < x }

@[simp]

theorem Set.toFinset_Icc {α : Type u_3} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) [Fintype ↑(Set.Icc a b)] : Set.toFinset (Set.Icc a b) = Finset.Icc a b

@[simp]

theorem Set.toFinset_Ico {α : Type u_3} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) [Fintype ↑(Set.Ico a b)] : Set.toFinset (Set.Ico a b) = Finset.Ico a b

@[simp]

theorem Set.toFinset_Ioc {α : Type u_3} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) [Fintype ↑(Set.Ioc a b)] : Set.toFinset (Set.Ioc a b) = Finset.Ioc a b

@[simp]

theorem Set.toFinset_Ioo {α : Type u_3} [Preorder α] [LocallyFiniteOrder α] (a : α) (b : α) [Fintype ↑(Set.Ioo a b)] : Set.toFinset (Set.Ioo a b) = Finset.Ioo a b

@[simp]

theorem Set.toFinset_Ici {α : Type u_3} [Preorder α] [LocallyFiniteOrderTop α] (a : α) [Fintype ↑(Set.Ici a)] : Set.toFinset (Set.Ici a) = Finset.Ici a

@[simp]

theorem Set.toFinset_Ioi {α : Type u_3} [Preorder α] [LocallyFiniteOrderTop α] (a : α) [Fintype ↑(Set.Ioi a)] : Set.toFinset (Set.Ioi a) = Finset.Ioi a

@[simp]

theorem Set.toFinset_Iic {α : Type u_3} [Preorder α] [LocallyFiniteOrderBot α] (a : α) [Fintype ↑(Set.Iic a)] : Set.toFinset (Set.Iic a) = Finset.Iic a

@[simp]

theorem Set.toFinset_Iio {α : Type u_3} [Preorder α] [LocallyFiniteOrderBot α] (a : α) [Fintype ↑(Set.Iio a)] : Set.toFinset (Set.Iio a) = Finset.Iio a