File: Mathlib/Algebra/Order/Floor.lean

full_name: FloorSemiring.floor_of_neg
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: FloorSemiring.floor a = 0

full_name: FloorSemiring.ceil
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: α → ℕ

full_name: FloorSemiring.gc_floor
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: n ≤ FloorSemiring.floor a ↔ ↑n ≤ a

full_name: FloorSemiring.floor
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: α → ℕ

full_name: FloorSemiring.gc_ceil
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: GaloisConnection FloorSemiring.ceil Nat.cast

full_name: FloorSemiring
code: /-- A `FloorSemiring` is an ordered semiring over `α` with a function
`floor : α → ℕ` satisfying `∀ (n : ℕ) (x : α), n ≤ ⌊x⌋ ↔ (n : α) ≤ x)`.
Note that many lemmas require a `LinearOrder`. Please see the above `TODO`. -/
class FloorSemiring (α) [OrderedSemiring α] where
  /-- `FloorSemiring.floor a` computes the greatest natural `n` such that `(n : α) ≤ a`. -/
  floor : α → ℕ
  /-- `FloorSemiring.ceil a` computes the least natural `n` such that `a ≤ (n : α)`. -/
  ceil : α → ℕ
  /-- `FloorSemiring.floor` of a negative element is zero. -/
  floor_of_neg {a : α} (ha : a < 0) : floor a = 0
  /-- A natural number `n` is smaller than `FloorSemiring.floor a` iff its coercion to `α` is
  smaller than `a`. -/
  gc_floor {a : α} {n : ℕ} (ha : 0 ≤ a) : n ≤ floor a ↔ (n : α) ≤ a
  /-- `FloorSemiring.ceil` is the lower adjoint of the coercion `↑ : ℕ → α`. -/
  gc_ceil : GaloisConnection ceil (↑)
goal: Type u_4

full_name: instFloorSemiringNat
code: instance : FloorSemiring ℕ 
goal: FloorSemiring ℕ

full_name: Nat.floor
code: /-- `⌊a⌋₊` is the greatest natural `n` such that `n ≤ a`. If `a` is negative, then `⌊a⌋₊ = 0`. -/
def floor : α → ℕ 
goal: α → ℕ

full_name: Nat.ceil
code: /-- `⌈a⌉₊` is the least natural `n` such that `a ≤ n` -/
def ceil : α → ℕ 
goal: α → ℕ

full_name: Nat.floor_nat
code: @[simp]
theorem floor_nat : (Nat.floor : ℕ → ℕ) = id 
goal: Nat.floor = id

full_name: Nat.ceil_nat
code: @[simp]
theorem ceil_nat : (Nat.ceil : ℕ → ℕ) = id 
goal: Nat.ceil = id

full_name: Nat.«_aux_Mathlib_Algebra_Order_Floor___macroRules_Nat_term⌊_⌋₊_1»
code: @[inherit_doc]
notation "⌊" a "⌋₊" => Nat.floor a
goal: Lean.Macro

full_name: Nat._aux_Mathlib_Algebra_Order_Floor___unexpand_Nat_floor_1
code: @[inherit_doc]
notation "⌊" a "⌋₊" => Nat.floor a
goal: Lean.PrettyPrinter.Unexpander

full_name: Nat.«_aux_Mathlib_Algebra_Order_Floor___macroRules_Nat_term⌈_⌉₊_1»
code: @[inherit_doc]
notation "⌈" a "⌉₊" => Nat.ceil a
goal: Lean.Macro

full_name: Nat._aux_Mathlib_Algebra_Order_Floor___unexpand_Nat_ceil_1
code: @[inherit_doc]
notation "⌈" a "⌉₊" => Nat.ceil a
goal: Lean.PrettyPrinter.Unexpander

full_name: Nat.le_floor_iff
code: theorem le_floor_iff (ha : 0 ≤ a) : n ≤ ⌊a⌋₊ ↔ (n : α) ≤ a 
goal: n ≤ ⌊a⌋₊ ↔ ↑n ≤ a

full_name: Nat.le_floor
code: theorem le_floor (h : (n : α) ≤ a) : n ≤ ⌊a⌋₊ 
goal: n ≤ ⌊a⌋₊

full_name: Nat.floor_lt
code: theorem floor_lt (ha : 0 ≤ a) : ⌊a⌋₊ < n ↔ a < n 
goal: ⌊a⌋₊ < n ↔ a < ↑n

full_name: Nat.floor_lt_one
code: theorem floor_lt_one (ha : 0 ≤ a) : ⌊a⌋₊ < 1 ↔ a < 1 
goal: ⌊a⌋₊ < 1 ↔ a < 1

full_name: Nat.lt_of_floor_lt
code: theorem lt_of_floor_lt (h : ⌊a⌋₊ < n) : a < n 
goal: a < ↑n

full_name: Nat.lt_one_of_floor_lt_one
code: theorem lt_one_of_floor_lt_one (h : ⌊a⌋₊ < 1) : a < 1 
goal: a < 1

full_name: Nat.floor_le
code: theorem floor_le (ha : 0 ≤ a) : (⌊a⌋₊ : α) ≤ a 
goal: ↑⌊a⌋₊ ≤ a

full_name: Nat.lt_succ_floor
code: theorem lt_succ_floor (a : α) : a < ⌊a⌋₊.succ 
goal: a < ↑⌊a⌋₊.succ

full_name: Nat.lt_floor_add_one
code: theorem lt_floor_add_one (a : α) : a < ⌊a⌋₊ + 1 
goal: a < ↑⌊a⌋₊ + 1

full_name: Nat.floor_natCast
code: @[simp]
theorem floor_natCast (n : ℕ) : ⌊(n : α)⌋₊ = n 
goal: ⌊↑n⌋₊ = n

full_name: Nat.floor_zero
code: @[simp]
theorem floor_zero : ⌊(0 : α)⌋₊ = 0 
goal: ⌊0⌋₊ = 0

full_name: Nat.floor_one
code: @[simp]
theorem floor_one : ⌊(1 : α)⌋₊ = 1 
goal: ⌊1⌋₊ = 1

full_name: Nat.floor_ofNat
code: @[simp]
theorem floor_ofNat (n : ℕ) [n.AtLeastTwo] : ⌊no_index (OfNat.ofNat n : α)⌋₊ = n 
goal: ⌊OfNat.ofNat n⌋₊ = n

full_name: Nat.floor_of_nonpos
code: theorem floor_of_nonpos (ha : a ≤ 0) : ⌊a⌋₊ = 0 
goal: ⌊a⌋₊ = 0

full_name: Nat.floor_mono
code: theorem floor_mono : Monotone (floor : α → ℕ) 
goal: Monotone Nat.floor

full_name: Nat.floor_le_floor
code: @[gcongr]
theorem floor_le_floor : ∀ x y : α, x ≤ y → ⌊x⌋₊ ≤ ⌊y⌋₊ 
goal: x ≤ y → ⌊x⌋₊ ≤ ⌊y⌋₊

full_name: Nat.le_floor_iff'
code: theorem le_floor_iff' (hn : n ≠ 0) : n ≤ ⌊a⌋₊ ↔ (n : α) ≤ a 
goal: n ≤ ⌊a⌋₊ ↔ ↑n ≤ a

full_name: Nat.one_le_floor_iff
code: @[simp]
theorem one_le_floor_iff (x : α) : 1 ≤ ⌊x⌋₊ ↔ 1 ≤ x 
goal: 1 ≤ ⌊x⌋₊ ↔ 1 ≤ x

full_name: Nat.floor_lt'
code: theorem floor_lt' (hn : n ≠ 0) : ⌊a⌋₊ < n ↔ a < n 
goal: ⌊a⌋₊ < n ↔ a < ↑n

full_name: Nat.floor_pos
code: theorem floor_pos : 0 < ⌊a⌋₊ ↔ 1 ≤ a 
goal: 0 < ⌊a⌋₊ ↔ 1 ≤ a

full_name: Nat.pos_of_floor_pos
code: theorem pos_of_floor_pos (h : 0 < ⌊a⌋₊) : 0 < a 
goal: 0 < a

full_name: Nat.lt_of_lt_floor
code: theorem lt_of_lt_floor (h : n < ⌊a⌋₊) : ↑n < a 
goal: ↑n < a

full_name: Nat.floor_le_of_le
code: theorem floor_le_of_le (h : a ≤ n) : ⌊a⌋₊ ≤ n 
goal: ⌊a⌋₊ ≤ n

full_name: Nat.floor_le_one_of_le_one
code: theorem floor_le_one_of_le_one (h : a ≤ 1) : ⌊a⌋₊ ≤ 1 
goal: ⌊a⌋₊ ≤ 1

full_name: Nat.floor_eq_zero
code: @[simp]
theorem floor_eq_zero : ⌊a⌋₊ = 0 ↔ a < 1 
goal: ⌊a⌋₊ = 0 ↔ a < 1

full_name: Nat.floor_eq_iff
code: theorem floor_eq_iff (ha : 0 ≤ a) : ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1 
goal: ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1

full_name: Nat.floor_eq_iff'
code: theorem floor_eq_iff' (hn : n ≠ 0) : ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1 
goal: ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1

full_name: Nat.floor_eq_on_Ico
code: theorem floor_eq_on_Ico (n : ℕ) : ∀ a ∈ (Set.Ico n (n + 1) : Set α), ⌊a⌋₊ = n 
goal: a ∈ Set.Ico (↑n) (↑n + 1) → ⌊a⌋₊ = n

full_name: Nat.floor_eq_on_Ico'
code: theorem floor_eq_on_Ico' (n : ℕ) :
    ∀ a ∈ (Set.Ico n (n + 1) : Set α), (⌊a⌋₊ : α) = n 
goal: a ∈ Set.Ico (↑n) (↑n + 1) → ↑⌊a⌋₊ = ↑n

full_name: Nat.preimage_floor_zero
code: @[simp]
theorem preimage_floor_zero : (floor : α → ℕ) ⁻¹' {0} = Iio 1 
goal: Nat.floor ⁻¹' {0} = Set.Iio 1

full_name: Nat.preimage_floor_of_ne_zero
code: theorem preimage_floor_of_ne_zero {n : ℕ} (hn : n ≠ 0) :
    (floor : α → ℕ) ⁻¹' {n} = Ico (n : α) (n + 1) 
goal: Nat.floor ⁻¹' {n} = Set.Ico (↑n) (↑n + 1)

full_name: Nat.gc_ceil_coe
code: theorem gc_ceil_coe : GaloisConnection (ceil : α → ℕ) (↑) 
goal: GaloisConnection Nat.ceil Nat.cast

full_name: Nat.ceil_le
code: @[simp]
theorem ceil_le : ⌈a⌉₊ ≤ n ↔ a ≤ n 
goal: ⌈a⌉₊ ≤ n ↔ a ≤ ↑n

full_name: Nat.lt_ceil
code: theorem lt_ceil : n < ⌈a⌉₊ ↔ (n : α) < a 
goal: n < ⌈a⌉₊ ↔ ↑n < a

full_name: Nat.add_one_le_ceil_iff
code: theorem add_one_le_ceil_iff : n + 1 ≤ ⌈a⌉₊ ↔ (n : α) < a 
goal: n + 1 ≤ ⌈a⌉₊ ↔ ↑n < a

full_name: Nat.one_le_ceil_iff
code: @[simp]
theorem one_le_ceil_iff : 1 ≤ ⌈a⌉₊ ↔ 0 < a 
goal: 1 ≤ ⌈a⌉₊ ↔ 0 < a

full_name: Nat.ceil_le_floor_add_one
code: theorem ceil_le_floor_add_one (a : α) : ⌈a⌉₊ ≤ ⌊a⌋₊ + 1 
goal: ⌈a⌉₊ ≤ ⌊a⌋₊ + 1

full_name: Nat.le_ceil
code: theorem le_ceil (a : α) : a ≤ ⌈a⌉₊ 
goal: a ≤ ↑⌈a⌉₊

full_name: Nat.ceil_intCast
code: @[simp]
theorem ceil_intCast {α : Type*} [LinearOrderedRing α] [FloorSemiring α] (z : ℤ) :
    ⌈(z : α)⌉₊ = z.toNat 
goal: ⌈↑z⌉₊ = z.toNat

full_name: Nat.ceil_natCast
code: @[simp]
theorem ceil_natCast (n : ℕ) : ⌈(n : α)⌉₊ = n 
goal: ⌈↑n⌉₊ = n

full_name: Nat.ceil_mono
code: theorem ceil_mono : Monotone (ceil : α → ℕ) 
goal: Monotone Nat.ceil

full_name: Nat.ceil_le_ceil
code: @[gcongr]
theorem ceil_le_ceil : ∀ x y : α, x ≤ y → ⌈x⌉₊ ≤ ⌈y⌉₊ 
goal: x ≤ y → ⌈x⌉₊ ≤ ⌈y⌉₊

full_name: Nat.ceil_zero
code: @[simp]
theorem ceil_zero : ⌈(0 : α)⌉₊ = 0 
goal: ⌈0⌉₊ = 0

full_name: Nat.ceil_one
code: @[simp]
theorem ceil_one : ⌈(1 : α)⌉₊ = 1 
goal: ⌈1⌉₊ = 1

full_name: Nat.ceil_ofNat
code: @[simp]
theorem ceil_ofNat (n : ℕ) [n.AtLeastTwo] : ⌈no_index (OfNat.ofNat n : α)⌉₊ = n 
goal: ⌈OfNat.ofNat n⌉₊ = n

full_name: Nat.ceil_eq_zero
code: @[simp]
theorem ceil_eq_zero : ⌈a⌉₊ = 0 ↔ a ≤ 0 
goal: ⌈a⌉₊ = 0 ↔ a ≤ 0

full_name: Nat.ceil_pos
code: @[simp]
theorem ceil_pos : 0 < ⌈a⌉₊ ↔ 0 < a 
goal: 0 < ⌈a⌉₊ ↔ 0 < a

full_name: Nat.lt_of_ceil_lt
code: theorem lt_of_ceil_lt (h : ⌈a⌉₊ < n) : a < n 
goal: a < ↑n

full_name: Nat.le_of_ceil_le
code: theorem le_of_ceil_le (h : ⌈a⌉₊ ≤ n) : a ≤ n 
goal: a ≤ ↑n

full_name: Nat.floor_le_ceil
code: theorem floor_le_ceil (a : α) : ⌊a⌋₊ ≤ ⌈a⌉₊ 
goal: ⌊a⌋₊ ≤ ⌈a⌉₊

full_name: Nat.floor_lt_ceil_of_lt_of_pos
code: theorem floor_lt_ceil_of_lt_of_pos {a b : α} (h : a < b) (h' : 0 < b) : ⌊a⌋₊ < ⌈b⌉₊ 
goal: ⌊a⌋₊ < ⌈b⌉₊

full_name: Nat.ceil_eq_iff
code: theorem ceil_eq_iff (hn : n ≠ 0) : ⌈a⌉₊ = n ↔ ↑(n - 1) < a ∧ a ≤ n 
goal: ⌈a⌉₊ = n ↔ ↑(n - 1) < a ∧ a ≤ ↑n

full_name: Nat.preimage_ceil_zero
code: @[simp]
theorem preimage_ceil_zero : (Nat.ceil : α → ℕ) ⁻¹' {0} = Iic 0 
goal: Nat.ceil ⁻¹' {0} = Set.Iic 0

full_name: Nat.preimage_ceil_of_ne_zero
code: theorem preimage_ceil_of_ne_zero (hn : n ≠ 0) : (Nat.ceil : α → ℕ) ⁻¹' {n} = Ioc (↑(n - 1) : α) n 
goal: Nat.ceil ⁻¹' {n} = Set.Ioc ↑(n - 1) ↑n

full_name: Nat.preimage_Ioo
code: @[simp]
theorem preimage_Ioo {a b : α} (ha : 0 ≤ a) :
    (Nat.cast : ℕ → α) ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋₊ ⌈b⌉₊ 
goal: Nat.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋₊ ⌈b⌉₊

full_name: Nat.preimage_Ico
code: @[simp]
theorem preimage_Ico {a b : α} : (Nat.cast : ℕ → α) ⁻¹' Set.Ico a b = Set.Ico ⌈a⌉₊ ⌈b⌉₊ 
goal: Nat.cast ⁻¹' Set.Ico a b = Set.Ico ⌈a⌉₊ ⌈b⌉₊

full_name: Nat.preimage_Ioc
code: @[simp]
theorem preimage_Ioc {a b : α} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    (Nat.cast : ℕ → α) ⁻¹' Set.Ioc a b = Set.Ioc ⌊a⌋₊ ⌊b⌋₊ 
goal: Nat.cast ⁻¹' Set.Ioc a b = Set.Ioc ⌊a⌋₊ ⌊b⌋₊

full_name: Nat.preimage_Icc
code: @[simp]
theorem preimage_Icc {a b : α} (hb : 0 ≤ b) :
    (Nat.cast : ℕ → α) ⁻¹' Set.Icc a b = Set.Icc ⌈a⌉₊ ⌊b⌋₊ 
goal: Nat.cast ⁻¹' Set.Icc a b = Set.Icc ⌈a⌉₊ ⌊b⌋₊

full_name: Nat.preimage_Ioi
code: @[simp]
theorem preimage_Ioi {a : α} (ha : 0 ≤ a) : (Nat.cast : ℕ → α) ⁻¹' Set.Ioi a = Set.Ioi ⌊a⌋₊ 
goal: Nat.cast ⁻¹' Set.Ioi a = Set.Ioi ⌊a⌋₊

full_name: Nat.preimage_Ici
code: @[simp]
theorem preimage_Ici {a : α} : (Nat.cast : ℕ → α) ⁻¹' Set.Ici a = Set.Ici ⌈a⌉₊ 
goal: Nat.cast ⁻¹' Set.Ici a = Set.Ici ⌈a⌉₊

full_name: Nat.preimage_Iio
code: @[simp]
theorem preimage_Iio {a : α} : (Nat.cast : ℕ → α) ⁻¹' Set.Iio a = Set.Iio ⌈a⌉₊ 
goal: Nat.cast ⁻¹' Set.Iio a = Set.Iio ⌈a⌉₊

full_name: Nat.preimage_Iic
code: @[simp]
theorem preimage_Iic {a : α} (ha : 0 ≤ a) : (Nat.cast : ℕ → α) ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊ 
goal: Nat.cast ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊

full_name: Nat.floor_add_nat
code: theorem floor_add_nat (ha : 0 ≤ a) (n : ℕ) : ⌊a + n⌋₊ = ⌊a⌋₊ + n 
goal: ⌊a + ↑n⌋₊ = ⌊a⌋₊ + n

full_name: Nat.floor_add_one
code: theorem floor_add_one (ha : 0 ≤ a) : ⌊a + 1⌋₊ = ⌊a⌋₊ + 1 
goal: ⌊a + 1⌋₊ = ⌊a⌋₊ + 1

full_name: Nat.floor_add_ofNat
code: theorem floor_add_ofNat (ha : 0 ≤ a) (n : ℕ) [n.AtLeastTwo] :
    ⌊a + (no_index (OfNat.ofNat n))⌋₊ = ⌊a⌋₊ + OfNat.ofNat n 
goal: ⌊a + OfNat.ofNat n⌋₊ = ⌊a⌋₊ + OfNat.ofNat n

full_name: Nat.floor_sub_nat
code: @[simp]
theorem floor_sub_nat [Sub α] [OrderedSub α] [ExistsAddOfLE α] (a : α) (n : ℕ) :
    ⌊a - n⌋₊ = ⌊a⌋₊ - n 
goal: ⌊a - ↑n⌋₊ = ⌊a⌋₊ - n

full_name: Nat.floor_sub_one
code: @[simp]
theorem floor_sub_one [Sub α] [OrderedSub α] [ExistsAddOfLE α] (a : α) : ⌊a - 1⌋₊ = ⌊a⌋₊ - 1 
goal: ⌊a - 1⌋₊ = ⌊a⌋₊ - 1

full_name: Nat.floor_sub_ofNat
code: @[simp]
theorem floor_sub_ofNat [Sub α] [OrderedSub α] [ExistsAddOfLE α] (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌊a - (no_index (OfNat.ofNat n))⌋₊ = ⌊a⌋₊ - OfNat.ofNat n 
goal: ⌊a - OfNat.ofNat n⌋₊ = ⌊a⌋₊ - OfNat.ofNat n

full_name: Nat.ceil_add_nat
code: theorem ceil_add_nat (ha : 0 ≤ a) (n : ℕ) : ⌈a + n⌉₊ = ⌈a⌉₊ + n 
goal: ⌈a + ↑n⌉₊ = ⌈a⌉₊ + n

full_name: Nat.ceil_add_one
code: theorem ceil_add_one (ha : 0 ≤ a) : ⌈a + 1⌉₊ = ⌈a⌉₊ + 1 
goal: ⌈a + 1⌉₊ = ⌈a⌉₊ + 1

full_name: Nat.ceil_add_ofNat
code: theorem ceil_add_ofNat (ha : 0 ≤ a) (n : ℕ) [n.AtLeastTwo] :
    ⌈a + (no_index (OfNat.ofNat n))⌉₊ = ⌈a⌉₊ + OfNat.ofNat n 
goal: ⌈a + OfNat.ofNat n⌉₊ = ⌈a⌉₊ + OfNat.ofNat n

full_name: Nat.ceil_lt_add_one
code: theorem ceil_lt_add_one (ha : 0 ≤ a) : (⌈a⌉₊ : α) < a + 1 
goal: ↑⌈a⌉₊ < a + 1

full_name: Nat.ceil_add_le
code: theorem ceil_add_le (a b : α) : ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊ 
goal: ⌈a + b⌉₊ ≤ ⌈a⌉₊ + ⌈b⌉₊

full_name: Nat.sub_one_lt_floor
code: theorem sub_one_lt_floor (a : α) : a - 1 < ⌊a⌋₊ 
goal: a - 1 < ↑⌊a⌋₊

full_name: Nat.floor_div_nat
code: theorem floor_div_nat (a : α) (n : ℕ) : ⌊a / n⌋₊ = ⌊a⌋₊ / n 
goal: ⌊a / ↑n⌋₊ = ⌊a⌋₊ / n

full_name: Nat.floor_div_ofNat
code: theorem floor_div_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌊a / (no_index (OfNat.ofNat n))⌋₊ = ⌊a⌋₊ / OfNat.ofNat n 
goal: ⌊a / OfNat.ofNat n⌋₊ = ⌊a⌋₊ / OfNat.ofNat n

full_name: Nat.floor_div_eq_div
code: /-- Natural division is the floor of field division. -/
theorem floor_div_eq_div (m n : ℕ) : ⌊(m : α) / n⌋₊ = m / n 
goal: ⌊↑m / ↑n⌋₊ = m / n

full_name: subsingleton_floorSemiring
code: /-- There exists at most one `FloorSemiring` structure on a linear ordered semiring. -/
theorem subsingleton_floorSemiring {α} [LinearOrderedSemiring α] :
    Subsingleton (FloorSemiring α) 
goal: Subsingleton (FloorSemiring α)

full_name: FloorRing
code: /-- A `FloorRing` is a linear ordered ring over `α` with a function
`floor : α → ℤ` satisfying `∀ (z : ℤ) (a : α), z ≤ floor a ↔ (z : α) ≤ a)`.
-/
class FloorRing (α) [LinearOrderedRing α] where
  /-- `FloorRing.floor a` computes the greatest integer `z` such that `(z : α) ≤ a`. -/
  floor : α → ℤ
  /-- `FloorRing.ceil a` computes the least integer `z` such that `a ≤ (z : α)`. -/
  ceil : α → ℤ
  /-- `FloorRing.ceil` is the upper adjoint of the coercion `↑ : ℤ → α`. -/
  gc_coe_floor : GaloisConnection (↑) floor
  /-- `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. -/
  gc_ceil_coe : GaloisConnection ceil (↑)
goal: Type u_4

full_name: FloorRing.ceil
code: /-- A `FloorRing` is a linear ordered ring over `α` with a function
`floor : α → ℤ` satisfying `∀ (z : ℤ) (a : α), z ≤ floor a ↔ (z : α) ≤ a)`.
-/
class FloorRing (α) [LinearOrderedRing α] where
  /-- `FloorRing.floor a` computes the greatest integer `z` such that `(z : α) ≤ a`. -/
  floor : α → ℤ
  /-- `FloorRing.ceil a` computes the least integer `z` such that `a ≤ (z : α)`. -/
  ceil : α → ℤ
  /-- `FloorRing.ceil` is the upper adjoint of the coercion `↑ : ℤ → α`. -/
  gc_coe_floor : GaloisConnection (↑) floor
  /-- `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. -/
  gc_ceil_coe : GaloisConnection ceil (↑)
goal: α → ℤ

full_name: FloorRing.gc_ceil_coe
code: /-- A `FloorRing` is a linear ordered ring over `α` with a function
`floor : α → ℤ` satisfying `∀ (z : ℤ) (a : α), z ≤ floor a ↔ (z : α) ≤ a)`.
-/
class FloorRing (α) [LinearOrderedRing α] where
  /-- `FloorRing.floor a` computes the greatest integer `z` such that `(z : α) ≤ a`. -/
  floor : α → ℤ
  /-- `FloorRing.ceil a` computes the least integer `z` such that `a ≤ (z : α)`. -/
  ceil : α → ℤ
  /-- `FloorRing.ceil` is the upper adjoint of the coercion `↑ : ℤ → α`. -/
  gc_coe_floor : GaloisConnection (↑) floor
  /-- `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. -/
  gc_ceil_coe : GaloisConnection ceil (↑)
goal: GaloisConnection FloorRing.ceil Int.cast

full_name: FloorRing.floor
code: /-- A `FloorRing` is a linear ordered ring over `α` with a function
`floor : α → ℤ` satisfying `∀ (z : ℤ) (a : α), z ≤ floor a ↔ (z : α) ≤ a)`.
-/
class FloorRing (α) [LinearOrderedRing α] where
  /-- `FloorRing.floor a` computes the greatest integer `z` such that `(z : α) ≤ a`. -/
  floor : α → ℤ
  /-- `FloorRing.ceil a` computes the least integer `z` such that `a ≤ (z : α)`. -/
  ceil : α → ℤ
  /-- `FloorRing.ceil` is the upper adjoint of the coercion `↑ : ℤ → α`. -/
  gc_coe_floor : GaloisConnection (↑) floor
  /-- `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. -/
  gc_ceil_coe : GaloisConnection ceil (↑)
goal: α → ℤ

full_name: FloorRing.gc_coe_floor
code: /-- A `FloorRing` is a linear ordered ring over `α` with a function
`floor : α → ℤ` satisfying `∀ (z : ℤ) (a : α), z ≤ floor a ↔ (z : α) ≤ a)`.
-/
class FloorRing (α) [LinearOrderedRing α] where
  /-- `FloorRing.floor a` computes the greatest integer `z` such that `(z : α) ≤ a`. -/
  floor : α → ℤ
  /-- `FloorRing.ceil a` computes the least integer `z` such that `a ≤ (z : α)`. -/
  ceil : α → ℤ
  /-- `FloorRing.ceil` is the upper adjoint of the coercion `↑ : ℤ → α`. -/
  gc_coe_floor : GaloisConnection (↑) floor
  /-- `FloorRing.ceil` is the lower adjoint of the coercion `↑ : ℤ → α`. -/
  gc_ceil_coe : GaloisConnection ceil (↑)
goal: GaloisConnection Int.cast FloorRing.floor

full_name: instFloorRingInt
code: instance : FloorRing ℤ 
goal: FloorRing ℤ

full_name: FloorRing.ofFloor
code: /-- A `FloorRing` constructor from the `floor` function alone. -/
def FloorRing.ofFloor (α) [LinearOrderedRing α] (floor : α → ℤ)
    (gc_coe_floor : GaloisConnection (↑) floor) : FloorRing α 
goal: FloorRing α

full_name: FloorRing.ofCeil
code: /-- A `FloorRing` constructor from the `ceil` function alone. -/
def FloorRing.ofCeil (α) [LinearOrderedRing α] (ceil : α → ℤ)
    (gc_ceil_coe : GaloisConnection ceil (↑)) : FloorRing α 
goal: FloorRing α

full_name: Int.floor
code: /-- `Int.floor a` is the greatest integer `z` such that `z ≤ a`. It is denoted with `⌊a⌋`. -/
def floor : α → ℤ 
goal: α → ℤ

full_name: Int.ceil
code: /-- `Int.ceil a` is the smallest integer `z` such that `a ≤ z`. It is denoted with `⌈a⌉`. -/
def ceil : α → ℤ 
goal: α → ℤ

full_name: Int.fract
code: /-- `Int.fract a`, the fractional part of `a`, is `a` minus its floor. -/
def fract (a : α) : α 
goal: α

full_name: Int.floor_int
code: @[simp]
theorem floor_int : (Int.floor : ℤ → ℤ) = id 
goal: Int.floor = id

full_name: Int.ceil_int
code: @[simp]
theorem ceil_int : (Int.ceil : ℤ → ℤ) = id 
goal: Int.ceil = id

full_name: Int.fract_int
code: @[simp]
theorem fract_int : (Int.fract : ℤ → ℤ) = 0 
goal: Int.fract = 0

full_name: Int._aux_Mathlib_Algebra_Order_Floor___unexpand_Int_floor_1
code: @[inherit_doc]
notation "⌊" a "⌋" => Int.floor a
goal: Lean.PrettyPrinter.Unexpander

full_name: Int.«_aux_Mathlib_Algebra_Order_Floor___macroRules_Int_term⌊_⌋_1»
code: @[inherit_doc]
notation "⌊" a "⌋" => Int.floor a
goal: Lean.Macro

full_name: Int.«_aux_Mathlib_Algebra_Order_Floor___macroRules_Int_term⌈_⌉_1»
code: @[inherit_doc]
notation "⌈" a "⌉" => Int.ceil a
goal: Lean.Macro

full_name: Int._aux_Mathlib_Algebra_Order_Floor___unexpand_Int_ceil_1
code: @[inherit_doc]
notation "⌈" a "⌉" => Int.ceil a
goal: Lean.PrettyPrinter.Unexpander

full_name: Int.floorRing_floor_eq
code: @[simp]
theorem floorRing_floor_eq : @FloorRing.floor = @Int.floor 
goal: @FloorRing.floor = @Int.floor

full_name: Int.floorRing_ceil_eq
code: @[simp]
theorem floorRing_ceil_eq : @FloorRing.ceil = @Int.ceil 
goal: @FloorRing.ceil = @Int.ceil

full_name: Int.gc_coe_floor
code: theorem gc_coe_floor : GaloisConnection ((↑) : ℤ → α) floor 
goal: GaloisConnection Int.cast Int.floor

full_name: Int.le_floor
code: theorem le_floor : z ≤ ⌊a⌋ ↔ (z : α) ≤ a 
goal: z ≤ ⌊a⌋ ↔ ↑z ≤ a

full_name: Int.floor_lt
code: theorem floor_lt : ⌊a⌋ < z ↔ a < z 
goal: ⌊a⌋ < z ↔ a < ↑z

full_name: Int.floor_le
code: theorem floor_le (a : α) : (⌊a⌋ : α) ≤ a 
goal: ↑⌊a⌋ ≤ a

full_name: Int.floor_nonneg
code: theorem floor_nonneg : 0 ≤ ⌊a⌋ ↔ 0 ≤ a 
goal: 0 ≤ ⌊a⌋ ↔ 0 ≤ a

full_name: Int.floor_le_sub_one_iff
code: @[simp]
theorem floor_le_sub_one_iff : ⌊a⌋ ≤ z - 1 ↔ a < z 
goal: ⌊a⌋ ≤ z - 1 ↔ a < ↑z

full_name: Int.floor_le_neg_one_iff
code: @[simp]
theorem floor_le_neg_one_iff : ⌊a⌋ ≤ -1 ↔ a < 0 
goal: ⌊a⌋ ≤ -1 ↔ a < 0

full_name: Int.floor_nonpos
code: theorem floor_nonpos (ha : a ≤ 0) : ⌊a⌋ ≤ 0 
goal: ⌊a⌋ ≤ 0

full_name: Int.lt_succ_floor
code: theorem lt_succ_floor (a : α) : a < ⌊a⌋.succ 
goal: a < ↑⌊a⌋.succ

full_name: Int.lt_floor_add_one
code: @[simp]
theorem lt_floor_add_one (a : α) : a < ⌊a⌋ + 1 
goal: a < ↑⌊a⌋ + 1

full_name: Int.sub_one_lt_floor
code: @[simp]
theorem sub_one_lt_floor (a : α) : a - 1 < ⌊a⌋ 
goal: a - 1 < ↑⌊a⌋

full_name: Int.floor_intCast
code: @[simp]
theorem floor_intCast (z : ℤ) : ⌊(z : α)⌋ = z 
goal: ⌊↑z⌋ = z

full_name: Int.floor_natCast
code: @[simp]
theorem floor_natCast (n : ℕ) : ⌊(n : α)⌋ = n 
goal: ⌊↑n⌋ = ↑n

full_name: Int.floor_zero
code: @[simp]
theorem floor_zero : ⌊(0 : α)⌋ = 0 
goal: ⌊0⌋ = 0

full_name: Int.floor_one
code: @[simp]
theorem floor_one : ⌊(1 : α)⌋ = 1 
goal: ⌊1⌋ = 1

full_name: Int.floor_ofNat
code: @[simp] theorem floor_ofNat (n : ℕ) [n.AtLeastTwo] : ⌊(no_index (OfNat.ofNat n : α))⌋ = n 
goal: ⌊OfNat.ofNat n⌋ = ↑n

full_name: Int.floor_mono
code: @[mono]
theorem floor_mono : Monotone (floor : α → ℤ) 
goal: Monotone Int.floor

full_name: Int.floor_le_floor
code: @[gcongr]
theorem floor_le_floor : ∀ x y : α, x ≤ y → ⌊x⌋ ≤ ⌊y⌋ 
goal: x ≤ y → ⌊x⌋ ≤ ⌊y⌋

full_name: Int.floor_pos
code: theorem floor_pos : 0 < ⌊a⌋ ↔ 1 ≤ a 
goal: 0 < ⌊a⌋ ↔ 1 ≤ a

full_name: Int.floor_add_int
code: @[simp]
theorem floor_add_int (a : α) (z : ℤ) : ⌊a + z⌋ = ⌊a⌋ + z 
goal: ⌊a + ↑z⌋ = ⌊a⌋ + z

full_name: Int.floor_add_one
code: @[simp]
theorem floor_add_one (a : α) : ⌊a + 1⌋ = ⌊a⌋ + 1 
goal: ⌊a + 1⌋ = ⌊a⌋ + 1

full_name: Int.le_floor_add
code: theorem le_floor_add (a b : α) : ⌊a⌋ + ⌊b⌋ ≤ ⌊a + b⌋ 
goal: ⌊a⌋ + ⌊b⌋ ≤ ⌊a + b⌋

full_name: Int.le_floor_add_floor
code: theorem le_floor_add_floor (a b : α) : ⌊a + b⌋ - 1 ≤ ⌊a⌋ + ⌊b⌋ 
goal: ⌊a + b⌋ - 1 ≤ ⌊a⌋ + ⌊b⌋

full_name: Int.floor_int_add
code: @[simp]
theorem floor_int_add (z : ℤ) (a : α) : ⌊↑z + a⌋ = z + ⌊a⌋ 
goal: ⌊↑z + a⌋ = z + ⌊a⌋

full_name: Int.floor_add_nat
code: @[simp]
theorem floor_add_nat (a : α) (n : ℕ) : ⌊a + n⌋ = ⌊a⌋ + n 
goal: ⌊a + ↑n⌋ = ⌊a⌋ + ↑n

full_name: Int.floor_add_ofNat
code: @[simp]
theorem floor_add_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌊a + (no_index (OfNat.ofNat n))⌋ = ⌊a⌋ + OfNat.ofNat n 
goal: ⌊a + OfNat.ofNat n⌋ = ⌊a⌋ + OfNat.ofNat n

full_name: Int.floor_nat_add
code: @[simp]
theorem floor_nat_add (n : ℕ) (a : α) : ⌊↑n + a⌋ = n + ⌊a⌋ 
goal: ⌊↑n + a⌋ = ↑n + ⌊a⌋

full_name: Int.floor_ofNat_add
code: @[simp]
theorem floor_ofNat_add (n : ℕ) [n.AtLeastTwo] (a : α) :
    ⌊(no_index (OfNat.ofNat n)) + a⌋ = OfNat.ofNat n + ⌊a⌋ 
goal: ⌊OfNat.ofNat n + a⌋ = OfNat.ofNat n + ⌊a⌋

full_name: Int.floor_sub_int
code: @[simp]
theorem floor_sub_int (a : α) (z : ℤ) : ⌊a - z⌋ = ⌊a⌋ - z 
goal: ⌊a - ↑z⌋ = ⌊a⌋ - z

full_name: Int.floor_sub_nat
code: @[simp]
theorem floor_sub_nat (a : α) (n : ℕ) : ⌊a - n⌋ = ⌊a⌋ - n 
goal: ⌊a - ↑n⌋ = ⌊a⌋ - ↑n

full_name: Int.floor_sub_one
code: @[simp] theorem floor_sub_one (a : α) : ⌊a - 1⌋ = ⌊a⌋ - 1 
goal: ⌊a - 1⌋ = ⌊a⌋ - 1

full_name: Int.floor_sub_ofNat
code: @[simp]
theorem floor_sub_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌊a - (no_index (OfNat.ofNat n))⌋ = ⌊a⌋ - OfNat.ofNat n 
goal: ⌊a - OfNat.ofNat n⌋ = ⌊a⌋ - OfNat.ofNat n

full_name: Int.abs_sub_lt_one_of_floor_eq_floor
code: theorem abs_sub_lt_one_of_floor_eq_floor {α : Type*} [LinearOrderedCommRing α] [FloorRing α]
    {a b : α} (h : ⌊a⌋ = ⌊b⌋) : |a - b| < 1 
goal: |a - b| < 1

full_name: Int.floor_eq_iff
code: theorem floor_eq_iff : ⌊a⌋ = z ↔ ↑z ≤ a ∧ a < z + 1 
goal: ⌊a⌋ = z ↔ ↑z ≤ a ∧ a < ↑z + 1

full_name: Int.floor_eq_zero_iff
code: @[simp]
theorem floor_eq_zero_iff : ⌊a⌋ = 0 ↔ a ∈ Ico (0 : α) 1 
goal: ⌊a⌋ = 0 ↔ a ∈ Set.Ico 0 1

full_name: Int.floor_eq_on_Ico
code: theorem floor_eq_on_Ico (n : ℤ) : ∀ a ∈ Set.Ico (n : α) (n + 1), ⌊a⌋ = n 
goal: a ∈ Set.Ico (↑n) (↑n + 1) → ⌊a⌋ = n

full_name: Int.floor_eq_on_Ico'
code: theorem floor_eq_on_Ico' (n : ℤ) : ∀ a ∈ Set.Ico (n : α) (n + 1), (⌊a⌋ : α) = n 
goal: a ∈ Set.Ico (↑n) (↑n + 1) → ↑⌊a⌋ = ↑n

full_name: Int.preimage_floor_singleton
code: @[simp]
theorem preimage_floor_singleton (m : ℤ) : (floor : α → ℤ) ⁻¹' {m} = Ico (m : α) (m + 1) 
goal: Int.floor ⁻¹' {m} = Set.Ico (↑m) (↑m + 1)

full_name: Int.self_sub_floor
code: @[simp]
theorem self_sub_floor (a : α) : a - ⌊a⌋ = fract a 
goal: a - ↑⌊a⌋ = Int.fract a

full_name: Int.floor_add_fract
code: @[simp]
theorem floor_add_fract (a : α) : (⌊a⌋ : α) + fract a = a 
goal: ↑⌊a⌋ + Int.fract a = a

full_name: Int.fract_add_floor
code: @[simp]
theorem fract_add_floor (a : α) : fract a + ⌊a⌋ = a 
goal: Int.fract a + ↑⌊a⌋ = a

full_name: Int.fract_add_int
code: @[simp]
theorem fract_add_int (a : α) (m : ℤ) : fract (a + m) = fract a 
goal: Int.fract (a + ↑m) = Int.fract a

full_name: Int.fract_add_nat
code: @[simp]
theorem fract_add_nat (a : α) (m : ℕ) : fract (a + m) = fract a 
goal: Int.fract (a + ↑m) = Int.fract a

full_name: Int.fract_add_one
code: @[simp]
theorem fract_add_one (a : α) : fract (a + 1) = fract a 
goal: Int.fract (a + 1) = Int.fract a

full_name: Int.fract_add_ofNat
code: @[simp]
theorem fract_add_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    fract (a + (no_index (OfNat.ofNat n))) = fract a 
goal: Int.fract (a + OfNat.ofNat n) = Int.fract a

full_name: Int.fract_int_add
code: @[simp]
theorem fract_int_add (m : ℤ) (a : α) : fract (↑m + a) = fract a 
goal: Int.fract (↑m + a) = Int.fract a

full_name: Int.fract_nat_add
code: @[simp]
theorem fract_nat_add (n : ℕ) (a : α) : fract (↑n + a) = fract a 
goal: Int.fract (↑n + a) = Int.fract a

full_name: Int.fract_one_add
code: @[simp]
theorem fract_one_add (a : α) : fract (1 + a) = fract a 
goal: Int.fract (1 + a) = Int.fract a

full_name: Int.fract_ofNat_add
code: @[simp]
theorem fract_ofNat_add (n : ℕ) [n.AtLeastTwo] (a : α) :
    fract ((no_index (OfNat.ofNat n)) + a) = fract a 
goal: Int.fract (OfNat.ofNat n + a) = Int.fract a

full_name: Int.fract_sub_int
code: @[simp]
theorem fract_sub_int (a : α) (m : ℤ) : fract (a - m) = fract a 
goal: Int.fract (a - ↑m) = Int.fract a

full_name: Int.fract_sub_nat
code: @[simp]
theorem fract_sub_nat (a : α) (n : ℕ) : fract (a - n) = fract a 
goal: Int.fract (a - ↑n) = Int.fract a

full_name: Int.fract_sub_one
code: @[simp]
theorem fract_sub_one (a : α) : fract (a - 1) = fract a 
goal: Int.fract (a - 1) = Int.fract a

full_name: Int.fract_sub_ofNat
code: @[simp]
theorem fract_sub_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    fract (a - (no_index (OfNat.ofNat n))) = fract a 
goal: Int.fract (a - OfNat.ofNat n) = Int.fract a

full_name: Int.fract_add_le
code: theorem fract_add_le (a b : α) : fract (a + b) ≤ fract a + fract b 
goal: Int.fract (a + b) ≤ Int.fract a + Int.fract b

full_name: Int.fract_add_fract_le
code: theorem fract_add_fract_le (a b : α) : fract a + fract b ≤ fract (a + b) + 1 
goal: Int.fract a + Int.fract b ≤ Int.fract (a + b) + 1

full_name: Int.self_sub_fract
code: @[simp]
theorem self_sub_fract (a : α) : a - fract a = ⌊a⌋ 
goal: a - Int.fract a = ↑⌊a⌋

full_name: Int.fract_sub_self
code: @[simp]
theorem fract_sub_self (a : α) : fract a - a = -⌊a⌋ 
goal: Int.fract a - a = -↑⌊a⌋

full_name: Int.fract_nonneg
code: @[simp]
theorem fract_nonneg (a : α) : 0 ≤ fract a 
goal: 0 ≤ Int.fract a

full_name: Int.fract_pos
code: /-- The fractional part of `a` is positive if and only if `a ≠ ⌊a⌋`. -/
lemma fract_pos : 0 < fract a ↔ a ≠ ⌊a⌋ 
goal: 0 < Int.fract a ↔ a ≠ ↑⌊a⌋

full_name: Int.fract_lt_one
code: theorem fract_lt_one (a : α) : fract a < 1 
goal: Int.fract a < 1

full_name: Int.fract_zero
code: @[simp]
theorem fract_zero : fract (0 : α) = 0 
goal: Int.fract 0 = 0

full_name: Int.fract_one
code: @[simp]
theorem fract_one : fract (1 : α) = 0 
goal: Int.fract 1 = 0

full_name: Int.abs_fract
code: theorem abs_fract : |fract a| = fract a 
goal: |Int.fract a| = Int.fract a

full_name: Int.abs_one_sub_fract
code: @[simp]
theorem abs_one_sub_fract : |1 - fract a| = 1 - fract a 
goal: |1 - Int.fract a| = 1 - Int.fract a

full_name: Int.fract_intCast
code: @[simp]
theorem fract_intCast (z : ℤ) : fract (z : α) = 0 
goal: Int.fract ↑z = 0

full_name: Int.fract_natCast
code: @[simp]
theorem fract_natCast (n : ℕ) : fract (n : α) = 0 
goal: Int.fract ↑n = 0

full_name: Int.fract_ofNat
code: @[simp]
theorem fract_ofNat (n : ℕ) [n.AtLeastTwo] :
    fract ((no_index (OfNat.ofNat n)) : α) = 0 
goal: Int.fract (OfNat.ofNat n) = 0

full_name: Int.fract_floor
code: theorem fract_floor (a : α) : fract (⌊a⌋ : α) = 0 
goal: Int.fract ↑⌊a⌋ = 0

full_name: Int.floor_fract
code: @[simp]
theorem floor_fract (a : α) : ⌊fract a⌋ = 0 
goal: ⌊Int.fract a⌋ = 0

full_name: Int.fract_eq_iff
code: theorem fract_eq_iff {a b : α} : fract a = b ↔ 0 ≤ b ∧ b < 1 ∧ ∃ z : ℤ, a - b = z 
goal: Int.fract a = b ↔ 0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z

full_name: Int.fract_eq_fract
code: theorem fract_eq_fract {a b : α} : fract a = fract b ↔ ∃ z : ℤ, a - b = z 
goal: Int.fract a = Int.fract b ↔ ∃ z, a - b = ↑z

full_name: Int.fract_eq_self
code: @[simp]
theorem fract_eq_self {a : α} : fract a = a ↔ 0 ≤ a ∧ a < 1 
goal: Int.fract a = a ↔ 0 ≤ a ∧ a < 1

full_name: Int.fract_fract
code: @[simp]
theorem fract_fract (a : α) : fract (fract a) = fract a 
goal: Int.fract (Int.fract a) = Int.fract a

full_name: Int.fract_add
code: theorem fract_add (a b : α) : ∃ z : ℤ, fract (a + b) - fract a - fract b = z 
goal: ∃ z, Int.fract (a + b) - Int.fract a - Int.fract b = ↑z

full_name: Int.fract_neg
code: theorem fract_neg {x : α} (hx : fract x ≠ 0) : fract (-x) = 1 - fract x 
goal: Int.fract (-x) = 1 - Int.fract x

full_name: Int.fract_neg_eq_zero
code: @[simp]
theorem fract_neg_eq_zero {x : α} : fract (-x) = 0 ↔ fract x = 0 
goal: Int.fract (-x) = 0 ↔ Int.fract x = 0

full_name: Int.fract_mul_nat
code: theorem fract_mul_nat (a : α) (b : ℕ) : ∃ z : ℤ, fract a * b - fract (a * b) = z 
goal: ∃ z, Int.fract a * ↑b - Int.fract (a * ↑b) = ↑z

full_name: Int.preimage_fract
code: theorem preimage_fract (s : Set α) :
    fract ⁻¹' s = ⋃ m : ℤ, (fun x => x - (m : α)) ⁻¹' (s ∩ Ico (0 : α) 1) 
goal: Int.fract ⁻¹' s = ⋃ m, (fun x => x - ↑m) ⁻¹' (s ∩ Set.Ico 0 1)

full_name: Int.image_fract
code: theorem image_fract (s : Set α) : fract '' s = ⋃ m : ℤ, (fun x : α => x - m) '' s ∩ Ico 0 1 
goal: Int.fract '' s = ⋃ m, (fun x => x - ↑m) '' s ∩ Set.Ico 0 1

full_name: Int.fract_div_mul_self_mem_Ico
code: theorem fract_div_mul_self_mem_Ico (a b : k) (ha : 0 < a) : fract (b / a) * a ∈ Ico 0 a 
goal: Int.fract (b / a) * a ∈ Set.Ico 0 a

full_name: Int.fract_div_mul_self_add_zsmul_eq
code: theorem fract_div_mul_self_add_zsmul_eq (a b : k) (ha : a ≠ 0) :
    fract (b / a) * a + ⌊b / a⌋ • a = b 
goal: Int.fract (b / a) * a + ⌊b / a⌋ • a = b

full_name: Int.sub_floor_div_mul_nonneg
code: theorem sub_floor_div_mul_nonneg (a : k) (hb : 0 < b) : 0 ≤ a - ⌊a / b⌋ * b 
goal: 0 ≤ a - ↑⌊a / b⌋ * b

full_name: Int.sub_floor_div_mul_lt
code: theorem sub_floor_div_mul_lt (a : k) (hb : 0 < b) : a - ⌊a / b⌋ * b < b 
goal: a - ↑⌊a / b⌋ * b < b

full_name: Int.fract_div_natCast_eq_div_natCast_mod
code: theorem fract_div_natCast_eq_div_natCast_mod {m n : ℕ} : fract ((m : k) / n) = ↑(m % n) / n 
goal: Int.fract (↑m / ↑n) = ↑(m % n) / ↑n

full_name: Int.fract_div_intCast_eq_div_intCast_mod
code: theorem fract_div_intCast_eq_div_intCast_mod {m : ℤ} {n : ℕ} :
    fract ((m : k) / n) = ↑(m % n) / n 
goal: Int.fract (↑m / ↑n) = ↑(m % ↑n) / ↑n

full_name: Int.gc_ceil_coe
code: theorem gc_ceil_coe : GaloisConnection ceil ((↑) : ℤ → α) 
goal: GaloisConnection Int.ceil Int.cast

full_name: Int.ceil_le
code: theorem ceil_le : ⌈a⌉ ≤ z ↔ a ≤ z 
goal: ⌈a⌉ ≤ z ↔ a ≤ ↑z

full_name: Int.floor_neg
code: theorem floor_neg : ⌊-a⌋ = -⌈a⌉ 
goal: ⌊-a⌋ = -⌈a⌉

full_name: Int.ceil_neg
code: theorem ceil_neg : ⌈-a⌉ = -⌊a⌋ 
goal: ⌈-a⌉ = -⌊a⌋

full_name: Int.lt_ceil
code: theorem lt_ceil : z < ⌈a⌉ ↔ (z : α) < a 
goal: z < ⌈a⌉ ↔ ↑z < a

full_name: Int.add_one_le_ceil_iff
code: @[simp]
theorem add_one_le_ceil_iff : z + 1 ≤ ⌈a⌉ ↔ (z : α) < a 
goal: z + 1 ≤ ⌈a⌉ ↔ ↑z < a

full_name: Int.one_le_ceil_iff
code: @[simp]
theorem one_le_ceil_iff : 1 ≤ ⌈a⌉ ↔ 0 < a 
goal: 1 ≤ ⌈a⌉ ↔ 0 < a

full_name: Int.ceil_le_floor_add_one
code: theorem ceil_le_floor_add_one (a : α) : ⌈a⌉ ≤ ⌊a⌋ + 1 
goal: ⌈a⌉ ≤ ⌊a⌋ + 1

full_name: Int.le_ceil
code: theorem le_ceil (a : α) : a ≤ ⌈a⌉ 
goal: a ≤ ↑⌈a⌉

full_name: Int.ceil_intCast
code: @[simp]
theorem ceil_intCast (z : ℤ) : ⌈(z : α)⌉ = z 
goal: ⌈↑z⌉ = z

full_name: Int.ceil_natCast
code: @[simp]
theorem ceil_natCast (n : ℕ) : ⌈(n : α)⌉ = n 
goal: ⌈↑n⌉ = ↑n

full_name: Int.ceil_ofNat
code: @[simp]
theorem ceil_ofNat (n : ℕ) [n.AtLeastTwo] : ⌈(no_index (OfNat.ofNat n : α))⌉ = n 
goal: ⌈OfNat.ofNat n⌉ = ↑n

full_name: Int.ceil_mono
code: theorem ceil_mono : Monotone (ceil : α → ℤ) 
goal: Monotone Int.ceil

full_name: Int.ceil_le_ceil
code: @[gcongr]
theorem ceil_le_ceil : ∀ x y : α, x ≤ y → ⌈x⌉ ≤ ⌈y⌉ 
goal: x ≤ y → ⌈x⌉ ≤ ⌈y⌉

full_name: Int.ceil_add_int
code: @[simp]
theorem ceil_add_int (a : α) (z : ℤ) : ⌈a + z⌉ = ⌈a⌉ + z 
goal: ⌈a + ↑z⌉ = ⌈a⌉ + z

full_name: Int.ceil_add_nat
code: @[simp]
theorem ceil_add_nat (a : α) (n : ℕ) : ⌈a + n⌉ = ⌈a⌉ + n 
goal: ⌈a + ↑n⌉ = ⌈a⌉ + ↑n

full_name: Int.ceil_add_one
code: @[simp]
theorem ceil_add_one (a : α) : ⌈a + 1⌉ = ⌈a⌉ + 1 
goal: ⌈a + 1⌉ = ⌈a⌉ + 1

full_name: Int.ceil_add_ofNat
code: @[simp]
theorem ceil_add_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌈a + (no_index (OfNat.ofNat n))⌉ = ⌈a⌉ + OfNat.ofNat n 
goal: ⌈a + OfNat.ofNat n⌉ = ⌈a⌉ + OfNat.ofNat n

full_name: Int.ceil_sub_int
code: @[simp]
theorem ceil_sub_int (a : α) (z : ℤ) : ⌈a - z⌉ = ⌈a⌉ - z 
goal: ⌈a - ↑z⌉ = ⌈a⌉ - z

full_name: Int.ceil_sub_nat
code: @[simp]
theorem ceil_sub_nat (a : α) (n : ℕ) : ⌈a - n⌉ = ⌈a⌉ - n 
goal: ⌈a - ↑n⌉ = ⌈a⌉ - ↑n

full_name: Int.ceil_sub_one
code: @[simp]
theorem ceil_sub_one (a : α) : ⌈a - 1⌉ = ⌈a⌉ - 1 
goal: ⌈a - 1⌉ = ⌈a⌉ - 1

full_name: Int.ceil_sub_ofNat
code: @[simp]
theorem ceil_sub_ofNat (a : α) (n : ℕ) [n.AtLeastTwo] :
    ⌈a - (no_index (OfNat.ofNat n))⌉ = ⌈a⌉ - OfNat.ofNat n 
goal: ⌈a - OfNat.ofNat n⌉ = ⌈a⌉ - OfNat.ofNat n

full_name: Int.ceil_lt_add_one
code: theorem ceil_lt_add_one (a : α) : (⌈a⌉ : α) < a + 1 
goal: ↑⌈a⌉ < a + 1

full_name: Int.ceil_add_le
code: theorem ceil_add_le (a b : α) : ⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉ 
goal: ⌈a + b⌉ ≤ ⌈a⌉ + ⌈b⌉

full_name: Int.ceil_add_ceil_le
code: theorem ceil_add_ceil_le (a b : α) : ⌈a⌉ + ⌈b⌉ ≤ ⌈a + b⌉ + 1 
goal: ⌈a⌉ + ⌈b⌉ ≤ ⌈a + b⌉ + 1

full_name: Int.ceil_pos
code: @[simp]
theorem ceil_pos : 0 < ⌈a⌉ ↔ 0 < a 
goal: 0 < ⌈a⌉ ↔ 0 < a

full_name: Int.ceil_zero
code: @[simp]
theorem ceil_zero : ⌈(0 : α)⌉ = 0 
goal: ⌈0⌉ = 0

full_name: Int.ceil_one
code: @[simp]
theorem ceil_one : ⌈(1 : α)⌉ = 1 
goal: ⌈1⌉ = 1

full_name: Int.ceil_nonneg
code: theorem ceil_nonneg (ha : 0 ≤ a) : 0 ≤ ⌈a⌉ 
goal: 0 ≤ ⌈a⌉

full_name: Int.ceil_eq_iff
code: theorem ceil_eq_iff : ⌈a⌉ = z ↔ ↑z - 1 < a ∧ a ≤ z 
goal: ⌈a⌉ = z ↔ ↑z - 1 < a ∧ a ≤ ↑z

full_name: Int.ceil_eq_zero_iff
code: @[simp]
theorem ceil_eq_zero_iff : ⌈a⌉ = 0 ↔ a ∈ Ioc (-1 : α) 0 
goal: ⌈a⌉ = 0 ↔ a ∈ Set.Ioc (-1) 0

full_name: Int.ceil_eq_on_Ioc
code: theorem ceil_eq_on_Ioc (z : ℤ) : ∀ a ∈ Set.Ioc (z - 1 : α) z, ⌈a⌉ = z 
goal: a ∈ Set.Ioc (↑z - 1) ↑z → ⌈a⌉ = z

full_name: Int.ceil_eq_on_Ioc'
code: theorem ceil_eq_on_Ioc' (z : ℤ) : ∀ a ∈ Set.Ioc (z - 1 : α) z, (⌈a⌉ : α) = z 
goal: a ∈ Set.Ioc (↑z - 1) ↑z → ↑⌈a⌉ = ↑z

full_name: Int.floor_le_ceil
code: theorem floor_le_ceil (a : α) : ⌊a⌋ ≤ ⌈a⌉ 
goal: ⌊a⌋ ≤ ⌈a⌉

full_name: Int.floor_lt_ceil_of_lt
code: theorem floor_lt_ceil_of_lt {a b : α} (h : a < b) : ⌊a⌋ < ⌈b⌉ 
goal: ⌊a⌋ < ⌈b⌉

full_name: Int.preimage_ceil_singleton
code: @[simp]
theorem preimage_ceil_singleton (m : ℤ) : (ceil : α → ℤ) ⁻¹' {m} = Ioc ((m : α) - 1) m 
goal: Int.ceil ⁻¹' {m} = Set.Ioc (↑m - 1) ↑m

full_name: Int.fract_eq_zero_or_add_one_sub_ceil
code: theorem fract_eq_zero_or_add_one_sub_ceil (a : α) : fract a = 0 ∨ fract a = a + 1 - (⌈a⌉ : α) 
goal: Int.fract a = 0 ∨ Int.fract a = a + 1 - ↑⌈a⌉

full_name: Int.ceil_eq_add_one_sub_fract
code: theorem ceil_eq_add_one_sub_fract (ha : fract a ≠ 0) : (⌈a⌉ : α) = a + 1 - fract a 
goal: ↑⌈a⌉ = a + 1 - Int.fract a

full_name: Int.ceil_sub_self_eq
code: theorem ceil_sub_self_eq (ha : fract a ≠ 0) : (⌈a⌉ : α) - a = 1 - fract a 
goal: ↑⌈a⌉ - a = 1 - Int.fract a

full_name: Int.preimage_Ioo
code: @[simp]
theorem preimage_Ioo {a b : α} : ((↑) : ℤ → α) ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉ 
goal: Int.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉

full_name: Int.preimage_Ico
code: @[simp]
theorem preimage_Ico {a b : α} : ((↑) : ℤ → α) ⁻¹' Set.Ico a b = Set.Ico ⌈a⌉ ⌈b⌉ 
goal: Int.cast ⁻¹' Set.Ico a b = Set.Ico ⌈a⌉ ⌈b⌉

full_name: Int.preimage_Ioc
code: @[simp]
theorem preimage_Ioc {a b : α} : ((↑) : ℤ → α) ⁻¹' Set.Ioc a b = Set.Ioc ⌊a⌋ ⌊b⌋ 
goal: Int.cast ⁻¹' Set.Ioc a b = Set.Ioc ⌊a⌋ ⌊b⌋

full_name: Int.preimage_Icc
code: @[simp]
theorem preimage_Icc {a b : α} : ((↑) : ℤ → α) ⁻¹' Set.Icc a b = Set.Icc ⌈a⌉ ⌊b⌋ 
goal: Int.cast ⁻¹' Set.Icc a b = Set.Icc ⌈a⌉ ⌊b⌋

full_name: Int.preimage_Ioi
code: @[simp]
theorem preimage_Ioi : ((↑) : ℤ → α) ⁻¹' Set.Ioi a = Set.Ioi ⌊a⌋ 
goal: Int.cast ⁻¹' Set.Ioi a = Set.Ioi ⌊a⌋

full_name: Int.preimage_Ici
code: @[simp]
theorem preimage_Ici : ((↑) : ℤ → α) ⁻¹' Set.Ici a = Set.Ici ⌈a⌉ 
goal: Int.cast ⁻¹' Set.Ici a = Set.Ici ⌈a⌉

full_name: Int.preimage_Iio
code: @[simp]
theorem preimage_Iio : ((↑) : ℤ → α) ⁻¹' Set.Iio a = Set.Iio ⌈a⌉ 
goal: Int.cast ⁻¹' Set.Iio a = Set.Iio ⌈a⌉

full_name: Int.preimage_Iic
code: @[simp]
theorem preimage_Iic : ((↑) : ℤ → α) ⁻¹' Set.Iic a = Set.Iic ⌊a⌋ 
goal: Int.cast ⁻¹' Set.Iic a = Set.Iic ⌊a⌋

full_name: round
code: /-- `round` rounds a number to the nearest integer. `round (1 / 2) = 1` -/
def round (x : α) : ℤ 
goal: ℤ

full_name: round_zero
code: @[simp]
theorem round_zero : round (0 : α) = 0 
goal: round 0 = 0

full_name: round_one
code: @[simp]
theorem round_one : round (1 : α) = 1 
goal: round 1 = 1

full_name: round_natCast
code: @[simp]
theorem round_natCast (n : ℕ) : round (n : α) = n 
goal: round ↑n = ↑n

full_name: round_ofNat
code: @[simp]
theorem round_ofNat (n : ℕ) [n.AtLeastTwo] : round (no_index (OfNat.ofNat n : α)) = n 
goal: round (OfNat.ofNat n) = ↑n

full_name: round_intCast
code: @[simp]
theorem round_intCast (n : ℤ) : round (n : α) = n 
goal: round ↑n = n

full_name: round_add_int
code: @[simp]
theorem round_add_int (x : α) (y : ℤ) : round (x + y) = round x + y 
goal: round (x + ↑y) = round x + y

full_name: round_add_one
code: @[simp]
theorem round_add_one (a : α) : round (a + 1) = round a + 1 
goal: round (a + 1) = round a + 1

full_name: round_sub_int
code: @[simp]
theorem round_sub_int (x : α) (y : ℤ) : round (x - y) = round x - y 
goal: round (x - ↑y) = round x - y

full_name: round_sub_one
code: @[simp]
theorem round_sub_one (a : α) : round (a - 1) = round a - 1 
goal: round (a - 1) = round a - 1

full_name: round_add_nat
code: @[simp]
theorem round_add_nat (x : α) (y : ℕ) : round (x + y) = round x + y 
goal: round (x + ↑y) = round x + ↑y

full_name: round_add_ofNat
code: @[simp]
theorem round_add_ofNat (x : α) (n : ℕ) [n.AtLeastTwo] :
    round (x + (no_index (OfNat.ofNat n))) = round x + OfNat.ofNat n 
goal: round (x + OfNat.ofNat n) = round x + OfNat.ofNat n

full_name: round_sub_nat
code: @[simp]
theorem round_sub_nat (x : α) (y : ℕ) : round (x - y) = round x - y 
goal: round (x - ↑y) = round x - ↑y

full_name: round_sub_ofNat
code: @[simp]
theorem round_sub_ofNat (x : α) (n : ℕ) [n.AtLeastTwo] :
    round (x - (no_index (OfNat.ofNat n))) = round x - OfNat.ofNat n 
goal: round (x - OfNat.ofNat n) = round x - OfNat.ofNat n

full_name: round_int_add
code: @[simp]
theorem round_int_add (x : α) (y : ℤ) : round ((y : α) + x) = y + round x 
goal: round (↑y + x) = y + round x

full_name: round_nat_add
code: @[simp]
theorem round_nat_add (x : α) (y : ℕ) : round ((y : α) + x) = y + round x 
goal: round (↑y + x) = ↑y + round x

full_name: round_ofNat_add
code: @[simp]
theorem round_ofNat_add (n : ℕ) [n.AtLeastTwo] (x : α) :
    round ((no_index (OfNat.ofNat n)) + x) = OfNat.ofNat n + round x 
goal: round (OfNat.ofNat n + x) = OfNat.ofNat n + round x

full_name: abs_sub_round_eq_min
code: theorem abs_sub_round_eq_min (x : α) : |x - round x| = min (fract x) (1 - fract x) 
goal: |x - ↑(round x)| = min (Int.fract x) (1 - Int.fract x)

full_name: round_le
code: theorem round_le (x : α) (z : ℤ) : |x - round x| ≤ |x - z| 
goal: |x - ↑(round x)| ≤ |x - ↑z|

full_name: round_eq
code: theorem round_eq (x : α) : round x = ⌊x + 1 / 2⌋ 
goal: round x = ⌊x + 1 / 2⌋

full_name: round_two_inv
code: @[simp]
theorem round_two_inv : round (2⁻¹ : α) = 1 
goal: round 2⁻¹ = 1

full_name: round_neg_two_inv
code: @[simp]
theorem round_neg_two_inv : round (-2⁻¹ : α) = 0 
goal: round (-2⁻¹) = 0

full_name: round_eq_zero_iff
code: @[simp]
theorem round_eq_zero_iff {x : α} : round x = 0 ↔ x ∈ Ico (-(1 / 2)) ((1 : α) / 2) 
goal: round x = 0 ↔ x ∈ Set.Ico (-(1 / 2)) (1 / 2)

full_name: abs_sub_round
code: theorem abs_sub_round (x : α) : |x - round x| ≤ 1 / 2 
goal: |x - ↑(round x)| ≤ 1 / 2

full_name: abs_sub_round_div_natCast_eq
code: theorem abs_sub_round_div_natCast_eq {m n : ℕ} :
    |(m : α) / n - round ((m : α) / n)| = ↑(min (m % n) (n - m % n)) / n 
goal: |↑m / ↑n - ↑(round (↑m / ↑n))| = ↑(min (m % n) (n - m % n)) / ↑n

full_name: sub_half_lt_round
code: theorem sub_half_lt_round (x : α) : x - 1 / 2 < round x 
goal: x - 1 / 2 < ↑(round x)

full_name: round_le_add_half
code: theorem round_le_add_half (x : α) : round x ≤ x + 1 / 2 
goal: ↑(round x) ≤ x + 1 / 2

full_name: Nat.floor_congr
code: theorem floor_congr (h : ∀ n : ℕ, (n : α) ≤ a ↔ (n : β) ≤ b) : ⌊a⌋₊ = ⌊b⌋₊ 
goal: ⌊a⌋₊ = ⌊b⌋₊

full_name: Nat.ceil_congr
code: theorem ceil_congr (h : ∀ n : ℕ, a ≤ n ↔ b ≤ n) : ⌈a⌉₊ = ⌈b⌉₊ 
goal: ⌈a⌉₊ = ⌈b⌉₊

full_name: Nat.map_floor
code: theorem map_floor (f : F) (hf : StrictMono f) (a : α) : ⌊f a⌋₊ = ⌊a⌋₊ 
goal: ⌊f a⌋₊ = ⌊a⌋₊

full_name: Nat.map_ceil
code: theorem map_ceil (f : F) (hf : StrictMono f) (a : α) : ⌈f a⌉₊ = ⌈a⌉₊ 
goal: ⌈f a⌉₊ = ⌈a⌉₊

full_name: Int.floor_congr
code: theorem floor_congr (h : ∀ n : ℤ, (n : α) ≤ a ↔ (n : β) ≤ b) : ⌊a⌋ = ⌊b⌋ 
goal: ⌊a⌋ = ⌊b⌋

full_name: Int.ceil_congr
code: theorem ceil_congr (h : ∀ n : ℤ, a ≤ n ↔ b ≤ n) : ⌈a⌉ = ⌈b⌉ 
goal: ⌈a⌉ = ⌈b⌉

full_name: Int.map_floor
code: theorem map_floor (f : F) (hf : StrictMono f) (a : α) : ⌊f a⌋ = ⌊a⌋ 
goal: ⌊f a⌋ = ⌊a⌋

full_name: Int.map_ceil
code: theorem map_ceil (f : F) (hf : StrictMono f) (a : α) : ⌈f a⌉ = ⌈a⌉ 
goal: ⌈f a⌉ = ⌈a⌉

full_name: Int.map_fract
code: theorem map_fract (f : F) (hf : StrictMono f) (a : α) : fract (f a) = f (fract a) 
goal: Int.fract (f a) = f (Int.fract a)

full_name: Int.map_round
code: theorem map_round (f : F) (hf : StrictMono f) (a : α) : round (f a) = round a 
goal: round (f a) = round a

full_name: FloorRing.toFloorSemiring
code: instance (priority := 100) FloorRing.toFloorSemiring : FloorSemiring α 
goal: FloorSemiring α

full_name: Int.floor_toNat
code: theorem Int.floor_toNat (a : α) : ⌊a⌋.toNat = ⌊a⌋₊ 
goal: ⌊a⌋.toNat = ⌊a⌋₊

full_name: Int.ceil_toNat
code: theorem Int.ceil_toNat (a : α) : ⌈a⌉.toNat = ⌈a⌉₊ 
goal: ⌈a⌉.toNat = ⌈a⌉₊

full_name: Nat.floor_int
code: @[simp]
theorem Nat.floor_int : (Nat.floor : ℤ → ℕ) = Int.toNat 
goal: Nat.floor = Int.toNat

full_name: Nat.ceil_int
code: @[simp]
theorem Nat.ceil_int : (Nat.ceil : ℤ → ℕ) = Int.toNat 
goal: Nat.ceil = Int.toNat

full_name: Int.ofNat_floor_eq_floor
code: theorem Int.ofNat_floor_eq_floor (ha : 0 ≤ a) : (⌊a⌋₊ : ℤ) = ⌊a⌋ 
goal: ↑⌊a⌋₊ = ⌊a⌋

full_name: Int.ofNat_ceil_eq_ceil
code: theorem Int.ofNat_ceil_eq_ceil (ha : 0 ≤ a) : (⌈a⌉₊ : ℤ) = ⌈a⌉ 
goal: ↑⌈a⌉₊ = ⌈a⌉

full_name: natCast_floor_eq_intCast_floor
code: theorem natCast_floor_eq_intCast_floor (ha : 0 ≤ a) : (⌊a⌋₊ : α) = ⌊a⌋ 
goal: ↑⌊a⌋₊ = ↑⌊a⌋

full_name: natCast_ceil_eq_intCast_ceil
code: theorem natCast_ceil_eq_intCast_ceil  (ha : 0 ≤ a) : (⌈a⌉₊ : α) = ⌈a⌉ 
goal: ↑⌈a⌉₊ = ↑⌈a⌉

full_name: subsingleton_floorRing
code: /-- There exists at most one `FloorRing` structure on a given linear ordered ring. -/
theorem subsingleton_floorRing {α} [LinearOrderedRing α] : Subsingleton (FloorRing α) 
goal: Subsingleton (FloorRing α)

full_name: _private.Mathlib.Algebra.Order.Floor.0.Mathlib.Meta.Positivity.int_floor_nonneg
code: private theorem int_floor_nonneg [LinearOrderedRing α] [FloorRing α] {a : α} (ha : 0 ≤ a) :
    0 ≤ ⌊a⌋ 
goal: 0 ≤ ⌊a⌋

full_name: _private.Mathlib.Algebra.Order.Floor.0.Mathlib.Meta.Positivity.int_floor_nonneg_of_pos
code: private theorem int_floor_nonneg_of_pos [LinearOrderedRing α] [FloorRing α] {a : α}
    (ha : 0 < a) :
    0 ≤ ⌊a⌋ 
goal: 0 ≤ ⌊a⌋

full_name: Mathlib.Meta.Positivity.evalIntFloor
code: /-- Extension for the `positivity` tactic: `Int.floor` is nonnegative if its input is. -/
@[positivity ⌊ _ ⌋]
def evalIntFloor : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Algebra.Order.Floor.0.Mathlib.Meta.Positivity.nat_ceil_pos
code: private theorem nat_ceil_pos [LinearOrderedSemiring α] [FloorSemiring α] {a : α} :
    0 < a → 0 < ⌈a⌉₊ 
goal: 0 < a → 0 < ⌈a⌉₊

full_name: Mathlib.Meta.Positivity.evalNatCeil
code: /-- Extension for the `positivity` tactic: `Nat.ceil` is positive if its input is. -/
@[positivity ⌈ _ ⌉₊]
def evalNatCeil : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Algebra.Order.Floor.0.Mathlib.Meta.Positivity.int_ceil_pos
code: private theorem int_ceil_pos [LinearOrderedRing α] [FloorRing α] {a : α} : 0 < a → 0 < ⌈a⌉ 
goal: 0 < a → 0 < ⌈a⌉

full_name: Mathlib.Meta.Positivity.evalIntCeil
code: /-- Extension for the `positivity` tactic: `Int.ceil` is positive/nonnegative if its input is. -/
@[positivity ⌈ _ ⌉]
def evalIntCeil : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt