File: Mathlib/Order/Interval/Finset/Defs.lean

full_name: LocallyFiniteOrder.finset_mem_Icc
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: x ∈ LocallyFiniteOrder.finsetIcc a b ↔ a ≤ x ∧ x ≤ b

full_name: LocallyFiniteOrder
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: Type u_1

full_name: LocallyFiniteOrder.finsetIcc
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: α → α → Finset α

full_name: LocallyFiniteOrder.finsetIoc
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: α → α → Finset α

full_name: LocallyFiniteOrder.finset_mem_Ioc
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: x ∈ LocallyFiniteOrder.finsetIoc a b ↔ a < x ∧ x ≤ b

full_name: LocallyFiniteOrder.finset_mem_Ioo
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: x ∈ LocallyFiniteOrder.finsetIoo a b ↔ a < x ∧ x < b

full_name: LocallyFiniteOrder.finsetIoo
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: α → α → Finset α

full_name: LocallyFiniteOrder.finsetIco
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: α → α → Finset α

full_name: LocallyFiniteOrder.finset_mem_Ico
code: /-- 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 LocallyFiniteOrder (α : Type*) [Preorder α] where
  /-- Left-closed right-closed interval -/
  finsetIcc : α → α → Finset α
  /-- Left-closed right-open interval -/
  finsetIco : α → α → Finset α
  /-- Left-open right-closed interval -/
  finsetIoc : α → α → Finset α
  /-- Left-open right-open interval -/
  finsetIoo : α → α → Finset α
  /-- `x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b` -/
  finset_mem_Icc : ∀ a b x : α, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b
  /-- `x ∈ finsetIco a b ↔ a ≤ x ∧ x < b` -/
  finset_mem_Ico : ∀ a b x : α, x ∈ finsetIco a b ↔ a ≤ x ∧ x < b
  /-- `x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b` -/
  finset_mem_Ioc : ∀ a b x : α, x ∈ finsetIoc a b ↔ a < x ∧ x ≤ b
  /-- `x ∈ finsetIoo a b ↔ a < x ∧ x < b` -/
  finset_mem_Ioo : ∀ a b x : α, x ∈ finsetIoo a b ↔ a < x ∧ x < b
goal: x ∈ LocallyFiniteOrder.finsetIco a b ↔ a ≤ x ∧ x < b

full_name: LocallyFiniteOrderTop.finsetIci
code: /-- 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 LocallyFiniteOrderTop (α : Type*) [Preorder α] where
  /-- Left-open right-infinite interval -/
  finsetIoi : α → Finset α
  /-- Left-closed right-infinite interval -/
  finsetIci : α → Finset α
  /-- `x ∈ finsetIci a ↔ a ≤ x` -/
  finset_mem_Ici : ∀ a x : α, x ∈ finsetIci a ↔ a ≤ x
  /-- `x ∈ finsetIoi a ↔ a < x` -/
  finset_mem_Ioi : ∀ a x : α, x ∈ finsetIoi a ↔ a < x
goal: α → Finset α

full_name: LocallyFiniteOrderTop.finset_mem_Ici
code: /-- 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 LocallyFiniteOrderTop (α : Type*) [Preorder α] where
  /-- Left-open right-infinite interval -/
  finsetIoi : α → Finset α
  /-- Left-closed right-infinite interval -/
  finsetIci : α → Finset α
  /-- `x ∈ finsetIci a ↔ a ≤ x` -/
  finset_mem_Ici : ∀ a x : α, x ∈ finsetIci a ↔ a ≤ x
  /-- `x ∈ finsetIoi a ↔ a < x` -/
  finset_mem_Ioi : ∀ a x : α, x ∈ finsetIoi a ↔ a < x
goal: x ∈ LocallyFiniteOrderTop.finsetIci a ↔ a ≤ x

full_name: LocallyFiniteOrderTop.finsetIoi
code: /-- 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 LocallyFiniteOrderTop (α : Type*) [Preorder α] where
  /-- Left-open right-infinite interval -/
  finsetIoi : α → Finset α
  /-- Left-closed right-infinite interval -/
  finsetIci : α → Finset α
  /-- `x ∈ finsetIci a ↔ a ≤ x` -/
  finset_mem_Ici : ∀ a x : α, x ∈ finsetIci a ↔ a ≤ x
  /-- `x ∈ finsetIoi a ↔ a < x` -/
  finset_mem_Ioi : ∀ a x : α, x ∈ finsetIoi a ↔ a < x
goal: α → Finset α

full_name: LocallyFiniteOrderTop.finset_mem_Ioi
code: /-- 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 LocallyFiniteOrderTop (α : Type*) [Preorder α] where
  /-- Left-open right-infinite interval -/
  finsetIoi : α → Finset α
  /-- Left-closed right-infinite interval -/
  finsetIci : α → Finset α
  /-- `x ∈ finsetIci a ↔ a ≤ x` -/
  finset_mem_Ici : ∀ a x : α, x ∈ finsetIci a ↔ a ≤ x
  /-- `x ∈ finsetIoi a ↔ a < x` -/
  finset_mem_Ioi : ∀ a x : α, x ∈ finsetIoi a ↔ a < x
goal: x ∈ LocallyFiniteOrderTop.finsetIoi a ↔ a < x

full_name: LocallyFiniteOrderTop
code: /-- 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 LocallyFiniteOrderTop (α : Type*) [Preorder α] where
  /-- Left-open right-infinite interval -/
  finsetIoi : α → Finset α
  /-- Left-closed right-infinite interval -/
  finsetIci : α → Finset α
  /-- `x ∈ finsetIci a ↔ a ≤ x` -/
  finset_mem_Ici : ∀ a x : α, x ∈ finsetIci a ↔ a ≤ x
  /-- `x ∈ finsetIoi a ↔ a < x` -/
  finset_mem_Ioi : ∀ a x : α, x ∈ finsetIoi a ↔ a < x
goal: Type u_1

full_name: LocallyFiniteOrderBot.finsetIic
code: /-- 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. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
goal: α → Finset α

full_name: LocallyFiniteOrderBot.finsetIio
code: /-- 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. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
goal: α → Finset α

full_name: LocallyFiniteOrderBot.finset_mem_Iio
code: /-- 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. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
goal: x ∈ LocallyFiniteOrderBot.finsetIio a ↔ x < a

full_name: LocallyFiniteOrderBot.finset_mem_Iic
code: /-- 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. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
goal: x ∈ LocallyFiniteOrderBot.finsetIic a ↔ x ≤ a

full_name: LocallyFiniteOrderBot
code: /-- 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. -/
class LocallyFiniteOrderBot (α : Type*) [Preorder α] where
  /-- Left-infinite right-open interval -/
  finsetIio : α → Finset α
  /-- Left-infinite right-closed interval -/
  finsetIic : α → Finset α
  /-- `x ∈ finsetIic a ↔ x ≤ a` -/
  finset_mem_Iic : ∀ a x : α, x ∈ finsetIic a ↔ x ≤ a
  /-- `x ∈ finsetIio a ↔ x < a` -/
  finset_mem_Iio : ∀ a x : α, x ∈ finsetIio a ↔ x < a
goal: Type u_1

full_name: LocallyFiniteOrder.ofIcc'
code: /-- 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*) [Preorder α] [DecidableRel ((· ≤ ·) : α → α → Prop)]
    (finsetIcc : α → α → Finset α) (mem_Icc : ∀ a b x, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b) :
    LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: LocallyFiniteOrder.ofIcc
code: /-- 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 LocallyFiniteOrder.ofIcc (α : Type*) [PartialOrder α] [DecidableEq α]
    (finsetIcc : α → α → Finset α) (mem_Icc : ∀ a b x, x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b) :
    LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: LocallyFiniteOrderTop.ofIci'
code: /-- A constructor from a definition of `Finset.Ici` 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*) [Preorder α] [DecidableRel ((· ≤ ·) : α → α → Prop)]
    (finsetIci : α → Finset α) (mem_Ici : ∀ a x, x ∈ finsetIci a ↔ a ≤ x) :
    LocallyFiniteOrderTop α 
goal: LocallyFiniteOrderTop α

full_name: LocallyFiniteOrderTop.ofIci
code: /-- A constructor from a definition of `Finset.Ici` alone, the other ones being derived by removing
the ends. As opposed to `LocallyFiniteOrderTop.ofIci'`, this one requires `PartialOrder` but
only `DecidableEq`. -/
def LocallyFiniteOrderTop.ofIci (α : Type*) [PartialOrder α] [DecidableEq α]
    (finsetIci : α → Finset α) (mem_Ici : ∀ a x, x ∈ finsetIci a ↔ a ≤ x) :
    LocallyFiniteOrderTop α 
goal: LocallyFiniteOrderTop α

full_name: LocallyFiniteOrderBot.ofIic'
code: /-- A constructor from a definition of `Finset.Iic` alone, the other ones being derived by removing
the ends. As opposed to `LocallyFiniteOrderBot.ofIic`, this one requires `DecidableRel (· ≤ ·)` but
only `Preorder`. -/
def LocallyFiniteOrderBot.ofIic' (α : Type*) [Preorder α] [DecidableRel ((· ≤ ·) : α → α → Prop)]
    (finsetIic : α → Finset α) (mem_Iic : ∀ a x, x ∈ finsetIic a ↔ x ≤ a) :
    LocallyFiniteOrderBot α 
goal: LocallyFiniteOrderBot α

full_name: LocallyFiniteOrderBot.ofIic
code: /-- A constructor from a definition of `Finset.Iic` alone, the other ones being derived by removing
the ends. As opposed to `LocallyFiniteOrderBot.ofIic'`, this one requires `PartialOrder` but
only `DecidableEq`. -/
def LocallyFiniteOrderBot.ofIic (α : Type*) [PartialOrder α] [DecidableEq α]
    (finsetIic : α → Finset α) (mem_Iic : ∀ a x, x ∈ finsetIic a ↔ x ≤ a) :
    LocallyFiniteOrderBot α 
goal: LocallyFiniteOrderBot α

full_name: IsEmpty.toLocallyFiniteOrder
code: /-- An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances. -/
protected abbrev IsEmpty.toLocallyFiniteOrder [Preorder α] [IsEmpty α] : LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: IsEmpty.toLocallyFiniteOrderTop
code: /-- An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances. -/
protected abbrev IsEmpty.toLocallyFiniteOrderTop [Preorder α] [IsEmpty α] :
    LocallyFiniteOrderTop α 
goal: LocallyFiniteOrderTop α

full_name: IsEmpty.toLocallyFiniteOrderBot
code: /-- An empty type is locally finite.

This is not an instance as it would not be defeq to more specific instances. -/
protected abbrev IsEmpty.toLocallyFiniteOrderBot [Preorder α] [IsEmpty α] :
    LocallyFiniteOrderBot α 
goal: LocallyFiniteOrderBot α

full_name: Finset.Icc
code: /-- The finset of elements `x` such that `a ≤ x` and `x ≤ b`. Basically `Set.Icc a b` as a finset.
-/
def Icc (a b : α) : Finset α 
goal: Finset α

full_name: Finset.Ico
code: /-- The finset of elements `x` such that `a ≤ x` and `x < b`. Basically `Set.Ico a b` as a finset.
-/
def Ico (a b : α) : Finset α 
goal: Finset α

full_name: Finset.Ioc
code: /-- The finset of elements `x` such that `a < x` and `x ≤ b`. Basically `Set.Ioc a b` as a finset.
-/
def Ioc (a b : α) : Finset α 
goal: Finset α

full_name: Finset.Ioo
code: /-- The finset of elements `x` such that `a < x` and `x < b`. Basically `Set.Ioo a b` as a finset.
-/
def Ioo (a b : α) : Finset α 
goal: Finset α

full_name: Finset.mem_Icc
code: @[simp]
theorem mem_Icc : x ∈ Icc a b ↔ a ≤ x ∧ x ≤ b 
goal: x ∈ Finset.Icc a b ↔ a ≤ x ∧ x ≤ b

full_name: Finset.mem_Ico
code: @[simp]
theorem mem_Ico : x ∈ Ico a b ↔ a ≤ x ∧ x < b 
goal: x ∈ Finset.Ico a b ↔ a ≤ x ∧ x < b

full_name: Finset.mem_Ioc
code: @[simp]
theorem mem_Ioc : x ∈ Ioc a b ↔ a < x ∧ x ≤ b 
goal: x ∈ Finset.Ioc a b ↔ a < x ∧ x ≤ b

full_name: Finset.mem_Ioo
code: @[simp]
theorem mem_Ioo : x ∈ Ioo a b ↔ a < x ∧ x < b 
goal: x ∈ Finset.Ioo a b ↔ a < x ∧ x < b

full_name: Finset.coe_Icc
code: @[simp, norm_cast]
theorem coe_Icc (a b : α) : (Icc a b : Set α) = Set.Icc a b 
goal: ↑(Finset.Icc a b) = Set.Icc a b

full_name: Finset.coe_Ico
code: @[simp, norm_cast]
theorem coe_Ico (a b : α) : (Ico a b : Set α) = Set.Ico a b 
goal: ↑(Finset.Ico a b) = Set.Ico a b

full_name: Finset.coe_Ioc
code: @[simp, norm_cast]
theorem coe_Ioc (a b : α) : (Ioc a b : Set α) = Set.Ioc a b 
goal: ↑(Finset.Ioc a b) = Set.Ioc a b

full_name: Finset.coe_Ioo
code: @[simp, norm_cast]
theorem coe_Ioo (a b : α) : (Ioo a b : Set α) = Set.Ioo a b 
goal: ↑(Finset.Ioo a b) = Set.Ioo a b

full_name: Finset.Ici
code: /-- The finset of elements `x` such that `a ≤ x`. Basically `Set.Ici a` as a finset. -/
def Ici (a : α) : Finset α 
goal: Finset α

full_name: Finset.Ioi
code: /-- The finset of elements `x` such that `a < x`. Basically `Set.Ioi a` as a finset. -/
def Ioi (a : α) : Finset α 
goal: Finset α

full_name: Finset.mem_Ici
code: @[simp]
theorem mem_Ici : x ∈ Ici a ↔ a ≤ x 
goal: x ∈ Finset.Ici a ↔ a ≤ x

full_name: Finset.mem_Ioi
code: @[simp]
theorem mem_Ioi : x ∈ Ioi a ↔ a < x 
goal: x ∈ Finset.Ioi a ↔ a < x

full_name: Finset.coe_Ici
code: @[simp, norm_cast]
theorem coe_Ici (a : α) : (Ici a : Set α) = Set.Ici a 
goal: ↑(Finset.Ici a) = Set.Ici a

full_name: Finset.coe_Ioi
code: @[simp, norm_cast]
theorem coe_Ioi (a : α) : (Ioi a : Set α) = Set.Ioi a 
goal: ↑(Finset.Ioi a) = Set.Ioi a

full_name: Finset.Iic
code: /-- The finset of elements `x` such that `a ≤ x`. Basically `Set.Iic a` as a finset. -/
def Iic (a : α) : Finset α 
goal: Finset α

full_name: Finset.Iio
code: /-- The finset of elements `x` such that `a < x`. Basically `Set.Iio a` as a finset. -/
def Iio (a : α) : Finset α 
goal: Finset α

full_name: Finset.mem_Iic
code: @[simp]
theorem mem_Iic : x ∈ Iic a ↔ x ≤ a 
goal: x ∈ Finset.Iic a ↔ x ≤ a

full_name: Finset.mem_Iio
code: @[simp]
theorem mem_Iio : x ∈ Iio a ↔ x < a 
goal: x ∈ Finset.Iio a ↔ x < a

full_name: Finset.coe_Iic
code: @[simp, norm_cast]
theorem coe_Iic (a : α) : (Iic a : Set α) = Set.Iic a 
goal: ↑(Finset.Iic a) = Set.Iic a

full_name: Finset.coe_Iio
code: @[simp, norm_cast]
theorem coe_Iio (a : α) : (Iio a : Set α) = Set.Iio a 
goal: ↑(Finset.Iio a) = Set.Iio a

full_name: LocallyFiniteOrder.toLocallyFiniteOrderTop
code: instance (priority := 100) _root_.LocallyFiniteOrder.toLocallyFiniteOrderTop :
    LocallyFiniteOrderTop α 
goal: LocallyFiniteOrderTop α

full_name: Finset.Ici_eq_Icc
code: theorem Ici_eq_Icc (a : α) : Ici a = Icc a ⊤ 
goal: Finset.Ici a = Finset.Icc a ⊤

full_name: Finset.Ioi_eq_Ioc
code: theorem Ioi_eq_Ioc (a : α) : Ioi a = Ioc a ⊤ 
goal: Finset.Ioi a = Finset.Ioc a ⊤

full_name: Finset.LocallyFiniteOrder.toLocallyFiniteOrderBot
code: instance (priority := 100) LocallyFiniteOrder.toLocallyFiniteOrderBot :
    LocallyFiniteOrderBot α 
goal: LocallyFiniteOrderBot α

full_name: Finset.Iic_eq_Icc
code: theorem Iic_eq_Icc : Iic = Icc (⊥ : α) 
goal: Finset.Iic = Finset.Icc ⊥

full_name: Finset.Iio_eq_Ico
code: theorem Iio_eq_Ico : Iio = Ico (⊥ : α) 
goal: Finset.Iio = Finset.Ico ⊥

full_name: Finset.uIcc
code: /-- `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 uIcc (a b : α) : Finset α 
goal: Finset α

full_name: FinsetInterval.«_aux_Mathlib_Order_Interval_Finset_Defs___macroRules_FinsetInterval_term[[_,_]]_1»
code: @[inherit_doc]
scoped[FinsetInterval] notation "[[" a ", " b "]]" => Finset.uIcc a b
goal: Lean.Macro

full_name: FinsetInterval._aux_Mathlib_Order_Interval_Finset_Defs___unexpand_Finset_uIcc_1
code: @[inherit_doc]
scoped[FinsetInterval] notation "[[" a ", " b "]]" => Finset.uIcc a b
goal: Lean.PrettyPrinter.Unexpander

full_name: Finset.mem_uIcc
code: @[simp]
theorem mem_uIcc : x ∈ uIcc a b ↔ a ⊓ b ≤ x ∧ x ≤ a ⊔ b 
goal: x ∈ Finset.uIcc a b ↔ a ⊓ b ≤ x ∧ x ≤ a ⊔ b

full_name: Finset.coe_uIcc
code: @[simp, norm_cast]
theorem coe_uIcc (a b : α) : (Finset.uIcc a b : Set α) = Set.uIcc a b 
goal: ↑(Finset.uIcc a b) = Set.uIcc a b

full_name: Set.fintypeIcc
code: instance fintypeIcc : Fintype (Icc a b) 
goal: Fintype ↑(Set.Icc a b)

full_name: Set.fintypeIco
code: instance fintypeIco : Fintype (Ico a b) 
goal: Fintype ↑(Set.Ico a b)

full_name: Set.fintypeIoc
code: instance fintypeIoc : Fintype (Ioc a b) 
goal: Fintype ↑(Set.Ioc a b)

full_name: Set.fintypeIoo
code: instance fintypeIoo : Fintype (Ioo a b) 
goal: Fintype ↑(Set.Ioo a b)

full_name: Set.finite_Icc
code: theorem finite_Icc : (Icc a b).Finite 
goal: (Set.Icc a b).Finite

full_name: Set.finite_Ico
code: theorem finite_Ico : (Ico a b).Finite 
goal: (Set.Ico a b).Finite

full_name: Set.finite_Ioc
code: theorem finite_Ioc : (Ioc a b).Finite 
goal: (Set.Ioc a b).Finite

full_name: Set.finite_Ioo
code: theorem finite_Ioo : (Ioo a b).Finite 
goal: (Set.Ioo a b).Finite

full_name: Set.fintypeIci
code: instance fintypeIci : Fintype (Ici a) 
goal: Fintype ↑(Set.Ici a)

full_name: Set.fintypeIoi
code: instance fintypeIoi : Fintype (Ioi a) 
goal: Fintype ↑(Set.Ioi a)

full_name: Set.finite_Ici
code: theorem finite_Ici : (Ici a).Finite 
goal: (Set.Ici a).Finite

full_name: Set.finite_Ioi
code: theorem finite_Ioi : (Ioi a).Finite 
goal: (Set.Ioi a).Finite

full_name: Set.fintypeIic
code: instance fintypeIic : Fintype (Iic b) 
goal: Fintype ↑(Set.Iic b)

full_name: Set.fintypeIio
code: instance fintypeIio : Fintype (Iio b) 
goal: Fintype ↑(Set.Iio b)

full_name: Set.finite_Iic
code: theorem finite_Iic : (Iic b).Finite 
goal: (Set.Iic b).Finite

full_name: Set.finite_Iio
code: theorem finite_Iio : (Iio b).Finite 
goal: (Set.Iio b).Finite

full_name: Set.fintypeUIcc
code: instance fintypeUIcc : Fintype (uIcc a b) 
goal: Fintype ↑(Set.uIcc a b)

full_name: Set.finite_interval
code: @[simp]
theorem finite_interval : (uIcc a b).Finite 
goal: (Set.uIcc a b).Finite

full_name: LocallyFiniteOrder.ofFiniteIcc
code: /-- A noncomputable constructor from the finiteness of all closed intervals. -/
noncomputable def LocallyFiniteOrder.ofFiniteIcc (h : ∀ a b : α, (Set.Icc a b).Finite) :
    LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: Fintype.toLocallyFiniteOrder
code: /-- 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`.
-/
abbrev Fintype.toLocallyFiniteOrder [Fintype α] [@DecidableRel α (· < ·)]
    [@DecidableRel α (· ≤ ·)] : LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: instSubsingletonLocallyFiniteOrder
code: instance : Subsingleton (LocallyFiniteOrder α) 
goal: Subsingleton (LocallyFiniteOrder α)

full_name: instSubsingletonLocallyFiniteOrderTop
code: instance : Subsingleton (LocallyFiniteOrderTop α) 
goal: Subsingleton (LocallyFiniteOrderTop α)

full_name: instSubsingletonLocallyFiniteOrderBot
code: instance : Subsingleton (LocallyFiniteOrderBot α) 
goal: Subsingleton (LocallyFiniteOrderBot α)

full_name: OrderEmbedding.locallyFiniteOrder
code: /-- Given an order embedding `α ↪o β`, pulls back the `LocallyFiniteOrder` on `β` to `α`. -/
protected noncomputable def OrderEmbedding.locallyFiniteOrder [LocallyFiniteOrder β] (f : α ↪o β) :
    LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: OrderDual.instLocallyFiniteOrder
code: /-- 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
```
-/
instance OrderDual.instLocallyFiniteOrder : LocallyFiniteOrder αᵒᵈ 
goal: LocallyFiniteOrder αᵒᵈ

full_name: Icc_toDual
code: theorem Icc_toDual : Icc (toDual a) (toDual b) = (Icc b a).map toDual.toEmbedding 
goal: Finset.Icc (OrderDual.toDual a) (OrderDual.toDual b) = Finset.map OrderDual.toDual.toEmbedding (Finset.Icc b a)

full_name: Ico_toDual
code: theorem Ico_toDual : Ico (toDual a) (toDual b) = (Ioc b a).map toDual.toEmbedding 
goal: Finset.Ico (OrderDual.toDual a) (OrderDual.toDual b) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ioc b a)

full_name: Ioc_toDual
code: theorem Ioc_toDual : Ioc (toDual a) (toDual b) = (Ico b a).map toDual.toEmbedding 
goal: Finset.Ioc (OrderDual.toDual a) (OrderDual.toDual b) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ico b a)

full_name: Ioo_toDual
code: theorem Ioo_toDual : Ioo (toDual a) (toDual b) = (Ioo b a).map toDual.toEmbedding 
goal: Finset.Ioo (OrderDual.toDual a) (OrderDual.toDual b) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ioo b a)

full_name: Icc_ofDual
code: theorem Icc_ofDual (a b : αᵒᵈ) : Icc (ofDual a) (ofDual b) = (Icc b a).map ofDual.toEmbedding 
goal: Finset.Icc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Icc b a)

full_name: Ico_ofDual
code: theorem Ico_ofDual (a b : αᵒᵈ) : Ico (ofDual a) (ofDual b) = (Ioc b a).map ofDual.toEmbedding 
goal: Finset.Ico (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Ioc b a)

full_name: Ioc_ofDual
code: theorem Ioc_ofDual (a b : αᵒᵈ) : Ioc (ofDual a) (ofDual b) = (Ico b a).map ofDual.toEmbedding 
goal: Finset.Ioc (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Ico b a)

full_name: Ioo_ofDual
code: theorem Ioo_ofDual (a b : αᵒᵈ) : Ioo (ofDual a) (ofDual b) = (Ioo b a).map ofDual.toEmbedding 
goal: Finset.Ioo (OrderDual.ofDual a) (OrderDual.ofDual b) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Ioo b a)

full_name: OrderDual.instLocallyFiniteOrderBot
code: /-- 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
```
-/
instance OrderDual.instLocallyFiniteOrderBot : LocallyFiniteOrderBot αᵒᵈ 
goal: LocallyFiniteOrderBot αᵒᵈ

full_name: Iic_toDual
code: theorem Iic_toDual (a : α) : Iic (toDual a) = (Ici a).map toDual.toEmbedding 
goal: Finset.Iic (OrderDual.toDual a) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ici a)

full_name: Iio_toDual
code: theorem Iio_toDual (a : α) : Iio (toDual a) = (Ioi a).map toDual.toEmbedding 
goal: Finset.Iio (OrderDual.toDual a) = Finset.map OrderDual.toDual.toEmbedding (Finset.Ioi a)

full_name: Ici_ofDual
code: theorem Ici_ofDual (a : αᵒᵈ) : Ici (ofDual a) = (Iic a).map ofDual.toEmbedding 
goal: Finset.Ici (OrderDual.ofDual a) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Iic a)

full_name: Ioi_ofDual
code: theorem Ioi_ofDual (a : αᵒᵈ) : Ioi (ofDual a) = (Iio a).map ofDual.toEmbedding 
goal: Finset.Ioi (OrderDual.ofDual a) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Iio a)

full_name: OrderDual.instLocallyFiniteOrderTop
code: /-- 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
```
-/
instance OrderDual.instLocallyFiniteOrderTop : LocallyFiniteOrderTop αᵒᵈ 
goal: LocallyFiniteOrderTop αᵒᵈ

full_name: Ici_toDual
code: theorem Ici_toDual (a : α) : Ici (toDual a) = (Iic a).map toDual.toEmbedding 
goal: Finset.Ici (OrderDual.toDual a) = Finset.map OrderDual.toDual.toEmbedding (Finset.Iic a)

full_name: Ioi_toDual
code: theorem Ioi_toDual (a : α) : Ioi (toDual a) = (Iio a).map toDual.toEmbedding 
goal: Finset.Ioi (OrderDual.toDual a) = Finset.map OrderDual.toDual.toEmbedding (Finset.Iio a)

full_name: Iic_ofDual
code: theorem Iic_ofDual (a : αᵒᵈ) : Iic (ofDual a) = (Ici a).map ofDual.toEmbedding 
goal: Finset.Iic (OrderDual.ofDual a) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Ici a)

full_name: Iio_ofDual
code: theorem Iio_ofDual (a : αᵒᵈ) : Iio (ofDual a) = (Ioi a).map ofDual.toEmbedding 
goal: Finset.Iio (OrderDual.ofDual a) = Finset.map OrderDual.ofDual.toEmbedding (Finset.Ioi a)

full_name: Prod.instLocallyFiniteOrderOfDecidableRelLe
code: instance [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] : LocallyFiniteOrder (α × β) 
goal: LocallyFiniteOrder (α × β)

full_name: Prod.instLocallyFiniteOrderTopOfDecidableRelLe
code: instance [LocallyFiniteOrderTop α] [LocallyFiniteOrderTop β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] : LocallyFiniteOrderTop (α × β) 
goal: LocallyFiniteOrderTop (α × β)

full_name: Prod.instLocallyFiniteOrderBotOfDecidableRelLe
code: instance [LocallyFiniteOrderBot α] [LocallyFiniteOrderBot β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] : LocallyFiniteOrderBot (α × β) 
goal: LocallyFiniteOrderBot (α × β)

full_name: Prod.Icc_eq
code: theorem Icc_eq [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    Finset.Icc p q = Finset.Icc p.1 q.1 ×ˢ Finset.Icc p.2 q.2 
goal: Finset.Icc p q = Finset.Icc p.1 q.1 ×ˢ Finset.Icc p.2 q.2

full_name: Prod.Icc_mk_mk
code: @[simp]
theorem Icc_mk_mk [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (a₁ a₂ : α) (b₁ b₂ : β) :
    Finset.Icc (a₁, b₁) (a₂, b₂) = Finset.Icc a₁ a₂ ×ˢ Finset.Icc b₁ b₂ 
goal: Finset.Icc (a₁, b₁) (a₂, b₂) = Finset.Icc a₁ a₂ ×ˢ Finset.Icc b₁ b₂

full_name: Prod.card_Icc
code: theorem card_Icc [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    (Finset.Icc p q).card = (Finset.Icc p.1 q.1).card * (Finset.Icc p.2 q.2).card 
goal: (Finset.Icc p q).card = (Finset.Icc p.1 q.1).card * (Finset.Icc p.2 q.2).card

full_name: Prod.uIcc_eq
code: theorem uIcc_eq [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    Finset.uIcc p q = Finset.uIcc p.1 q.1 ×ˢ Finset.uIcc p.2 q.2 
goal: Finset.uIcc p q = Finset.uIcc p.1 q.1 ×ˢ Finset.uIcc p.2 q.2

full_name: Prod.uIcc_mk_mk
code: @[simp]
theorem uIcc_mk_mk [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (a₁ a₂ : α) (b₁ b₂ : β) :
    Finset.uIcc (a₁, b₁) (a₂, b₂) = Finset.uIcc a₁ a₂ ×ˢ Finset.uIcc b₁ b₂ 
goal: Finset.uIcc (a₁, b₁) (a₂, b₂) = Finset.uIcc a₁ a₂ ×ˢ Finset.uIcc b₁ b₂

full_name: Prod.card_uIcc
code: theorem card_uIcc [LocallyFiniteOrder α] [LocallyFiniteOrder β]
    [DecidableRel ((· ≤ ·) : α × β → α × β → Prop)] (p q : α × β) :
    (Finset.uIcc p q).card = (Finset.uIcc p.1 q.1).card * (Finset.uIcc p.2 q.2).card 
goal: (Finset.uIcc p q).card = (Finset.uIcc p.1 q.1).card * (Finset.uIcc p.2 q.2).card

full_name: _private.Mathlib.Order.Interval.Finset.Defs.0.WithTop.aux
code: private lemma aux (x : α) (p : α → Prop) :
    (∃ a : α, p a ∧ WithTop.some a = WithTop.some x) ↔ p x 
goal: (∃ a, p a ∧ ↑a = ↑x) ↔ p x

full_name: WithTop.locallyFiniteOrder
code: instance locallyFiniteOrder : LocallyFiniteOrder (WithTop α) 
goal: LocallyFiniteOrder (WithTop α)

full_name: WithTop.Icc_coe_top
code: theorem Icc_coe_top : Icc (a : WithTop α) ⊤ = insertNone (Ici a) 
goal: Finset.Icc ↑a ⊤ = Finset.insertNone (Finset.Ici a)

full_name: WithTop.Icc_coe_coe
code: theorem Icc_coe_coe : Icc (a : WithTop α) b = (Icc a b).map Embedding.some 
goal: Finset.Icc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Icc a b)

full_name: WithTop.Ico_coe_top
code: theorem Ico_coe_top : Ico (a : WithTop α) ⊤ = (Ici a).map Embedding.some 
goal: Finset.Ico ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ici a)

full_name: WithTop.Ico_coe_coe
code: theorem Ico_coe_coe : Ico (a : WithTop α) b = (Ico a b).map Embedding.some 
goal: Finset.Ico ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ico a b)

full_name: WithTop.Ioc_coe_top
code: theorem Ioc_coe_top : Ioc (a : WithTop α) ⊤ = insertNone (Ioi a) 
goal: Finset.Ioc ↑a ⊤ = Finset.insertNone (Finset.Ioi a)

full_name: WithTop.Ioc_coe_coe
code: theorem Ioc_coe_coe : Ioc (a : WithTop α) b = (Ioc a b).map Embedding.some 
goal: Finset.Ioc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioc a b)

full_name: WithTop.Ioo_coe_top
code: theorem Ioo_coe_top : Ioo (a : WithTop α) ⊤ = (Ioi a).map Embedding.some 
goal: Finset.Ioo ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ioi a)

full_name: WithTop.Ioo_coe_coe
code: theorem Ioo_coe_coe : Ioo (a : WithTop α) b = (Ioo a b).map Embedding.some 
goal: Finset.Ioo ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioo a b)

full_name: WithBot.instLocallyFiniteOrder
code: instance instLocallyFiniteOrder : LocallyFiniteOrder (WithBot α) 
goal: LocallyFiniteOrder (WithBot α)

full_name: WithBot.Icc_bot_coe
code: theorem Icc_bot_coe : Icc (⊥ : WithBot α) b = insertNone (Iic b) 
goal: Finset.Icc ⊥ ↑b = Finset.insertNone (Finset.Iic b)

full_name: WithBot.Icc_coe_coe
code: theorem Icc_coe_coe : Icc (a : WithBot α) b = (Icc a b).map Embedding.some 
goal: Finset.Icc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Icc a b)

full_name: WithBot.Ico_bot_coe
code: theorem Ico_bot_coe : Ico (⊥ : WithBot α) b = insertNone (Iio b) 
goal: Finset.Ico ⊥ ↑b = Finset.insertNone (Finset.Iio b)

full_name: WithBot.Ico_coe_coe
code: theorem Ico_coe_coe : Ico (a : WithBot α) b = (Ico a b).map Embedding.some 
goal: Finset.Ico ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ico a b)

full_name: WithBot.Ioc_bot_coe
code: theorem Ioc_bot_coe : Ioc (⊥ : WithBot α) b = (Iic b).map Embedding.some 
goal: Finset.Ioc ⊥ ↑b = Finset.map Function.Embedding.some (Finset.Iic b)

full_name: WithBot.Ioc_coe_coe
code: theorem Ioc_coe_coe : Ioc (a : WithBot α) b = (Ioc a b).map Embedding.some 
goal: Finset.Ioc ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioc a b)

full_name: WithBot.Ioo_bot_coe
code: theorem Ioo_bot_coe : Ioo (⊥ : WithBot α) b = (Iio b).map Embedding.some 
goal: Finset.Ioo ⊥ ↑b = Finset.map Function.Embedding.some (Finset.Iio b)

full_name: WithBot.Ioo_coe_coe
code: theorem Ioo_coe_coe : Ioo (a : WithBot α) b = (Ioo a b).map Embedding.some 
goal: Finset.Ioo ↑a ↑b = Finset.map Function.Embedding.some (Finset.Ioo a b)

full_name: OrderIso.locallyFiniteOrder
code: /-- Transfer `LocallyFiniteOrder` across an `OrderIso`. -/
abbrev locallyFiniteOrder [LocallyFiniteOrder β] (f : α ≃o β) : LocallyFiniteOrder α 
goal: LocallyFiniteOrder α

full_name: OrderIso.locallyFiniteOrderTop
code: /-- Transfer `LocallyFiniteOrderTop` across an `OrderIso`. -/
abbrev locallyFiniteOrderTop [LocallyFiniteOrderTop β] (f : α ≃o β) : LocallyFiniteOrderTop α 
goal: LocallyFiniteOrderTop α

full_name: OrderIso.locallyFiniteOrderBot
code: /-- Transfer `LocallyFiniteOrderBot` across an `OrderIso`. -/
abbrev locallyFiniteOrderBot [LocallyFiniteOrderBot β] (f : α ≃o β) : LocallyFiniteOrderBot α 
goal: LocallyFiniteOrderBot α

full_name: Subtype.instLocallyFiniteOrder
code: instance Subtype.instLocallyFiniteOrder [LocallyFiniteOrder α] :
    LocallyFiniteOrder (Subtype p) 
goal: LocallyFiniteOrder (Subtype p)

full_name: Subtype.instLocallyFiniteOrderTop
code: instance Subtype.instLocallyFiniteOrderTop [LocallyFiniteOrderTop α] :
    LocallyFiniteOrderTop (Subtype p) 
goal: LocallyFiniteOrderTop (Subtype p)

full_name: Subtype.instLocallyFiniteOrderBot
code: instance Subtype.instLocallyFiniteOrderBot [LocallyFiniteOrderBot α] :
    LocallyFiniteOrderBot (Subtype p) 
goal: LocallyFiniteOrderBot (Subtype p)

full_name: Finset.subtype_Icc_eq
code: theorem subtype_Icc_eq : Icc a b = (Icc (a : α) b).subtype p 
goal: Finset.Icc a b = Finset.subtype p (Finset.Icc ↑a ↑b)

full_name: Finset.subtype_Ico_eq
code: theorem subtype_Ico_eq : Ico a b = (Ico (a : α) b).subtype p 
goal: Finset.Ico a b = Finset.subtype p (Finset.Ico ↑a ↑b)

full_name: Finset.subtype_Ioc_eq
code: theorem subtype_Ioc_eq : Ioc a b = (Ioc (a : α) b).subtype p 
goal: Finset.Ioc a b = Finset.subtype p (Finset.Ioc ↑a ↑b)

full_name: Finset.subtype_Ioo_eq
code: theorem subtype_Ioo_eq : Ioo a b = (Ioo (a : α) b).subtype p 
goal: Finset.Ioo a b = Finset.subtype p (Finset.Ioo ↑a ↑b)

full_name: Finset.map_subtype_embedding_Icc
code: theorem map_subtype_embedding_Icc (hp : ∀ ⦃a b x⦄, a ≤ x → x ≤ b → p a → p b → p x):
    (Icc a b).map (Embedding.subtype p) = (Icc a b : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Icc a b) = Finset.Icc ↑a ↑b

full_name: Finset.map_subtype_embedding_Ico
code: theorem map_subtype_embedding_Ico (hp : ∀ ⦃a b x⦄, a ≤ x → x ≤ b → p a → p b → p x):
    (Ico a b).map (Embedding.subtype p) = (Ico a b : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Ico a b) = Finset.Ico ↑a ↑b

full_name: Finset.map_subtype_embedding_Ioc
code: theorem map_subtype_embedding_Ioc (hp : ∀ ⦃a b x⦄, a ≤ x → x ≤ b → p a → p b → p x):
    (Ioc a b).map (Embedding.subtype p) = (Ioc a b : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Ioc a b) = Finset.Ioc ↑a ↑b

full_name: Finset.map_subtype_embedding_Ioo
code: theorem map_subtype_embedding_Ioo (hp : ∀ ⦃a b x⦄, a ≤ x → x ≤ b → p a → p b → p x):
    (Ioo a b).map (Embedding.subtype p) = (Ioo a b : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Ioo a b) = Finset.Ioo ↑a ↑b

full_name: Finset.subtype_Ici_eq
code: theorem subtype_Ici_eq : Ici a = (Ici (a : α)).subtype p 
goal: Finset.Ici a = Finset.subtype p (Finset.Ici ↑a)

full_name: Finset.subtype_Ioi_eq
code: theorem subtype_Ioi_eq : Ioi a = (Ioi (a : α)).subtype p 
goal: Finset.Ioi a = Finset.subtype p (Finset.Ioi ↑a)

full_name: Finset.map_subtype_embedding_Ici
code: theorem map_subtype_embedding_Ici : (Ici a).map (Embedding.subtype p) = (Ici a : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Ici a) = Finset.Ici ↑a

full_name: Finset.map_subtype_embedding_Ioi
code: theorem map_subtype_embedding_Ioi : (Ioi a).map (Embedding.subtype p) = (Ioi a : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Ioi a) = Finset.Ioi ↑a

full_name: Finset.subtype_Iic_eq
code: theorem subtype_Iic_eq : Iic a = (Iic (a : α)).subtype p 
goal: Finset.Iic a = Finset.subtype p (Finset.Iic ↑a)

full_name: Finset.subtype_Iio_eq
code: theorem subtype_Iio_eq : Iio a = (Iio (a : α)).subtype p 
goal: Finset.Iio a = Finset.subtype p (Finset.Iio ↑a)

full_name: Finset.map_subtype_embedding_Iic
code: theorem map_subtype_embedding_Iic : (Iic a).map (Embedding.subtype p) = (Iic a : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Iic a) = Finset.Iic ↑a

full_name: Finset.map_subtype_embedding_Iio
code: theorem map_subtype_embedding_Iio : (Iio a).map (Embedding.subtype p) = (Iio a : Finset α) 
goal: Finset.map (Function.Embedding.subtype p) (Finset.Iio a) = Finset.Iio ↑a

full_name: BddBelow.finite_of_bddAbove
code: theorem BddBelow.finite_of_bddAbove [Preorder α] [LocallyFiniteOrder α]
    {s : Set α} (h₀ : BddBelow s) (h₁ : BddAbove s) :
    s.Finite 
goal: s.Finite

full_name: Set.finite_iff_bddAbove
code: theorem Set.finite_iff_bddAbove [SemilatticeSup α] [LocallyFiniteOrder α] [OrderBot α] :
    s.Finite ↔ BddAbove s 
goal: s.Finite ↔ BddAbove s

full_name: Set.finite_iff_bddBelow
code: theorem Set.finite_iff_bddBelow [SemilatticeInf α] [LocallyFiniteOrder α] [OrderTop α] :
    s.Finite ↔ BddBelow s 
goal: s.Finite ↔ BddBelow s

full_name: Set.finite_iff_bddBelow_bddAbove
code: theorem Set.finite_iff_bddBelow_bddAbove [Nonempty α] [Lattice α] [LocallyFiniteOrder α] :
    s.Finite ↔ BddBelow s ∧ BddAbove s 
goal: s.Finite ↔ BddBelow s ∧ BddAbove s

full_name: instLocallyFiniteOrderTopSubtypeLeOfDecidableRelOfLocallyFiniteOrder
code: instance (priority := low) [Preorder α] [DecidableRel ((· : α) ≤ ·)] [LocallyFiniteOrder α] :
    LocallyFiniteOrderTop { x : α // x ≤ y } 
goal: LocallyFiniteOrderTop { x // x ≤ y }

full_name: instLocallyFiniteOrderTopSubtypeLtOfDecidableRelOfLocallyFiniteOrder
code: instance (priority := low) [Preorder α] [DecidableRel ((· : α) < ·)] [LocallyFiniteOrder α] :
    LocallyFiniteOrderTop { x : α // x < y } 
goal: LocallyFiniteOrderTop { x // x < y }

full_name: instLocallyFiniteOrderBotSubtypeLeOfDecidableRelOfLocallyFiniteOrder
code: instance (priority := low) [Preorder α] [DecidableRel ((· : α) ≤ ·)] [LocallyFiniteOrder α] :
    LocallyFiniteOrderBot { x : α // y ≤ x } 
goal: LocallyFiniteOrderBot { x // y ≤ x }

full_name: instLocallyFiniteOrderBotSubtypeLtOfDecidableRelOfLocallyFiniteOrder
code: instance (priority := low) [Preorder α] [DecidableRel ((· : α) < ·)] [LocallyFiniteOrder α] :
    LocallyFiniteOrderBot { x : α // y < x } 
goal: LocallyFiniteOrderBot { x // y < x }

full_name: instFiniteSubtypeLeOfLocallyFiniteOrderBot
code: instance [Preorder α] [LocallyFiniteOrderBot α] : Finite { x : α // x ≤ y } 
goal: Finite { x // x ≤ y }

full_name: instFiniteSubtypeLtOfLocallyFiniteOrderBot
code: instance [Preorder α] [LocallyFiniteOrderBot α] : Finite { x : α // x < y } 
goal: Finite { x // x < y }

full_name: instFiniteSubtypeLeOfLocallyFiniteOrderTop
code: instance [Preorder α] [LocallyFiniteOrderTop α] : Finite { x : α // y ≤ x } 
goal: Finite { x // y ≤ x }

full_name: instFiniteSubtypeLtOfLocallyFiniteOrderTop
code: instance [Preorder α] [LocallyFiniteOrderTop α] : Finite { x : α // y < x } 
goal: Finite { x // y < x }

full_name: Set.toFinset_Icc
code: @[simp] lemma toFinset_Icc (a b : α) [Fintype (Icc a b)] : (Icc a b).toFinset = Finset.Icc a b 
goal: (Set.Icc a b).toFinset = Finset.Icc a b

full_name: Set.toFinset_Ico
code: @[simp] lemma toFinset_Ico (a b : α) [Fintype (Ico a b)] : (Ico a b).toFinset = Finset.Ico a b 
goal: (Set.Ico a b).toFinset = Finset.Ico a b

full_name: Set.toFinset_Ioc
code: @[simp] lemma toFinset_Ioc (a b : α) [Fintype (Ioc a b)] : (Ioc a b).toFinset = Finset.Ioc a b 
goal: (Set.Ioc a b).toFinset = Finset.Ioc a b

full_name: Set.toFinset_Ioo
code: @[simp] lemma toFinset_Ioo (a b : α) [Fintype (Ioo a b)] : (Ioo a b).toFinset = Finset.Ioo a b 
goal: (Set.Ioo a b).toFinset = Finset.Ioo a b

full_name: Set.toFinset_Ici
code: @[simp]
lemma toFinset_Ici (a : α) [Fintype (Ici a)] : (Ici a).toFinset = Finset.Ici a 
goal: (Set.Ici a).toFinset = Finset.Ici a

full_name: Set.toFinset_Ioi
code: @[simp]
lemma toFinset_Ioi (a : α) [Fintype (Ioi a)] : (Ioi a).toFinset = Finset.Ioi a 
goal: (Set.Ioi a).toFinset = Finset.Ioi a

full_name: Set.toFinset_Iic
code: @[simp]
lemma toFinset_Iic (a : α) [Fintype (Iic a)] : (Iic a).toFinset = Finset.Iic a 
goal: (Set.Iic a).toFinset = Finset.Iic a

full_name: Set.toFinset_Iio
code: @[simp]
lemma toFinset_Iio (a : α) [Fintype (Iio a)] : (Iio a).toFinset = Finset.Iio a 
goal: (Set.Iio a).toFinset = Finset.Iio a