File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

full_name: LinearLocallyFiniteOrder.succFn
code: /-- 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, ∞)`. -/
noncomputable def succFn (i : ι) : ι 
goal: ι

full_name: LinearLocallyFiniteOrder.succFn_spec
code: theorem succFn_spec (i : ι) : IsGLB (Set.Ioi i) (succFn i) 
goal: IsGLB (Set.Ioi i) (LinearLocallyFiniteOrder.succFn i)

full_name: LinearLocallyFiniteOrder.le_succFn
code: theorem le_succFn (i : ι) : i ≤ succFn i 
goal: i ≤ LinearLocallyFiniteOrder.succFn i

full_name: LinearLocallyFiniteOrder.isGLB_Ioc_of_isGLB_Ioi
code: theorem isGLB_Ioc_of_isGLB_Ioi {i j k : ι} (hij_lt : i < j) (h : IsGLB (Set.Ioi i) k) :
    IsGLB (Set.Ioc i j) k 
goal: IsGLB (Set.Ioc i j) k

full_name: LinearLocallyFiniteOrder.isMax_of_succFn_le
code: theorem isMax_of_succFn_le [LocallyFiniteOrder ι] (i : ι) (hi : succFn i ≤ i) : IsMax i 
goal: IsMax i

full_name: LinearLocallyFiniteOrder.succFn_le_of_lt
code: theorem succFn_le_of_lt (i j : ι) (hij : i < j) : succFn i ≤ j 
goal: LinearLocallyFiniteOrder.succFn i ≤ j

full_name: LinearLocallyFiniteOrder.le_of_lt_succFn
code: theorem le_of_lt_succFn (j i : ι) (hij : j < succFn i) : j ≤ i 
goal: j ≤ i

full_name: LinearLocallyFiniteOrder.instSuccOrderOfLocallyFiniteOrder
code: noncomputable instance (priority := 100) [LocallyFiniteOrder ι] : SuccOrder ι 
goal: SuccOrder ι

full_name: LinearLocallyFiniteOrder.instPredOrderOfLocallyFiniteOrder
code: noncomputable instance (priority := 100) [LocallyFiniteOrder ι] : PredOrder ι 
goal: PredOrder ι

full_name: LinearLocallyFiniteOrder.isSuccArchimedean
code: instance (priority := 100) LinearLocallyFiniteOrder.isSuccArchimedean [LocallyFiniteOrder ι] :
    IsSuccArchimedean ι 
goal: IsSuccArchimedean ι

full_name: LinearOrder.isPredArchimedean_of_isSuccArchimedean
code: instance (priority := 100) LinearOrder.isPredArchimedean_of_isSuccArchimedean [SuccOrder ι]
    [PredOrder ι] [IsSuccArchimedean ι] : IsPredArchimedean ι 
goal: IsPredArchimedean ι

full_name: toZ
code: /-- `toZ` numbers elements of `ι` according to their order, starting from `i0`. We prove in
`orderIsoRangeToZOfLinearSuccPredArch` that this defines an `OrderIso` between `ι` and
the range of `toZ`. -/
def toZ (i0 i : ι) : ℤ 
goal: ℤ

full_name: toZ_of_ge
code: theorem toZ_of_ge (hi : i0 ≤ i) : toZ i0 i = Nat.find (exists_succ_iterate_of_le hi) 
goal: toZ i0 i = ↑(Nat.find ⋯)

full_name: toZ_of_lt
code: theorem toZ_of_lt (hi : i < i0) : toZ i0 i = -Nat.find (exists_pred_iterate_of_le hi.le) 
goal: toZ i0 i = -↑(Nat.find ⋯)

full_name: toZ_of_eq
code: @[simp]
theorem toZ_of_eq : toZ i0 i0 = 0 
goal: toZ i0 i0 = 0

full_name: iterate_succ_toZ
code: theorem iterate_succ_toZ (i : ι) (hi : i0 ≤ i) : succ^[(toZ i0 i).toNat] i0 = i 
goal: Order.succ^[(toZ i0 i).toNat] i0 = i

full_name: iterate_pred_toZ
code: theorem iterate_pred_toZ (i : ι) (hi : i < i0) : pred^[(-toZ i0 i).toNat] i0 = i 
goal: Order.pred^[(-toZ i0 i).toNat] i0 = i

full_name: toZ_nonneg
code: lemma toZ_nonneg (hi : i0 ≤ i) : 0 ≤ toZ i0 i 
goal: 0 ≤ toZ i0 i

full_name: toZ_neg
code: theorem toZ_neg (hi : i < i0) : toZ i0 i < 0 
goal: toZ i0 i < 0

full_name: toZ_iterate_succ_le
code: theorem toZ_iterate_succ_le (n : ℕ) : toZ i0 (succ^[n] i0) ≤ n 
goal: toZ i0 (Order.succ^[n] i0) ≤ ↑n

full_name: toZ_iterate_pred_ge
code: theorem toZ_iterate_pred_ge (n : ℕ) : -(n : ℤ) ≤ toZ i0 (pred^[n] i0) 
goal: -↑n ≤ toZ i0 (Order.pred^[n] i0)

full_name: toZ_iterate_succ_of_not_isMax
code: theorem toZ_iterate_succ_of_not_isMax (n : ℕ) (hn : ¬IsMax (succ^[n] i0)) :
    toZ i0 (succ^[n] i0) = n 
goal: toZ i0 (Order.succ^[n] i0) = ↑n

full_name: toZ_iterate_pred_of_not_isMin
code: theorem toZ_iterate_pred_of_not_isMin (n : ℕ) (hn : ¬IsMin (pred^[n] i0)) :
    toZ i0 (pred^[n] i0) = -n 
goal: toZ i0 (Order.pred^[n] i0) = -↑n

full_name: le_of_toZ_le
code: theorem le_of_toZ_le {j : ι} (h_le : toZ i0 i ≤ toZ i0 j) : i ≤ j 
goal: i ≤ j

full_name: toZ_mono
code: theorem toZ_mono {i j : ι} (h_le : i ≤ j) : toZ i0 i ≤ toZ i0 j 
goal: toZ i0 i ≤ toZ i0 j

full_name: toZ_le_iff
code: theorem toZ_le_iff (i j : ι) : toZ i0 i ≤ toZ i0 j ↔ i ≤ j 
goal: toZ i0 i ≤ toZ i0 j ↔ i ≤ j

full_name: toZ_iterate_succ
code: theorem toZ_iterate_succ [NoMaxOrder ι] (n : ℕ) : toZ i0 (succ^[n] i0) = n 
goal: toZ i0 (Order.succ^[n] i0) = ↑n

full_name: toZ_iterate_pred
code: theorem toZ_iterate_pred [NoMinOrder ι] (n : ℕ) : toZ i0 (pred^[n] i0) = -n 
goal: toZ i0 (Order.pred^[n] i0) = -↑n

full_name: injective_toZ
code: theorem injective_toZ : Function.Injective (toZ i0) 
goal: Function.Injective (toZ i0)

full_name: orderIsoRangeToZOfLinearSuccPredArch
code: /-- `toZ` defines an `OrderIso` between `ι` and its range. -/
noncomputable def orderIsoRangeToZOfLinearSuccPredArch [hι : Nonempty ι] :
    ι ≃o Set.range (toZ hι.some) 
goal: ι ≃o ↑(Set.range (toZ hι.some))

full_name: countable_of_linear_succ_pred_arch
code: instance (priority := 100) countable_of_linear_succ_pred_arch : Countable ι 
goal: Countable ι

full_name: orderIsoIntOfLinearSuccPredArch
code: /-- If the order has neither bot nor top, `toZ` defines an `OrderIso` between `ι` and `ℤ`. -/
noncomputable def orderIsoIntOfLinearSuccPredArch [NoMaxOrder ι] [NoMinOrder ι] [hι : Nonempty ι] :
    ι ≃o ℤ 
goal: ι ≃o ℤ

full_name: orderIsoNatOfLinearSuccPredArch
code: /-- If the order has a bot but no top, `toZ` defines an `OrderIso` between `ι` and `ℕ`. -/
def orderIsoNatOfLinearSuccPredArch [NoMaxOrder ι] [OrderBot ι] : ι ≃o ℕ 
goal: ι ≃o ℕ

full_name: orderIsoRangeOfLinearSuccPredArch
code: /-- If the order has both a bot and a top, `toZ` gives an `OrderIso` between `ι` and
`Finset.range n` for some `n`. -/
def orderIsoRangeOfLinearSuccPredArch [OrderBot ι] [OrderTop ι] :
    ι ≃o Finset.range ((toZ ⊥ (⊤ : ι)).toNat + 1) 
goal: ι ≃o { x // x ∈ Finset.range ((toZ ⊥ ⊤).toNat + 1) }