File: Mathlib/Algebra/Order/ToIntervalMod.lean

full_name: toIcoDiv
code: /--
The unique integer such that this multiple of `p`, subtracted from `b`, is in `Ico a (a + p)`. -/
def toIcoDiv (a b : α) : ℤ 
goal: ℤ

full_name: sub_toIcoDiv_zsmul_mem_Ico
code: theorem sub_toIcoDiv_zsmul_mem_Ico (a b : α) : b - toIcoDiv hp a b • p ∈ Set.Ico a (a + p) 
goal: b - toIcoDiv hp a b • p ∈ Set.Ico a (a + p)

full_name: toIcoDiv_eq_of_sub_zsmul_mem_Ico
code: theorem toIcoDiv_eq_of_sub_zsmul_mem_Ico (h : b - n • p ∈ Set.Ico a (a + p)) :
    toIcoDiv hp a b = n 
goal: toIcoDiv hp a b = n

full_name: toIocDiv
code: /--
The unique integer such that this multiple of `p`, subtracted from `b`, is in `Ioc a (a + p)`. -/
def toIocDiv (a b : α) : ℤ 
goal: ℤ

full_name: sub_toIocDiv_zsmul_mem_Ioc
code: theorem sub_toIocDiv_zsmul_mem_Ioc (a b : α) : b - toIocDiv hp a b • p ∈ Set.Ioc a (a + p) 
goal: b - toIocDiv hp a b • p ∈ Set.Ioc a (a + p)

full_name: toIocDiv_eq_of_sub_zsmul_mem_Ioc
code: theorem toIocDiv_eq_of_sub_zsmul_mem_Ioc (h : b - n • p ∈ Set.Ioc a (a + p)) :
    toIocDiv hp a b = n 
goal: toIocDiv hp a b = n

full_name: toIcoMod
code: /-- Reduce `b` to the interval `Ico a (a + p)`. -/
def toIcoMod (a b : α) : α 
goal: α

full_name: toIocMod
code: /-- Reduce `b` to the interval `Ioc a (a + p)`. -/
def toIocMod (a b : α) : α 
goal: α

full_name: toIcoMod_mem_Ico
code: theorem toIcoMod_mem_Ico (a b : α) : toIcoMod hp a b ∈ Set.Ico a (a + p) 
goal: toIcoMod hp a b ∈ Set.Ico a (a + p)

full_name: toIcoMod_mem_Ico'
code: theorem toIcoMod_mem_Ico' (b : α) : toIcoMod hp 0 b ∈ Set.Ico 0 p 
goal: toIcoMod hp 0 b ∈ Set.Ico 0 p

full_name: toIocMod_mem_Ioc
code: theorem toIocMod_mem_Ioc (a b : α) : toIocMod hp a b ∈ Set.Ioc a (a + p) 
goal: toIocMod hp a b ∈ Set.Ioc a (a + p)

full_name: left_le_toIcoMod
code: theorem left_le_toIcoMod (a b : α) : a ≤ toIcoMod hp a b 
goal: a ≤ toIcoMod hp a b

full_name: left_lt_toIocMod
code: theorem left_lt_toIocMod (a b : α) : a < toIocMod hp a b 
goal: a < toIocMod hp a b

full_name: toIcoMod_lt_right
code: theorem toIcoMod_lt_right (a b : α) : toIcoMod hp a b < a + p 
goal: toIcoMod hp a b < a + p

full_name: toIocMod_le_right
code: theorem toIocMod_le_right (a b : α) : toIocMod hp a b ≤ a + p 
goal: toIocMod hp a b ≤ a + p

full_name: self_sub_toIcoDiv_zsmul
code: @[simp]
theorem self_sub_toIcoDiv_zsmul (a b : α) : b - toIcoDiv hp a b • p = toIcoMod hp a b 
goal: b - toIcoDiv hp a b • p = toIcoMod hp a b

full_name: self_sub_toIocDiv_zsmul
code: @[simp]
theorem self_sub_toIocDiv_zsmul (a b : α) : b - toIocDiv hp a b • p = toIocMod hp a b 
goal: b - toIocDiv hp a b • p = toIocMod hp a b

full_name: toIcoDiv_zsmul_sub_self
code: @[simp]
theorem toIcoDiv_zsmul_sub_self (a b : α) : toIcoDiv hp a b • p - b = -toIcoMod hp a b 
goal: toIcoDiv hp a b • p - b = -toIcoMod hp a b

full_name: toIocDiv_zsmul_sub_self
code: @[simp]
theorem toIocDiv_zsmul_sub_self (a b : α) : toIocDiv hp a b • p - b = -toIocMod hp a b 
goal: toIocDiv hp a b • p - b = -toIocMod hp a b

full_name: toIcoMod_sub_self
code: @[simp]
theorem toIcoMod_sub_self (a b : α) : toIcoMod hp a b - b = -toIcoDiv hp a b • p 
goal: toIcoMod hp a b - b = -toIcoDiv hp a b • p

full_name: toIocMod_sub_self
code: @[simp]
theorem toIocMod_sub_self (a b : α) : toIocMod hp a b - b = -toIocDiv hp a b • p 
goal: toIocMod hp a b - b = -toIocDiv hp a b • p

full_name: self_sub_toIcoMod
code: @[simp]
theorem self_sub_toIcoMod (a b : α) : b - toIcoMod hp a b = toIcoDiv hp a b • p 
goal: b - toIcoMod hp a b = toIcoDiv hp a b • p

full_name: self_sub_toIocMod
code: @[simp]
theorem self_sub_toIocMod (a b : α) : b - toIocMod hp a b = toIocDiv hp a b • p 
goal: b - toIocMod hp a b = toIocDiv hp a b • p

full_name: toIcoMod_add_toIcoDiv_zsmul
code: @[simp]
theorem toIcoMod_add_toIcoDiv_zsmul (a b : α) : toIcoMod hp a b + toIcoDiv hp a b • p = b 
goal: toIcoMod hp a b + toIcoDiv hp a b • p = b

full_name: toIocMod_add_toIocDiv_zsmul
code: @[simp]
theorem toIocMod_add_toIocDiv_zsmul (a b : α) : toIocMod hp a b + toIocDiv hp a b • p = b 
goal: toIocMod hp a b + toIocDiv hp a b • p = b

full_name: toIcoDiv_zsmul_sub_toIcoMod
code: @[simp]
theorem toIcoDiv_zsmul_sub_toIcoMod (a b : α) : toIcoDiv hp a b • p + toIcoMod hp a b = b 
goal: toIcoDiv hp a b • p + toIcoMod hp a b = b

full_name: toIocDiv_zsmul_sub_toIocMod
code: @[simp]
theorem toIocDiv_zsmul_sub_toIocMod (a b : α) : toIocDiv hp a b • p + toIocMod hp a b = b 
goal: toIocDiv hp a b • p + toIocMod hp a b = b

full_name: toIcoMod_eq_iff
code: theorem toIcoMod_eq_iff : toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z : ℤ, b = c + z • p 
goal: toIcoMod hp a b = c ↔ c ∈ Set.Ico a (a + p) ∧ ∃ z, b = c + z • p

full_name: toIocMod_eq_iff
code: theorem toIocMod_eq_iff : toIocMod hp a b = c ↔ c ∈ Set.Ioc a (a + p) ∧ ∃ z : ℤ, b = c + z • p 
goal: toIocMod hp a b = c ↔ c ∈ Set.Ioc a (a + p) ∧ ∃ z, b = c + z • p

full_name: toIcoDiv_apply_left
code: @[simp]
theorem toIcoDiv_apply_left (a : α) : toIcoDiv hp a a = 0 
goal: toIcoDiv hp a a = 0

full_name: toIocDiv_apply_left
code: @[simp]
theorem toIocDiv_apply_left (a : α) : toIocDiv hp a a = -1 
goal: toIocDiv hp a a = -1

full_name: toIcoMod_apply_left
code: @[simp]
theorem toIcoMod_apply_left (a : α) : toIcoMod hp a a = a 
goal: toIcoMod hp a a = a

full_name: toIocMod_apply_left
code: @[simp]
theorem toIocMod_apply_left (a : α) : toIocMod hp a a = a + p 
goal: toIocMod hp a a = a + p

full_name: toIcoDiv_apply_right
code: theorem toIcoDiv_apply_right (a : α) : toIcoDiv hp a (a + p) = 1 
goal: toIcoDiv hp a (a + p) = 1

full_name: toIocDiv_apply_right
code: theorem toIocDiv_apply_right (a : α) : toIocDiv hp a (a + p) = 0 
goal: toIocDiv hp a (a + p) = 0

full_name: toIcoMod_apply_right
code: theorem toIcoMod_apply_right (a : α) : toIcoMod hp a (a + p) = a 
goal: toIcoMod hp a (a + p) = a

full_name: toIocMod_apply_right
code: theorem toIocMod_apply_right (a : α) : toIocMod hp a (a + p) = a + p 
goal: toIocMod hp a (a + p) = a + p

full_name: toIcoDiv_add_zsmul
code: @[simp]
theorem toIcoDiv_add_zsmul (a b : α) (m : ℤ) : toIcoDiv hp a (b + m • p) = toIcoDiv hp a b + m 
goal: toIcoDiv hp a (b + m • p) = toIcoDiv hp a b + m

full_name: toIcoDiv_add_zsmul'
code: @[simp]
theorem toIcoDiv_add_zsmul' (a b : α) (m : ℤ) :
    toIcoDiv hp (a + m • p) b = toIcoDiv hp a b - m 
goal: toIcoDiv hp (a + m • p) b = toIcoDiv hp a b - m

full_name: toIocDiv_add_zsmul
code: @[simp]
theorem toIocDiv_add_zsmul (a b : α) (m : ℤ) : toIocDiv hp a (b + m • p) = toIocDiv hp a b + m 
goal: toIocDiv hp a (b + m • p) = toIocDiv hp a b + m

full_name: toIocDiv_add_zsmul'
code: @[simp]
theorem toIocDiv_add_zsmul' (a b : α) (m : ℤ) :
    toIocDiv hp (a + m • p) b = toIocDiv hp a b - m 
goal: toIocDiv hp (a + m • p) b = toIocDiv hp a b - m

full_name: toIcoDiv_zsmul_add
code: @[simp]
theorem toIcoDiv_zsmul_add (a b : α) (m : ℤ) : toIcoDiv hp a (m • p + b) = m + toIcoDiv hp a b 
goal: toIcoDiv hp a (m • p + b) = m + toIcoDiv hp a b

full_name: toIocDiv_zsmul_add
code: @[simp]
theorem toIocDiv_zsmul_add (a b : α) (m : ℤ) : toIocDiv hp a (m • p + b) = m + toIocDiv hp a b 
goal: toIocDiv hp a (m • p + b) = m + toIocDiv hp a b

full_name: toIcoDiv_sub_zsmul
code: @[simp]
theorem toIcoDiv_sub_zsmul (a b : α) (m : ℤ) : toIcoDiv hp a (b - m • p) = toIcoDiv hp a b - m 
goal: toIcoDiv hp a (b - m • p) = toIcoDiv hp a b - m

full_name: toIcoDiv_sub_zsmul'
code: @[simp]
theorem toIcoDiv_sub_zsmul' (a b : α) (m : ℤ) :
    toIcoDiv hp (a - m • p) b = toIcoDiv hp a b + m 
goal: toIcoDiv hp (a - m • p) b = toIcoDiv hp a b + m

full_name: toIocDiv_sub_zsmul
code: @[simp]
theorem toIocDiv_sub_zsmul (a b : α) (m : ℤ) : toIocDiv hp a (b - m • p) = toIocDiv hp a b - m 
goal: toIocDiv hp a (b - m • p) = toIocDiv hp a b - m

full_name: toIocDiv_sub_zsmul'
code: @[simp]
theorem toIocDiv_sub_zsmul' (a b : α) (m : ℤ) :
    toIocDiv hp (a - m • p) b = toIocDiv hp a b + m 
goal: toIocDiv hp (a - m • p) b = toIocDiv hp a b + m

full_name: toIcoDiv_add_right
code: @[simp]
theorem toIcoDiv_add_right (a b : α) : toIcoDiv hp a (b + p) = toIcoDiv hp a b + 1 
goal: toIcoDiv hp a (b + p) = toIcoDiv hp a b + 1

full_name: toIcoDiv_add_right'
code: @[simp]
theorem toIcoDiv_add_right' (a b : α) : toIcoDiv hp (a + p) b = toIcoDiv hp a b - 1 
goal: toIcoDiv hp (a + p) b = toIcoDiv hp a b - 1

full_name: toIocDiv_add_right
code: @[simp]
theorem toIocDiv_add_right (a b : α) : toIocDiv hp a (b + p) = toIocDiv hp a b + 1 
goal: toIocDiv hp a (b + p) = toIocDiv hp a b + 1

full_name: toIocDiv_add_right'
code: @[simp]
theorem toIocDiv_add_right' (a b : α) : toIocDiv hp (a + p) b = toIocDiv hp a b - 1 
goal: toIocDiv hp (a + p) b = toIocDiv hp a b - 1

full_name: toIcoDiv_add_left
code: @[simp]
theorem toIcoDiv_add_left (a b : α) : toIcoDiv hp a (p + b) = toIcoDiv hp a b + 1 
goal: toIcoDiv hp a (p + b) = toIcoDiv hp a b + 1

full_name: toIcoDiv_add_left'
code: @[simp]
theorem toIcoDiv_add_left' (a b : α) : toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1 
goal: toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1

full_name: toIocDiv_add_left
code: @[simp]
theorem toIocDiv_add_left (a b : α) : toIocDiv hp a (p + b) = toIocDiv hp a b + 1 
goal: toIocDiv hp a (p + b) = toIocDiv hp a b + 1

full_name: toIocDiv_add_left'
code: @[simp]
theorem toIocDiv_add_left' (a b : α) : toIocDiv hp (p + a) b = toIocDiv hp a b - 1 
goal: toIocDiv hp (p + a) b = toIocDiv hp a b - 1

full_name: toIcoDiv_sub
code: @[simp]
theorem toIcoDiv_sub (a b : α) : toIcoDiv hp a (b - p) = toIcoDiv hp a b - 1 
goal: toIcoDiv hp a (b - p) = toIcoDiv hp a b - 1

full_name: toIcoDiv_sub'
code: @[simp]
theorem toIcoDiv_sub' (a b : α) : toIcoDiv hp (a - p) b = toIcoDiv hp a b + 1 
goal: toIcoDiv hp (a - p) b = toIcoDiv hp a b + 1

full_name: toIocDiv_sub
code: @[simp]
theorem toIocDiv_sub (a b : α) : toIocDiv hp a (b - p) = toIocDiv hp a b - 1 
goal: toIocDiv hp a (b - p) = toIocDiv hp a b - 1

full_name: toIocDiv_sub'
code: @[simp]
theorem toIocDiv_sub' (a b : α) : toIocDiv hp (a - p) b = toIocDiv hp a b + 1 
goal: toIocDiv hp (a - p) b = toIocDiv hp a b + 1

full_name: toIcoDiv_sub_eq_toIcoDiv_add
code: theorem toIcoDiv_sub_eq_toIcoDiv_add (a b c : α) :
    toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b 
goal: toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b

full_name: toIocDiv_sub_eq_toIocDiv_add
code: theorem toIocDiv_sub_eq_toIocDiv_add (a b c : α) :
    toIocDiv hp a (b - c) = toIocDiv hp (a + c) b 
goal: toIocDiv hp a (b - c) = toIocDiv hp (a + c) b

full_name: toIcoDiv_sub_eq_toIcoDiv_add'
code: theorem toIcoDiv_sub_eq_toIcoDiv_add' (a b c : α) :
    toIcoDiv hp (a - c) b = toIcoDiv hp a (b + c) 
goal: toIcoDiv hp (a - c) b = toIcoDiv hp a (b + c)

full_name: toIocDiv_sub_eq_toIocDiv_add'
code: theorem toIocDiv_sub_eq_toIocDiv_add' (a b c : α) :
    toIocDiv hp (a - c) b = toIocDiv hp a (b + c) 
goal: toIocDiv hp (a - c) b = toIocDiv hp a (b + c)

full_name: toIcoDiv_neg
code: theorem toIcoDiv_neg (a b : α) : toIcoDiv hp a (-b) = -(toIocDiv hp (-a) b + 1) 
goal: toIcoDiv hp a (-b) = -(toIocDiv hp (-a) b + 1)

full_name: toIcoDiv_neg'
code: theorem toIcoDiv_neg' (a b : α) : toIcoDiv hp (-a) b = -(toIocDiv hp a (-b) + 1) 
goal: toIcoDiv hp (-a) b = -(toIocDiv hp a (-b) + 1)

full_name: toIocDiv_neg
code: theorem toIocDiv_neg (a b : α) : toIocDiv hp a (-b) = -(toIcoDiv hp (-a) b + 1) 
goal: toIocDiv hp a (-b) = -(toIcoDiv hp (-a) b + 1)

full_name: toIocDiv_neg'
code: theorem toIocDiv_neg' (a b : α) : toIocDiv hp (-a) b = -(toIcoDiv hp a (-b) + 1) 
goal: toIocDiv hp (-a) b = -(toIcoDiv hp a (-b) + 1)

full_name: toIcoMod_add_zsmul
code: @[simp]
theorem toIcoMod_add_zsmul (a b : α) (m : ℤ) : toIcoMod hp a (b + m • p) = toIcoMod hp a b 
goal: toIcoMod hp a (b + m • p) = toIcoMod hp a b

full_name: toIcoMod_add_zsmul'
code: @[simp]
theorem toIcoMod_add_zsmul' (a b : α) (m : ℤ) :
    toIcoMod hp (a + m • p) b = toIcoMod hp a b + m • p 
goal: toIcoMod hp (a + m • p) b = toIcoMod hp a b + m • p

full_name: toIocMod_add_zsmul
code: @[simp]
theorem toIocMod_add_zsmul (a b : α) (m : ℤ) : toIocMod hp a (b + m • p) = toIocMod hp a b 
goal: toIocMod hp a (b + m • p) = toIocMod hp a b

full_name: toIocMod_add_zsmul'
code: @[simp]
theorem toIocMod_add_zsmul' (a b : α) (m : ℤ) :
    toIocMod hp (a + m • p) b = toIocMod hp a b + m • p 
goal: toIocMod hp (a + m • p) b = toIocMod hp a b + m • p

full_name: toIcoMod_zsmul_add
code: @[simp]
theorem toIcoMod_zsmul_add (a b : α) (m : ℤ) : toIcoMod hp a (m • p + b) = toIcoMod hp a b 
goal: toIcoMod hp a (m • p + b) = toIcoMod hp a b

full_name: toIcoMod_zsmul_add'
code: @[simp]
theorem toIcoMod_zsmul_add' (a b : α) (m : ℤ) :
    toIcoMod hp (m • p + a) b = m • p + toIcoMod hp a b 
goal: toIcoMod hp (m • p + a) b = m • p + toIcoMod hp a b

full_name: toIocMod_zsmul_add
code: @[simp]
theorem toIocMod_zsmul_add (a b : α) (m : ℤ) : toIocMod hp a (m • p + b) = toIocMod hp a b 
goal: toIocMod hp a (m • p + b) = toIocMod hp a b

full_name: toIocMod_zsmul_add'
code: @[simp]
theorem toIocMod_zsmul_add' (a b : α) (m : ℤ) :
    toIocMod hp (m • p + a) b = m • p + toIocMod hp a b 
goal: toIocMod hp (m • p + a) b = m • p + toIocMod hp a b

full_name: toIcoMod_sub_zsmul
code: @[simp]
theorem toIcoMod_sub_zsmul (a b : α) (m : ℤ) : toIcoMod hp a (b - m • p) = toIcoMod hp a b 
goal: toIcoMod hp a (b - m • p) = toIcoMod hp a b

full_name: toIcoMod_sub_zsmul'
code: @[simp]
theorem toIcoMod_sub_zsmul' (a b : α) (m : ℤ) :
    toIcoMod hp (a - m • p) b = toIcoMod hp a b - m • p 
goal: toIcoMod hp (a - m • p) b = toIcoMod hp a b - m • p

full_name: toIocMod_sub_zsmul
code: @[simp]
theorem toIocMod_sub_zsmul (a b : α) (m : ℤ) : toIocMod hp a (b - m • p) = toIocMod hp a b 
goal: toIocMod hp a (b - m • p) = toIocMod hp a b

full_name: toIocMod_sub_zsmul'
code: @[simp]
theorem toIocMod_sub_zsmul' (a b : α) (m : ℤ) :
    toIocMod hp (a - m • p) b = toIocMod hp a b - m • p 
goal: toIocMod hp (a - m • p) b = toIocMod hp a b - m • p

full_name: toIcoMod_add_right
code: @[simp]
theorem toIcoMod_add_right (a b : α) : toIcoMod hp a (b + p) = toIcoMod hp a b 
goal: toIcoMod hp a (b + p) = toIcoMod hp a b

full_name: toIcoMod_add_right'
code: @[simp]
theorem toIcoMod_add_right' (a b : α) : toIcoMod hp (a + p) b = toIcoMod hp a b + p 
goal: toIcoMod hp (a + p) b = toIcoMod hp a b + p

full_name: toIocMod_add_right
code: @[simp]
theorem toIocMod_add_right (a b : α) : toIocMod hp a (b + p) = toIocMod hp a b 
goal: toIocMod hp a (b + p) = toIocMod hp a b

full_name: toIocMod_add_right'
code: @[simp]
theorem toIocMod_add_right' (a b : α) : toIocMod hp (a + p) b = toIocMod hp a b + p 
goal: toIocMod hp (a + p) b = toIocMod hp a b + p

full_name: toIcoMod_add_left
code: @[simp]
theorem toIcoMod_add_left (a b : α) : toIcoMod hp a (p + b) = toIcoMod hp a b 
goal: toIcoMod hp a (p + b) = toIcoMod hp a b

full_name: toIcoMod_add_left'
code: @[simp]
theorem toIcoMod_add_left' (a b : α) : toIcoMod hp (p + a) b = p + toIcoMod hp a b 
goal: toIcoMod hp (p + a) b = p + toIcoMod hp a b

full_name: toIocMod_add_left
code: @[simp]
theorem toIocMod_add_left (a b : α) : toIocMod hp a (p + b) = toIocMod hp a b 
goal: toIocMod hp a (p + b) = toIocMod hp a b

full_name: toIocMod_add_left'
code: @[simp]
theorem toIocMod_add_left' (a b : α) : toIocMod hp (p + a) b = p + toIocMod hp a b 
goal: toIocMod hp (p + a) b = p + toIocMod hp a b

full_name: toIcoMod_sub
code: @[simp]
theorem toIcoMod_sub (a b : α) : toIcoMod hp a (b - p) = toIcoMod hp a b 
goal: toIcoMod hp a (b - p) = toIcoMod hp a b

full_name: toIcoMod_sub'
code: @[simp]
theorem toIcoMod_sub' (a b : α) : toIcoMod hp (a - p) b = toIcoMod hp a b - p 
goal: toIcoMod hp (a - p) b = toIcoMod hp a b - p

full_name: toIocMod_sub
code: @[simp]
theorem toIocMod_sub (a b : α) : toIocMod hp a (b - p) = toIocMod hp a b 
goal: toIocMod hp a (b - p) = toIocMod hp a b

full_name: toIocMod_sub'
code: @[simp]
theorem toIocMod_sub' (a b : α) : toIocMod hp (a - p) b = toIocMod hp a b - p 
goal: toIocMod hp (a - p) b = toIocMod hp a b - p

full_name: toIcoMod_sub_eq_sub
code: theorem toIcoMod_sub_eq_sub (a b c : α) : toIcoMod hp a (b - c) = toIcoMod hp (a + c) b - c 
goal: toIcoMod hp a (b - c) = toIcoMod hp (a + c) b - c

full_name: toIocMod_sub_eq_sub
code: theorem toIocMod_sub_eq_sub (a b c : α) : toIocMod hp a (b - c) = toIocMod hp (a + c) b - c 
goal: toIocMod hp a (b - c) = toIocMod hp (a + c) b - c

full_name: toIcoMod_add_right_eq_add
code: theorem toIcoMod_add_right_eq_add (a b c : α) :
    toIcoMod hp a (b + c) = toIcoMod hp (a - c) b + c 
goal: toIcoMod hp a (b + c) = toIcoMod hp (a - c) b + c

full_name: toIocMod_add_right_eq_add
code: theorem toIocMod_add_right_eq_add (a b c : α) :
    toIocMod hp a (b + c) = toIocMod hp (a - c) b + c 
goal: toIocMod hp a (b + c) = toIocMod hp (a - c) b + c

full_name: toIcoMod_neg
code: theorem toIcoMod_neg (a b : α) : toIcoMod hp a (-b) = p - toIocMod hp (-a) b 
goal: toIcoMod hp a (-b) = p - toIocMod hp (-a) b

full_name: toIcoMod_neg'
code: theorem toIcoMod_neg' (a b : α) : toIcoMod hp (-a) b = p - toIocMod hp a (-b) 
goal: toIcoMod hp (-a) b = p - toIocMod hp a (-b)

full_name: toIocMod_neg
code: theorem toIocMod_neg (a b : α) : toIocMod hp a (-b) = p - toIcoMod hp (-a) b 
goal: toIocMod hp a (-b) = p - toIcoMod hp (-a) b

full_name: toIocMod_neg'
code: theorem toIocMod_neg' (a b : α) : toIocMod hp (-a) b = p - toIcoMod hp a (-b) 
goal: toIocMod hp (-a) b = p - toIcoMod hp a (-b)

full_name: toIcoMod_eq_toIcoMod
code: theorem toIcoMod_eq_toIcoMod : toIcoMod hp a b = toIcoMod hp a c ↔ ∃ n : ℤ, c - b = n • p 
goal: toIcoMod hp a b = toIcoMod hp a c ↔ ∃ n, c - b = n • p

full_name: toIocMod_eq_toIocMod
code: theorem toIocMod_eq_toIocMod : toIocMod hp a b = toIocMod hp a c ↔ ∃ n : ℤ, c - b = n • p 
goal: toIocMod hp a b = toIocMod hp a c ↔ ∃ n, c - b = n • p

full_name: AddCommGroup.modEq_iff_toIcoMod_eq_left
code: theorem modEq_iff_toIcoMod_eq_left : a ≡ b [PMOD p] ↔ toIcoMod hp a b = a 
goal: a ≡ b [PMOD p] ↔ toIcoMod hp a b = a

full_name: AddCommGroup.modEq_iff_toIocMod_eq_right
code: theorem modEq_iff_toIocMod_eq_right : a ≡ b [PMOD p] ↔ toIocMod hp a b = a + p 
goal: a ≡ b [PMOD p] ↔ toIocMod hp a b = a + p

full_name: AddCommGroup.tfae_modEq
code: theorem tfae_modEq :
    TFAE
      [a ≡ b [PMOD p], ∀ z : ℤ, b - z • p ∉ Set.Ioo a (a + p), toIcoMod hp a b ≠ toIocMod hp a b,
        toIcoMod hp a b + p = toIocMod hp a b] 
goal: [a ≡ b [PMOD p], ∀ (z : ℤ), b - z • p ∉ Set.Ioo a (a + p), toIcoMod hp a b ≠ toIocMod hp a b,
    toIcoMod hp a b + p = toIocMod hp a b].TFAE

full_name: AddCommGroup.modEq_iff_not_forall_mem_Ioo_mod
code: theorem modEq_iff_not_forall_mem_Ioo_mod :
    a ≡ b [PMOD p] ↔ ∀ z : ℤ, b - z • p ∉ Set.Ioo a (a + p) 
goal: a ≡ b [PMOD p] ↔ ∀ (z : ℤ), b - z • p ∉ Set.Ioo a (a + p)

full_name: AddCommGroup.modEq_iff_toIcoMod_ne_toIocMod
code: theorem modEq_iff_toIcoMod_ne_toIocMod : a ≡ b [PMOD p] ↔ toIcoMod hp a b ≠ toIocMod hp a b 
goal: a ≡ b [PMOD p] ↔ toIcoMod hp a b ≠ toIocMod hp a b

full_name: AddCommGroup.modEq_iff_toIcoMod_add_period_eq_toIocMod
code: theorem modEq_iff_toIcoMod_add_period_eq_toIocMod :
    a ≡ b [PMOD p] ↔ toIcoMod hp a b + p = toIocMod hp a b 
goal: a ≡ b [PMOD p] ↔ toIcoMod hp a b + p = toIocMod hp a b

full_name: AddCommGroup.not_modEq_iff_toIcoMod_eq_toIocMod
code: theorem not_modEq_iff_toIcoMod_eq_toIocMod : ¬a ≡ b [PMOD p] ↔ toIcoMod hp a b = toIocMod hp a b 
goal: ¬a ≡ b [PMOD p] ↔ toIcoMod hp a b = toIocMod hp a b

full_name: AddCommGroup.not_modEq_iff_toIcoDiv_eq_toIocDiv
code: theorem not_modEq_iff_toIcoDiv_eq_toIocDiv :
    ¬a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b 
goal: ¬a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b

full_name: AddCommGroup.modEq_iff_toIcoDiv_eq_toIocDiv_add_one
code: theorem modEq_iff_toIcoDiv_eq_toIocDiv_add_one :
    a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1 
goal: a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1

full_name: toIcoMod_inj
code: /-- If `a` and `b` fall within the same cycle WRT `c`, then they are congruent modulo `p`. -/
@[simp]
theorem toIcoMod_inj {c : α} : toIcoMod hp c a = toIcoMod hp c b ↔ a ≡ b [PMOD p] 
goal: toIcoMod hp c a = toIcoMod hp c b ↔ a ≡ b [PMOD p]

full_name: Ico_eq_locus_Ioc_eq_iUnion_Ioo
code: theorem Ico_eq_locus_Ioc_eq_iUnion_Ioo :
    { b | toIcoMod hp a b = toIocMod hp a b } = ⋃ z : ℤ, Set.Ioo (a + z • p) (a + p + z • p) 
goal: {b | toIcoMod hp a b = toIocMod hp a b} = ⋃ z, Set.Ioo (a + z • p) (a + p + z • p)

full_name: toIocDiv_wcovBy_toIcoDiv
code: theorem toIocDiv_wcovBy_toIcoDiv (a b : α) : toIocDiv hp a b ⩿ toIcoDiv hp a b 
goal: toIocDiv hp a b ⩿ toIcoDiv hp a b

full_name: toIcoMod_le_toIocMod
code: theorem toIcoMod_le_toIocMod (a b : α) : toIcoMod hp a b ≤ toIocMod hp a b 
goal: toIcoMod hp a b ≤ toIocMod hp a b

full_name: toIocMod_le_toIcoMod_add
code: theorem toIocMod_le_toIcoMod_add (a b : α) : toIocMod hp a b ≤ toIcoMod hp a b + p 
goal: toIocMod hp a b ≤ toIcoMod hp a b + p

full_name: toIcoMod_eq_self
code: theorem toIcoMod_eq_self : toIcoMod hp a b = b ↔ b ∈ Set.Ico a (a + p) 
goal: toIcoMod hp a b = b ↔ b ∈ Set.Ico a (a + p)

full_name: toIocMod_eq_self
code: theorem toIocMod_eq_self : toIocMod hp a b = b ↔ b ∈ Set.Ioc a (a + p) 
goal: toIocMod hp a b = b ↔ b ∈ Set.Ioc a (a + p)

full_name: toIcoMod_toIcoMod
code: @[simp]
theorem toIcoMod_toIcoMod (a₁ a₂ b : α) : toIcoMod hp a₁ (toIcoMod hp a₂ b) = toIcoMod hp a₁ b 
goal: toIcoMod hp a₁ (toIcoMod hp a₂ b) = toIcoMod hp a₁ b

full_name: toIcoMod_toIocMod
code: @[simp]
theorem toIcoMod_toIocMod (a₁ a₂ b : α) : toIcoMod hp a₁ (toIocMod hp a₂ b) = toIcoMod hp a₁ b 
goal: toIcoMod hp a₁ (toIocMod hp a₂ b) = toIcoMod hp a₁ b

full_name: toIocMod_toIocMod
code: @[simp]
theorem toIocMod_toIocMod (a₁ a₂ b : α) : toIocMod hp a₁ (toIocMod hp a₂ b) = toIocMod hp a₁ b 
goal: toIocMod hp a₁ (toIocMod hp a₂ b) = toIocMod hp a₁ b

full_name: toIocMod_toIcoMod
code: @[simp]
theorem toIocMod_toIcoMod (a₁ a₂ b : α) : toIocMod hp a₁ (toIcoMod hp a₂ b) = toIocMod hp a₁ b 
goal: toIocMod hp a₁ (toIcoMod hp a₂ b) = toIocMod hp a₁ b

full_name: toIcoMod_periodic
code: theorem toIcoMod_periodic (a : α) : Function.Periodic (toIcoMod hp a) p 
goal: Function.Periodic (toIcoMod hp a) p

full_name: toIocMod_periodic
code: theorem toIocMod_periodic (a : α) : Function.Periodic (toIocMod hp a) p 
goal: Function.Periodic (toIocMod hp a) p

full_name: toIcoMod_zero_sub_comm
code: theorem toIcoMod_zero_sub_comm (a b : α) : toIcoMod hp 0 (a - b) = p - toIocMod hp 0 (b - a) 
goal: toIcoMod hp 0 (a - b) = p - toIocMod hp 0 (b - a)

full_name: toIocMod_zero_sub_comm
code: theorem toIocMod_zero_sub_comm (a b : α) : toIocMod hp 0 (a - b) = p - toIcoMod hp 0 (b - a) 
goal: toIocMod hp 0 (a - b) = p - toIcoMod hp 0 (b - a)

full_name: toIcoDiv_eq_sub
code: theorem toIcoDiv_eq_sub (a b : α) : toIcoDiv hp a b = toIcoDiv hp 0 (b - a) 
goal: toIcoDiv hp a b = toIcoDiv hp 0 (b - a)

full_name: toIocDiv_eq_sub
code: theorem toIocDiv_eq_sub (a b : α) : toIocDiv hp a b = toIocDiv hp 0 (b - a) 
goal: toIocDiv hp a b = toIocDiv hp 0 (b - a)

full_name: toIcoMod_eq_sub
code: theorem toIcoMod_eq_sub (a b : α) : toIcoMod hp a b = toIcoMod hp 0 (b - a) + a 
goal: toIcoMod hp a b = toIcoMod hp 0 (b - a) + a

full_name: toIocMod_eq_sub
code: theorem toIocMod_eq_sub (a b : α) : toIocMod hp a b = toIocMod hp 0 (b - a) + a 
goal: toIocMod hp a b = toIocMod hp 0 (b - a) + a

full_name: toIcoMod_add_toIocMod_zero
code: theorem toIcoMod_add_toIocMod_zero (a b : α) :
    toIcoMod hp 0 (a - b) + toIocMod hp 0 (b - a) = p 
goal: toIcoMod hp 0 (a - b) + toIocMod hp 0 (b - a) = p

full_name: toIocMod_add_toIcoMod_zero
code: theorem toIocMod_add_toIcoMod_zero (a b : α) :
    toIocMod hp 0 (a - b) + toIcoMod hp 0 (b - a) = p 
goal: toIocMod hp 0 (a - b) + toIcoMod hp 0 (b - a) = p

full_name: QuotientAddGroup.equivIcoMod
code: /-- `toIcoMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIcoMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ico a (a + p) 
goal: α ⧸ AddSubgroup.zmultiples p ≃ ↑(Set.Ico a (a + p))

full_name: QuotientAddGroup.equivIcoMod_symm_apply
code: /-- `toIcoMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIcoMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ico a (a + p) 
goal: (QuotientAddGroup.equivIcoMod hp a).symm x = ↑↑x

full_name: QuotientAddGroup.equivIcoMod_coe
code: @[simp]
theorem QuotientAddGroup.equivIcoMod_coe (a b : α) :
    QuotientAddGroup.equivIcoMod hp a ↑b = ⟨toIcoMod hp a b, toIcoMod_mem_Ico hp a _⟩ 
goal: (QuotientAddGroup.equivIcoMod hp a) ↑b = ⟨toIcoMod hp a b, ⋯⟩

full_name: QuotientAddGroup.equivIcoMod_zero
code: @[simp]
theorem QuotientAddGroup.equivIcoMod_zero (a : α) :
    QuotientAddGroup.equivIcoMod hp a 0 = ⟨toIcoMod hp a 0, toIcoMod_mem_Ico hp a _⟩ 
goal: (QuotientAddGroup.equivIcoMod hp a) 0 = ⟨toIcoMod hp a 0, ⋯⟩

full_name: QuotientAddGroup.equivIocMod
code: /-- `toIocMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIocMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ioc a (a + p) 
goal: α ⧸ AddSubgroup.zmultiples p ≃ ↑(Set.Ioc a (a + p))

full_name: QuotientAddGroup.equivIocMod_symm_apply
code: /-- `toIocMod` as an equiv from the quotient. -/
@[simps symm_apply]
def QuotientAddGroup.equivIocMod (a : α) : α ⧸ AddSubgroup.zmultiples p ≃ Set.Ioc a (a + p) 
goal: (QuotientAddGroup.equivIocMod hp a).symm x = ↑↑x

full_name: QuotientAddGroup.equivIocMod_coe
code: @[simp]
theorem QuotientAddGroup.equivIocMod_coe (a b : α) :
    QuotientAddGroup.equivIocMod hp a ↑b = ⟨toIocMod hp a b, toIocMod_mem_Ioc hp a _⟩ 
goal: (QuotientAddGroup.equivIocMod hp a) ↑b = ⟨toIocMod hp a b, ⋯⟩

full_name: QuotientAddGroup.equivIocMod_zero
code: @[simp]
theorem QuotientAddGroup.equivIocMod_zero (a : α) :
    QuotientAddGroup.equivIocMod hp a 0 = ⟨toIocMod hp a 0, toIocMod_mem_Ioc hp a _⟩ 
goal: (QuotientAddGroup.equivIocMod hp a) 0 = ⟨toIocMod hp a 0, ⋯⟩

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_iff
code: private theorem toIxxMod_iff (x₁ x₂ x₃ : α) : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ↔
    toIcoMod hp 0 (x₂ - x₁) + toIcoMod hp 0 (x₁ - x₃) ≤ p 
goal: toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ↔ toIcoMod hp 0 (x₂ - x₁) + toIcoMod hp 0 (x₁ - x₃) ≤ p

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_cyclic_left
code: private theorem toIxxMod_cyclic_left {x₁ x₂ x₃ : α} (h : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃) :
    toIcoMod hp x₂ x₃ ≤ toIocMod hp x₂ x₁ 
goal: toIcoMod hp x₂ x₃ ≤ toIocMod hp x₂ x₁

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_antisymm
code: private theorem toIxxMod_antisymm (h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c)
    (h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b) :
    b ≡ a [PMOD p] ∨ c ≡ b [PMOD p] ∨ a ≡ c [PMOD p] 
goal: b ≡ a [PMOD p] ∨ c ≡ b [PMOD p] ∨ a ≡ c [PMOD p]

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_total'
code: private theorem toIxxMod_total' (a b c : α) :
    toIcoMod hp b a ≤ toIocMod hp b c ∨ toIcoMod hp b c ≤ toIocMod hp b a 
goal: toIcoMod hp b a ≤ toIocMod hp b c ∨ toIcoMod hp b c ≤ toIocMod hp b a

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_total
code: private theorem toIxxMod_total (a b c : α) :
    toIcoMod hp a b ≤ toIocMod hp a c ∨ toIcoMod hp c b ≤ toIocMod hp c a 
goal: toIcoMod hp a b ≤ toIocMod hp a c ∨ toIcoMod hp c b ≤ toIocMod hp c a

full_name: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_trans
code: private theorem toIxxMod_trans {x₁ x₂ x₃ x₄ : α}
    (h₁₂₃ : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₂ ≤ toIocMod hp x₃ x₁)
    (h₂₃₄ : toIcoMod hp x₂ x₄ ≤ toIocMod hp x₂ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₂) :
    toIcoMod hp x₁ x₄ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₁ 
goal: toIcoMod hp x₁ x₄ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₁

full_name: QuotientAddGroup.instBtwQuotientAddSubgroupZmultiples
code: instance : Btw (α ⧸ AddSubgroup.zmultiples p) 
goal: Btw (α ⧸ AddSubgroup.zmultiples p)

full_name: QuotientAddGroup.btw_coe_iff'
code: theorem btw_coe_iff' {x₁ x₂ x₃ : α} :
    Btw.btw (x₁ : α ⧸ AddSubgroup.zmultiples p) x₂ x₃ ↔
      toIcoMod hp'.out 0 (x₂ - x₁) ≤ toIocMod hp'.out 0 (x₃ - x₁) 
goal: btw ↑x₁ ↑x₂ ↑x₃ ↔ toIcoMod ⋯ 0 (x₂ - x₁) ≤ toIocMod ⋯ 0 (x₃ - x₁)

full_name: QuotientAddGroup.btw_coe_iff
code: theorem btw_coe_iff {x₁ x₂ x₃ : α} :
    Btw.btw (x₁ : α ⧸ AddSubgroup.zmultiples p) x₂ x₃ ↔
      toIcoMod hp'.out x₁ x₂ ≤ toIocMod hp'.out x₁ x₃ 
goal: btw ↑x₁ ↑x₂ ↑x₃ ↔ toIcoMod ⋯ x₁ x₂ ≤ toIocMod ⋯ x₁ x₃

full_name: QuotientAddGroup.circularPreorder
code: instance circularPreorder : CircularPreorder (α ⧸ AddSubgroup.zmultiples p) 
goal: CircularPreorder (α ⧸ AddSubgroup.zmultiples p)

full_name: QuotientAddGroup.circularOrder
code: instance circularOrder : CircularOrder (α ⧸ AddSubgroup.zmultiples p) 
goal: CircularOrder (α ⧸ AddSubgroup.zmultiples p)

full_name: toIcoDiv_eq_floor
code: theorem toIcoDiv_eq_floor (a b : α) : toIcoDiv hp a b = ⌊(b - a) / p⌋ 
goal: toIcoDiv hp a b = ⌊(b - a) / p⌋

full_name: toIocDiv_eq_neg_floor
code: theorem toIocDiv_eq_neg_floor (a b : α) : toIocDiv hp a b = -⌊(a + p - b) / p⌋ 
goal: toIocDiv hp a b = -⌊(a + p - b) / p⌋

full_name: toIcoDiv_zero_one
code: theorem toIcoDiv_zero_one (b : α) : toIcoDiv (zero_lt_one' α) 0 b = ⌊b⌋ 
goal: toIcoDiv ⋯ 0 b = ⌊b⌋

full_name: toIcoMod_eq_add_fract_mul
code: theorem toIcoMod_eq_add_fract_mul (a b : α) :
    toIcoMod hp a b = a + Int.fract ((b - a) / p) * p 
goal: toIcoMod hp a b = a + Int.fract ((b - a) / p) * p

full_name: toIcoMod_eq_fract_mul
code: theorem toIcoMod_eq_fract_mul (b : α) : toIcoMod hp 0 b = Int.fract (b / p) * p 
goal: toIcoMod hp 0 b = Int.fract (b / p) * p

full_name: toIocMod_eq_sub_fract_mul
code: theorem toIocMod_eq_sub_fract_mul (a b : α) :
    toIocMod hp a b = a + p - Int.fract ((a + p - b) / p) * p 
goal: toIocMod hp a b = a + p - Int.fract ((a + p - b) / p) * p

full_name: toIcoMod_zero_one
code: theorem toIcoMod_zero_one (b : α) : toIcoMod (zero_lt_one' α) 0 b = Int.fract b 
goal: toIcoMod ⋯ 0 b = Int.fract b

full_name: iUnion_Ioc_add_zsmul
code: theorem iUnion_Ioc_add_zsmul : ⋃ n : ℤ, Ioc (a + n • p) (a + (n + 1) • p) = univ 
goal: ⋃ n, Set.Ioc (a + n • p) (a + (n + 1) • p) = Set.univ

full_name: iUnion_Ico_add_zsmul
code: theorem iUnion_Ico_add_zsmul : ⋃ n : ℤ, Ico (a + n • p) (a + (n + 1) • p) = univ 
goal: ⋃ n, Set.Ico (a + n • p) (a + (n + 1) • p) = Set.univ

full_name: iUnion_Icc_add_zsmul
code: theorem iUnion_Icc_add_zsmul : ⋃ n : ℤ, Icc (a + n • p) (a + (n + 1) • p) = univ 
goal: ⋃ n, Set.Icc (a + n • p) (a + (n + 1) • p) = Set.univ

full_name: iUnion_Ioc_zsmul
code: theorem iUnion_Ioc_zsmul : ⋃ n : ℤ, Ioc (n • p) ((n + 1) • p) = univ 
goal: ⋃ n, Set.Ioc (n • p) ((n + 1) • p) = Set.univ

full_name: iUnion_Ico_zsmul
code: theorem iUnion_Ico_zsmul : ⋃ n : ℤ, Ico (n • p) ((n + 1) • p) = univ 
goal: ⋃ n, Set.Ico (n • p) ((n + 1) • p) = Set.univ

full_name: iUnion_Icc_zsmul
code: theorem iUnion_Icc_zsmul : ⋃ n : ℤ, Icc (n • p) ((n + 1) • p) = univ 
goal: ⋃ n, Set.Icc (n • p) ((n + 1) • p) = Set.univ

full_name: iUnion_Ioc_add_intCast
code: theorem iUnion_Ioc_add_intCast : ⋃ n : ℤ, Ioc (a + n) (a + n + 1) = Set.univ 
goal: ⋃ n, Set.Ioc (a + ↑n) (a + ↑n + 1) = Set.univ

full_name: iUnion_Ico_add_intCast
code: theorem iUnion_Ico_add_intCast : ⋃ n : ℤ, Ico (a + n) (a + n + 1) = Set.univ 
goal: ⋃ n, Set.Ico (a + ↑n) (a + ↑n + 1) = Set.univ

full_name: iUnion_Icc_add_intCast
code: theorem iUnion_Icc_add_intCast : ⋃ n : ℤ, Icc (a + n) (a + n + 1) = Set.univ 
goal: ⋃ n, Set.Icc (a + ↑n) (a + ↑n + 1) = Set.univ

full_name: iUnion_Ioc_intCast
code: theorem iUnion_Ioc_intCast : ⋃ n : ℤ, Ioc (n : α) (n + 1) = Set.univ 
goal: ⋃ n, Set.Ioc (↑n) (↑n + 1) = Set.univ

full_name: iUnion_Ico_intCast
code: theorem iUnion_Ico_intCast : ⋃ n : ℤ, Ico (n : α) (n + 1) = Set.univ 
goal: ⋃ n, Set.Ico (↑n) (↑n + 1) = Set.univ

full_name: iUnion_Icc_intCast
code: theorem iUnion_Icc_intCast : ⋃ n : ℤ, Icc (n : α) (n + 1) = Set.univ 
goal: ⋃ n, Set.Icc (↑n) (↑n + 1) = Set.univ