File: Mathlib/Data/Num/Lemmas.lean

full_name: PosNum.cast_one
code: @[simp, norm_cast]
theorem cast_one [One α] [Add α] : ((1 : PosNum) : α) = 1 
goal: ↑1 = 1

full_name: PosNum.cast_one'
code: @[simp]
theorem cast_one' [One α] [Add α] : (PosNum.one : α) = 1 
goal: ↑PosNum.one = 1

full_name: PosNum.cast_bit0
code: @[simp, norm_cast]
theorem cast_bit0 [One α] [Add α] (n : PosNum) : (n.bit0 : α) = (n : α) + n 
goal: ↑n.bit0 = ↑n + ↑n

full_name: PosNum.cast_bit1
code: @[simp, norm_cast]
theorem cast_bit1 [One α] [Add α] (n : PosNum) : (n.bit1 : α) = ((n : α) + n) + 1 
goal: ↑n.bit1 = ↑n + ↑n + 1

full_name: PosNum.cast_to_nat
code: @[simp, norm_cast]
theorem cast_to_nat [AddMonoidWithOne α] : ∀ n : PosNum, ((n : ℕ) : α) = n
  
goal: ↑↑n = ↑n

full_name: PosNum.to_nat_to_int
code: @[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : PosNum) : ((n : ℕ) : ℤ) = n 
goal: ↑↑n = ↑n

full_name: PosNum.cast_to_int
code: @[simp, norm_cast]
theorem cast_to_int [AddGroupWithOne α] (n : PosNum) : ((n : ℤ) : α) = n 
goal: ↑↑n = ↑n

full_name: PosNum.succ_to_nat
code: theorem succ_to_nat : ∀ n, (succ n : ℕ) = n + 1
  
goal: ↑n.succ = ↑n + 1

full_name: PosNum.one_add
code: theorem one_add (n : PosNum) : 1 + n = succ n 
goal: 1 + n = n.succ

full_name: PosNum.add_one
code: theorem add_one (n : PosNum) : n + 1 = succ n 
goal: n + 1 = n.succ

full_name: PosNum.add_to_nat
code: @[norm_cast]
theorem add_to_nat : ∀ m n, ((m + n : PosNum) : ℕ) = m + n
  
goal: ↑(m + n) = ↑m + ↑n

full_name: PosNum.add_succ
code: theorem add_succ : ∀ m n : PosNum, m + succ n = succ (m + n)
  
goal: m + n.succ = (m + n).succ

full_name: PosNum.bit0_of_bit0
code: theorem bit0_of_bit0 : ∀ n, n + n = bit0 n
  
goal: n + n = n.bit0

full_name: PosNum.bit1_of_bit1
code: theorem bit1_of_bit1 (n : PosNum) : (n + n) + 1 = bit1 n 
goal: n + n + 1 = n.bit1

full_name: PosNum.mul_to_nat
code: @[norm_cast]
theorem mul_to_nat (m) : ∀ n, ((m * n : PosNum) : ℕ) = m * n
  
goal: ↑(m * n) = ↑m * ↑n

full_name: PosNum.to_nat_pos
code: theorem to_nat_pos : ∀ n : PosNum, 0 < (n : ℕ)
  
goal: 0 < ↑n

full_name: PosNum.cmp_to_nat_lemma
code: theorem cmp_to_nat_lemma {m n : PosNum} : (m : ℕ) < n → (bit1 m : ℕ) < bit0 n 
goal: ↑m < ↑n → ↑m.bit1 < ↑n.bit0

full_name: PosNum.cmp_swap
code: theorem cmp_swap (m) : ∀ n, (cmp m n).swap = cmp n m 
goal: (m.cmp n).swap = n.cmp m

full_name: PosNum.cmp_to_nat
code: theorem cmp_to_nat : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℕ) < n) (m = n) ((n : ℕ) < m) : Prop)
  
goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)

full_name: PosNum.lt_to_nat
code: @[norm_cast]
theorem lt_to_nat {m n : PosNum} : (m : ℕ) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: PosNum.le_to_nat
code: @[norm_cast]
theorem le_to_nat {m n : PosNum} : (m : ℕ) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Num.add_zero
code: theorem add_zero (n : Num) : n + 0 = n 
goal: n + 0 = n

full_name: Num.zero_add
code: theorem zero_add (n : Num) : 0 + n = n 
goal: 0 + n = n

full_name: Num.add_one
code: theorem add_one : ∀ n : Num, n + 1 = succ n
  
goal: n + 1 = n.succ

full_name: Num.add_succ
code: theorem add_succ : ∀ m n : Num, m + succ n = succ (m + n)
  
goal: m + n.succ = (m + n).succ

full_name: Num.bit0_of_bit0
code: theorem bit0_of_bit0 : ∀ n : Num, n + n = n.bit0
  
goal: n + n = n.bit0

full_name: Num.bit1_of_bit1
code: theorem bit1_of_bit1 : ∀ n : Num, (n + n) + 1 = n.bit1
  
goal: n + n + 1 = n.bit1

full_name: Num.ofNat'_zero
code: @[simp]
theorem ofNat'_zero : Num.ofNat' 0 = 0 
goal: Num.ofNat' 0 = 0

full_name: Num.ofNat'_bit
code: theorem ofNat'_bit (b n) : ofNat' (Nat.bit b n) = cond b Num.bit1 Num.bit0 (ofNat' n) 
goal: Num.ofNat' (Nat.bit b n) = (bif b then Num.bit1 else Num.bit0) (Num.ofNat' n)

full_name: Num.ofNat'_one
code: @[simp]
theorem ofNat'_one : Num.ofNat' 1 = 1 
goal: Num.ofNat' 1 = 1

full_name: Num.bit1_succ
code: theorem bit1_succ : ∀ n : Num, n.bit1.succ = n.succ.bit0
  
goal: n.bit1.succ = n.succ.bit0

full_name: Num.ofNat'_succ
code: theorem ofNat'_succ : ∀ {n}, ofNat' (n + 1) = ofNat' n + 1 
goal: Num.ofNat' (n + 1) = Num.ofNat' n + 1

full_name: Num.add_ofNat'
code: @[simp]
theorem add_ofNat' (m n) : Num.ofNat' (m + n) = Num.ofNat' m + Num.ofNat' n 
goal: Num.ofNat' (m + n) = Num.ofNat' m + Num.ofNat' n

full_name: Num.cast_zero
code: @[simp, norm_cast]
theorem cast_zero [Zero α] [One α] [Add α] : ((0 : Num) : α) = 0 
goal: ↑0 = 0

full_name: Num.cast_zero'
code: @[simp]
theorem cast_zero' [Zero α] [One α] [Add α] : (Num.zero : α) = 0 
goal: ↑Num.zero = 0

full_name: Num.cast_one
code: @[simp, norm_cast]
theorem cast_one [Zero α] [One α] [Add α] : ((1 : Num) : α) = 1 
goal: ↑1 = 1

full_name: Num.cast_pos
code: @[simp]
theorem cast_pos [Zero α] [One α] [Add α] (n : PosNum) : (Num.pos n : α) = n 
goal: ↑(Num.pos n) = ↑n

full_name: Num.succ'_to_nat
code: theorem succ'_to_nat : ∀ n, (succ' n : ℕ) = n + 1
  
goal: ↑n.succ' = ↑n + 1

full_name: Num.succ_to_nat
code: theorem succ_to_nat (n) : (succ n : ℕ) = n + 1 
goal: ↑n.succ = ↑n + 1

full_name: Num.cast_to_nat
code: @[simp, norm_cast]
theorem cast_to_nat [AddMonoidWithOne α] : ∀ n : Num, ((n : ℕ) : α) = n
  
goal: ↑↑n = ↑n

full_name: Num.add_to_nat
code: @[norm_cast]
theorem add_to_nat : ∀ m n, ((m + n : Num) : ℕ) = m + n
  
goal: ↑(m + n) = ↑m + ↑n

full_name: Num.mul_to_nat
code: @[norm_cast]
theorem mul_to_nat : ∀ m n, ((m * n : Num) : ℕ) = m * n
  
goal: ↑(m * n) = ↑m * ↑n

full_name: Num.cmp_to_nat
code: theorem cmp_to_nat : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℕ) < n) (m = n) ((n : ℕ) < m) : Prop)
  
goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)

full_name: Num.lt_to_nat
code: @[norm_cast]
theorem lt_to_nat {m n : Num} : (m : ℕ) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: Num.le_to_nat
code: @[norm_cast]
theorem le_to_nat {m n : Num} : (m : ℕ) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: PosNum.of_to_nat'
code: @[simp]
theorem of_to_nat' : ∀ n : PosNum, Num.ofNat' (n : ℕ) = Num.pos n
  
goal: Num.ofNat' ↑n = Num.pos n

full_name: Num.of_to_nat'
code: @[simp, norm_cast]
theorem of_to_nat' : ∀ n : Num, Num.ofNat' (n : ℕ) = n
  
goal: Num.ofNat' ↑n = n

full_name: Num.toNat_injective
code: lemma toNat_injective : Injective (castNum : Num → ℕ) 
goal: Function.Injective castNum

full_name: Num.to_nat_inj
code: @[norm_cast]
theorem to_nat_inj {m n : Num} : (m : ℕ) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Num.transfer_rw
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_nat_inj] | rw [← lt_to_nat] | rw [← le_to_nat]
     repeat first | rw [add_to_nat] | rw [mul_to_nat] | rw [cast_one] | rw [cast_zero]))
goal: Lean.ParserDescr

full_name: Num._aux_Mathlib_Data_Num_Lemmas___macroRules_Num_transfer_rw_1
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_nat_inj] | rw [← lt_to_nat] | rw [← le_to_nat]
     repeat first | rw [add_to_nat] | rw [mul_to_nat] | rw [cast_one] | rw [cast_zero]))
goal: Lean.Macro

full_name: Num.transfer
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp))
goal: Lean.ParserDescr

full_name: Num._aux_Mathlib_Data_Num_Lemmas___macroRules_Num_transfer_1
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp))
goal: Lean.Macro

full_name: Num.addMonoid
code: instance addMonoid : AddMonoid Num 
goal: AddMonoid Num

full_name: Num.addMonoidWithOne
code: instance addMonoidWithOne : AddMonoidWithOne Num 
goal: AddMonoidWithOne Num

full_name: Num.commSemiring
code: instance commSemiring : CommSemiring Num 
goal: CommSemiring Num

full_name: Num.orderedCancelAddCommMonoid
code: instance orderedCancelAddCommMonoid : OrderedCancelAddCommMonoid Num 
goal: OrderedCancelAddCommMonoid Num

full_name: Num.linearOrderedSemiring
code: instance linearOrderedSemiring : LinearOrderedSemiring Num 
goal: LinearOrderedSemiring Num

full_name: Num.add_of_nat
code: @[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem add_of_nat (m n) : ((m + n : ℕ) : Num) = m + n 
goal: ↑(m + n) = ↑m + ↑n

full_name: Num.to_nat_to_int
code: @[norm_cast]  -- @[simp] -- Porting note (#10618): simp can prove this
theorem to_nat_to_int (n : Num) : ((n : ℕ) : ℤ) = n 
goal: ↑↑n = ↑n

full_name: Num.cast_to_int
code: @[simp, norm_cast]
theorem cast_to_int {α} [AddGroupWithOne α] (n : Num) : ((n : ℤ) : α) = n 
goal: ↑↑n = ↑n

full_name: Num.to_of_nat
code: theorem to_of_nat : ∀ n : ℕ, ((n : Num) : ℕ) = n
  
goal: ↑↑n = n

full_name: Num.of_natCast
code: @[simp, norm_cast]
theorem of_natCast {α} [AddMonoidWithOne α] (n : ℕ) : ((n : Num) : α) = n 
goal: ↑↑n = ↑n

full_name: Num.of_nat_inj
code: @[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem of_nat_inj {m n : ℕ} : (m : Num) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Num.of_to_nat
code: @[simp high, norm_cast]
theorem of_to_nat : ∀ n : Num, ((n : ℕ) : Num) = n 
goal: ↑↑n = n

full_name: Num.dvd_to_nat
code: @[norm_cast]
theorem dvd_to_nat (m n : Num) : (m : ℕ) ∣ n ↔ m ∣ n 
goal: ↑m ∣ ↑n ↔ m ∣ n

full_name: PosNum.of_to_nat
code: @[simp high, norm_cast]
theorem of_to_nat : ∀ n : PosNum, ((n : ℕ) : Num) = Num.pos n 
goal: ↑↑n = Num.pos n

full_name: PosNum.to_nat_inj
code: @[norm_cast]
theorem to_nat_inj {m n : PosNum} : (m : ℕ) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: PosNum.pred'_to_nat
code: theorem pred'_to_nat : ∀ n, (pred' n : ℕ) = Nat.pred n
  
goal: ↑n.pred' = (↑n).pred

full_name: PosNum.pred'_succ'
code: @[simp]
theorem pred'_succ' (n) : pred' (succ' n) = n 
goal: n.succ'.pred' = n

full_name: PosNum.succ'_pred'
code: @[simp]
theorem succ'_pred' (n) : succ' (pred' n) = n 
goal: n.pred'.succ' = n

full_name: PosNum.dvd
code: instance dvd : Dvd PosNum 
goal: Dvd PosNum

full_name: PosNum.dvd_to_nat
code: @[norm_cast]
theorem dvd_to_nat {m n : PosNum} : (m : ℕ) ∣ n ↔ m ∣ n 
goal: ↑m ∣ ↑n ↔ m ∣ n

full_name: PosNum.size_to_nat
code: theorem size_to_nat : ∀ n, (size n : ℕ) = Nat.size n
  
goal: ↑n.size = (↑n).size

full_name: PosNum.size_eq_natSize
code: theorem size_eq_natSize : ∀ n, (size n : ℕ) = natSize n
  
goal: ↑n.size = n.natSize

full_name: PosNum.natSize_to_nat
code: theorem natSize_to_nat (n) : natSize n = Nat.size n 
goal: n.natSize = (↑n).size

full_name: PosNum.natSize_pos
code: theorem natSize_pos (n) : 0 < natSize n 
goal: 0 < n.natSize

full_name: PosNum._aux_Mathlib_Data_Num_Lemmas___macroRules_PosNum_transfer_rw_1
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_nat_inj] | rw [← lt_to_nat] | rw [← le_to_nat]
     repeat first | rw [add_to_nat] | rw [mul_to_nat] | rw [cast_one] | rw [cast_zero]))
goal: Lean.Macro

full_name: PosNum.transfer_rw
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_nat_inj] | rw [← lt_to_nat] | rw [← le_to_nat]
     repeat first | rw [add_to_nat] | rw [mul_to_nat] | rw [cast_one] | rw [cast_zero]))
goal: Lean.ParserDescr

full_name: PosNum.transfer
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp [add_comm, add_left_comm, mul_comm, mul_left_comm]))
goal: Lean.ParserDescr

full_name: PosNum._aux_Mathlib_Data_Num_Lemmas___macroRules_PosNum_transfer_1
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp [add_comm, add_left_comm, mul_comm, mul_left_comm]))
goal: Lean.Macro

full_name: PosNum.addCommSemigroup
code: instance addCommSemigroup : AddCommSemigroup PosNum 
goal: AddCommSemigroup PosNum

full_name: PosNum.commMonoid
code: instance commMonoid : CommMonoid PosNum 
goal: CommMonoid PosNum

full_name: PosNum.distrib
code: instance distrib : Distrib PosNum 
goal: Distrib PosNum

full_name: PosNum.linearOrder
code: instance linearOrder : LinearOrder PosNum 
goal: LinearOrder PosNum

full_name: PosNum.cast_to_num
code: @[simp]
theorem cast_to_num (n : PosNum) : ↑n = Num.pos n 
goal: ↑n = Num.pos n

full_name: PosNum.bit_to_nat
code: @[simp, norm_cast]
theorem bit_to_nat (b n) : (bit b n : ℕ) = Nat.bit b n 
goal: ↑(PosNum.bit b n) = Nat.bit b ↑n

full_name: PosNum.cast_add
code: @[simp, norm_cast]
theorem cast_add [AddMonoidWithOne α] (m n) : ((m + n : PosNum) : α) = m + n 
goal: ↑(m + n) = ↑m + ↑n

full_name: PosNum.cast_succ
code: @[simp 500, norm_cast]
theorem cast_succ [AddMonoidWithOne α] (n : PosNum) : (succ n : α) = n + 1 
goal: ↑n.succ = ↑n + 1

full_name: PosNum.cast_inj
code: @[simp, norm_cast]
theorem cast_inj [AddMonoidWithOne α] [CharZero α] {m n : PosNum} : (m : α) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: PosNum.one_le_cast
code: @[simp]
theorem one_le_cast [LinearOrderedSemiring α] (n : PosNum) : (1 : α) ≤ n 
goal: 1 ≤ ↑n

full_name: PosNum.cast_pos
code: @[simp]
theorem cast_pos [LinearOrderedSemiring α] (n : PosNum) : 0 < (n : α) 
goal: 0 < ↑n

full_name: PosNum.cast_mul
code: @[simp, norm_cast]
theorem cast_mul [Semiring α] (m n) : ((m * n : PosNum) : α) = m * n 
goal: ↑(m * n) = ↑m * ↑n

full_name: PosNum.cmp_eq
code: @[simp]
theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n 
goal: m.cmp n = Ordering.eq ↔ m = n

full_name: PosNum.cast_lt
code: @[simp, norm_cast]
theorem cast_lt [LinearOrderedSemiring α] {m n : PosNum} : (m : α) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: PosNum.cast_le
code: @[simp, norm_cast]
theorem cast_le [LinearOrderedSemiring α] {m n : PosNum} : (m : α) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Num.bit_to_nat
code: theorem bit_to_nat (b n) : (bit b n : ℕ) = Nat.bit b n 
goal: ↑(Num.bit b n) = Nat.bit b ↑n

full_name: Num.cast_succ'
code: theorem cast_succ' [AddMonoidWithOne α] (n) : (succ' n : α) = n + 1 
goal: ↑n.succ' = ↑n + 1

full_name: Num.cast_succ
code: theorem cast_succ [AddMonoidWithOne α] (n) : (succ n : α) = n + 1 
goal: ↑n.succ = ↑n + 1

full_name: Num.cast_add
code: @[simp, norm_cast]
theorem cast_add [Semiring α] (m n) : ((m + n : Num) : α) = m + n 
goal: ↑(m + n) = ↑m + ↑n

full_name: Num.cast_bit0
code: @[simp, norm_cast]
theorem cast_bit0 [Semiring α] (n : Num) : (n.bit0 : α) = 2 * (n : α) 
goal: ↑n.bit0 = 2 * ↑n

full_name: Num.cast_bit1
code: @[simp, norm_cast]
theorem cast_bit1 [Semiring α] (n : Num) : (n.bit1 : α) = 2 * (n : α) + 1 
goal: ↑n.bit1 = 2 * ↑n + 1

full_name: Num.cast_mul
code: @[simp, norm_cast]
theorem cast_mul [Semiring α] : ∀ m n, ((m * n : Num) : α) = m * n
  
goal: ↑(m * n) = ↑m * ↑n

full_name: Num.size_to_nat
code: theorem size_to_nat : ∀ n, (size n : ℕ) = Nat.size n
  
goal: ↑n.size = (↑n).size

full_name: Num.size_eq_natSize
code: theorem size_eq_natSize : ∀ n, (size n : ℕ) = natSize n
  
goal: ↑n.size = n.natSize

full_name: Num.natSize_to_nat
code: theorem natSize_to_nat (n) : natSize n = Nat.size n 
goal: n.natSize = (↑n).size

full_name: Num.ofNat'_eq
code: @[simp 999]
theorem ofNat'_eq : ∀ n, Num.ofNat' n = n 
goal: Num.ofNat' n = ↑n

full_name: Num.zneg_toZNum
code: theorem zneg_toZNum (n : Num) : -n.toZNum = n.toZNumNeg 
goal: -n.toZNum = n.toZNumNeg

full_name: Num.zneg_toZNumNeg
code: theorem zneg_toZNumNeg (n : Num) : -n.toZNumNeg = n.toZNum 
goal: -n.toZNumNeg = n.toZNum

full_name: Num.toZNum_inj
code: theorem toZNum_inj {m n : Num} : m.toZNum = n.toZNum ↔ m = n 
goal: m.toZNum = n.toZNum ↔ m = n

full_name: Num.cast_toZNum
code: @[simp]
theorem cast_toZNum [Zero α] [One α] [Add α] [Neg α] : ∀ n : Num, (n.toZNum : α) = n
  
goal: ↑n.toZNum = ↑n

full_name: Num.cast_toZNumNeg
code: @[simp]
theorem cast_toZNumNeg [AddGroup α] [One α] : ∀ n : Num, (n.toZNumNeg : α) = -n
  
goal: ↑n.toZNumNeg = -↑n

full_name: Num.add_toZNum
code: @[simp]
theorem add_toZNum (m n : Num) : Num.toZNum (m + n) = m.toZNum + n.toZNum 
goal: (m + n).toZNum = m.toZNum + n.toZNum

full_name: PosNum.pred_to_nat
code: theorem pred_to_nat {n : PosNum} (h : 1 < n) : (pred n : ℕ) = Nat.pred n 
goal: ↑n.pred = (↑n).pred

full_name: PosNum.sub'_one
code: theorem sub'_one (a : PosNum) : sub' a 1 = (pred' a).toZNum 
goal: a.sub' 1 = a.pred'.toZNum

full_name: PosNum.one_sub'
code: theorem one_sub' (a : PosNum) : sub' 1 a = (pred' a).toZNumNeg 
goal: PosNum.sub' 1 a = a.pred'.toZNumNeg

full_name: PosNum.lt_iff_cmp
code: theorem lt_iff_cmp {m n} : m < n ↔ cmp m n = Ordering.lt 
goal: m < n ↔ m.cmp n = Ordering.lt

full_name: PosNum.le_iff_cmp
code: theorem le_iff_cmp {m n} : m ≤ n ↔ cmp m n ≠ Ordering.gt 
goal: m ≤ n ↔ m.cmp n ≠ Ordering.gt

full_name: Num.pred_to_nat
code: theorem pred_to_nat : ∀ n : Num, (pred n : ℕ) = Nat.pred n
  
goal: ↑n.pred = (↑n).pred

full_name: Num.ppred_to_nat
code: theorem ppred_to_nat : ∀ n : Num, (↑) <$> ppred n = Nat.ppred n
  
goal: castNum <$> n.ppred = (↑n).ppred

full_name: Num.cmp_swap
code: theorem cmp_swap (m n) : (cmp m n).swap = cmp n m 
goal: (m.cmp n).swap = n.cmp m

full_name: Num.cmp_eq
code: theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n 
goal: m.cmp n = Ordering.eq ↔ m = n

full_name: Num.cast_lt
code: @[simp, norm_cast]
theorem cast_lt [LinearOrderedSemiring α] {m n : Num} : (m : α) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: Num.cast_le
code: @[simp, norm_cast]
theorem cast_le [LinearOrderedSemiring α] {m n : Num} : (m : α) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Num.cast_inj
code: @[simp, norm_cast]
theorem cast_inj [LinearOrderedSemiring α] {m n : Num} : (m : α) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Num.lt_iff_cmp
code: theorem lt_iff_cmp {m n} : m < n ↔ cmp m n = Ordering.lt 
goal: m < n ↔ m.cmp n = Ordering.lt

full_name: Num.le_iff_cmp
code: theorem le_iff_cmp {m n} : m ≤ n ↔ cmp m n ≠ Ordering.gt 
goal: m ≤ n ↔ m.cmp n ≠ Ordering.gt

full_name: Num.castNum_eq_bitwise
code: theorem castNum_eq_bitwise {f : Num → Num → Num} {g : Bool → Bool → Bool}
    (p : PosNum → PosNum → Num)
    (gff : g false false = false) (f00 : f 0 0 = 0)
    (f0n : ∀ n, f 0 (pos n) = cond (g false true) (pos n) 0)
    (fn0 : ∀ n, f (pos n) 0 = cond (g true false) (pos n) 0)
    (fnn : ∀ m n, f (pos m) (pos n) = p m n) (p11 : p 1 1 = cond (g true true) 1 0)
    (p1b : ∀ b n, p 1 (PosNum.bit b n) = bit (g true b) (cond (g false true) (pos n) 0))
    (pb1 : ∀ a m, p (PosNum.bit a m) 1 = bit (g a true) (cond (g true false) (pos m) 0))
    (pbb : ∀ a b m n, p (PosNum.bit a m) (PosNum.bit b n) = bit (g a b) (p m n)) :
    ∀ m n : Num, (f m n : ℕ) = Nat.bitwise g m n 
goal: ↑(f m n) = Nat.bitwise g ↑m ↑n

full_name: Num.castNum_or
code: @[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) 
goal: ↑(m ||| n) = ↑m ||| ↑n

full_name: Num.castNum_and
code: @[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) 
goal: ↑(m &&& n) = ↑m &&& ↑n

full_name: Num.castNum_ldiff
code: @[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n 
goal: ↑(m.ldiff n) = (↑m).ldiff ↑n

full_name: Num.castNum_xor
code: @[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) 
goal: ↑(m ^^^ n) = ↑m ^^^ ↑n

full_name: Num.castNum_shiftLeft
code: @[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) 
goal: ↑(m <<< n) = ↑m <<< n

full_name: Num.castNum_shiftRight
code: @[simp, norm_cast]
theorem castNum_shiftRight (m : Num) (n : Nat) : ↑(m >>> n) = (m : ℕ) >>> (n : ℕ) 
goal: ↑(m >>> n) = ↑m >>> n

full_name: Num.castNum_testBit
code: @[simp]
theorem castNum_testBit (m n) : testBit m n = Nat.testBit m n 
goal: m.testBit n = (↑m).testBit n

full_name: ZNum.cast_zero
code: @[simp, norm_cast]
theorem cast_zero [Zero α] [One α] [Add α] [Neg α] : ((0 : ZNum) : α) = 0 
goal: ↑0 = 0

full_name: ZNum.cast_zero'
code: @[simp]
theorem cast_zero' [Zero α] [One α] [Add α] [Neg α] : (ZNum.zero : α) = 0 
goal: ↑ZNum.zero = 0

full_name: ZNum.cast_one
code: @[simp, norm_cast]
theorem cast_one [Zero α] [One α] [Add α] [Neg α] : ((1 : ZNum) : α) = 1 
goal: ↑1 = 1

full_name: ZNum.cast_pos
code: @[simp]
theorem cast_pos [Zero α] [One α] [Add α] [Neg α] (n : PosNum) : (pos n : α) = n 
goal: ↑(ZNum.pos n) = ↑n

full_name: ZNum.cast_neg
code: @[simp]
theorem cast_neg [Zero α] [One α] [Add α] [Neg α] (n : PosNum) : (neg n : α) = -n 
goal: ↑(ZNum.neg n) = -↑n

full_name: ZNum.cast_zneg
code: @[simp, norm_cast]
theorem cast_zneg [AddGroup α] [One α] : ∀ n, ((-n : ZNum) : α) = -n
  
goal: ↑(-n) = -↑n

full_name: ZNum.neg_zero
code: theorem neg_zero : (-0 : ZNum) = 0 
goal: -0 = 0

full_name: ZNum.zneg_pos
code: theorem zneg_pos (n : PosNum) : -pos n = neg n 
goal: -ZNum.pos n = ZNum.neg n

full_name: ZNum.zneg_neg
code: theorem zneg_neg (n : PosNum) : -neg n = pos n 
goal: -ZNum.neg n = ZNum.pos n

full_name: ZNum.zneg_zneg
code: theorem zneg_zneg (n : ZNum) : - -n = n 
goal: - -n = n

full_name: ZNum.zneg_bit1
code: theorem zneg_bit1 (n : ZNum) : -n.bit1 = (-n).bitm1 
goal: -n.bit1 = (-n).bitm1

full_name: ZNum.zneg_bitm1
code: theorem zneg_bitm1 (n : ZNum) : -n.bitm1 = (-n).bit1 
goal: -n.bitm1 = (-n).bit1

full_name: ZNum.zneg_succ
code: theorem zneg_succ (n : ZNum) : -n.succ = (-n).pred 
goal: -n.succ = (-n).pred

full_name: ZNum.zneg_pred
code: theorem zneg_pred (n : ZNum) : -n.pred = (-n).succ 
goal: -n.pred = (-n).succ

full_name: ZNum.abs_to_nat
code: @[simp]
theorem abs_to_nat : ∀ n, (abs n : ℕ) = Int.natAbs n
  
goal: ↑n.abs = (↑n).natAbs

full_name: ZNum.abs_toZNum
code: @[simp]
theorem abs_toZNum : ∀ n : Num, abs n.toZNum = n
  
goal: n.toZNum.abs = n

full_name: ZNum.cast_to_int
code: @[simp, norm_cast]
theorem cast_to_int [AddGroupWithOne α] : ∀ n : ZNum, ((n : ℤ) : α) = n
  
goal: ↑↑n = ↑n

full_name: ZNum.bit0_of_bit0
code: theorem bit0_of_bit0 : ∀ n : ZNum, n + n = n.bit0
  
goal: n + n = n.bit0

full_name: ZNum.bit1_of_bit1
code: theorem bit1_of_bit1 : ∀ n : ZNum, n + n + 1 = n.bit1
  
goal: n + n + 1 = n.bit1

full_name: ZNum.cast_bit0
code: @[simp, norm_cast]
theorem cast_bit0 [AddGroupWithOne α] : ∀ n : ZNum, (n.bit0 : α) = (n : α) + n
  
goal: ↑n.bit0 = ↑n + ↑n

full_name: ZNum.cast_bit1
code: @[simp, norm_cast]
theorem cast_bit1 [AddGroupWithOne α] : ∀ n : ZNum, (n.bit1 : α) = ((n : α) + n) + 1
  
goal: ↑n.bit1 = ↑n + ↑n + 1

full_name: ZNum.cast_bitm1
code: @[simp]
theorem cast_bitm1 [AddGroupWithOne α] (n : ZNum) : (n.bitm1 : α) = (n : α) + n - 1 
goal: ↑n.bitm1 = ↑n + ↑n - 1

full_name: ZNum.add_zero
code: theorem add_zero (n : ZNum) : n + 0 = n 
goal: n + 0 = n

full_name: ZNum.zero_add
code: theorem zero_add (n : ZNum) : 0 + n = n 
goal: 0 + n = n

full_name: ZNum.add_one
code: theorem add_one : ∀ n : ZNum, n + 1 = succ n
  
goal: n + 1 = n.succ

full_name: PosNum.cast_to_znum
code: theorem cast_to_znum : ∀ n : PosNum, (n : ZNum) = ZNum.pos n
  
goal: ↑n = ZNum.pos n

full_name: PosNum.cast_sub'
code: theorem cast_sub' [AddGroupWithOne α] : ∀ m n : PosNum, (sub' m n : α) = m - n
  
goal: ↑(m.sub' n) = ↑m - ↑n

full_name: PosNum.to_nat_eq_succ_pred
code: theorem to_nat_eq_succ_pred (n : PosNum) : (n : ℕ) = n.pred' + 1 
goal: ↑n = ↑n.pred' + 1

full_name: PosNum.to_int_eq_succ_pred
code: theorem to_int_eq_succ_pred (n : PosNum) : (n : ℤ) = (n.pred' : ℕ) + 1 
goal: ↑n = ↑↑n.pred' + 1

full_name: Num.cast_sub'
code: @[simp]
theorem cast_sub' [AddGroupWithOne α] : ∀ m n : Num, (sub' m n : α) = m - n
  
goal: ↑(m.sub' n) = ↑m - ↑n

full_name: Num.toZNum_succ
code: theorem toZNum_succ : ∀ n : Num, n.succ.toZNum = n.toZNum.succ
  
goal: n.succ.toZNum = n.toZNum.succ

full_name: Num.toZNumNeg_succ
code: theorem toZNumNeg_succ : ∀ n : Num, n.succ.toZNumNeg = n.toZNumNeg.pred
  
goal: n.succ.toZNumNeg = n.toZNumNeg.pred

full_name: Num.pred_succ
code: @[simp]
theorem pred_succ : ∀ n : ZNum, n.pred.succ = n
  
goal: n.pred.succ = n

full_name: Num.succ_ofInt'
code: theorem succ_ofInt' : ∀ n, ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1
  
goal: ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1

full_name: Num.ofInt'_toZNum
code: theorem ofInt'_toZNum : ∀ n : ℕ, toZNum n = ZNum.ofInt' n
  
goal: (↑n).toZNum = ZNum.ofInt' ↑n

full_name: Num.mem_ofZNum'
code: theorem mem_ofZNum' : ∀ {m : Num} {n : ZNum}, m ∈ ofZNum' n ↔ n = toZNum m
  
goal: m ∈ Num.ofZNum' n ↔ n = m.toZNum

full_name: Num.ofZNum'_toNat
code: theorem ofZNum'_toNat : ∀ n : ZNum, (↑) <$> ofZNum' n = Int.toNat' n
  
goal: castNum <$> Num.ofZNum' n = (↑n).toNat'

full_name: Num.ofZNum_toNat
code: @[simp]
theorem ofZNum_toNat : ∀ n : ZNum, (ofZNum n : ℕ) = Int.toNat n
  
goal: ↑(Num.ofZNum n) = (↑n).toNat

full_name: Num.cast_ofZNum
code: @[simp]
theorem cast_ofZNum [AddGroupWithOne α] (n : ZNum) : (ofZNum n : α) = Int.toNat n 
goal: ↑(Num.ofZNum n) = ↑(↑n).toNat

full_name: Num.sub_to_nat
code: @[simp, norm_cast]
theorem sub_to_nat (m n) : ((m - n : Num) : ℕ) = m - n 
goal: ↑(m - n) = ↑m - ↑n

full_name: ZNum.cast_add
code: @[simp, norm_cast]
theorem cast_add [AddGroupWithOne α] : ∀ m n, ((m + n : ZNum) : α) = m + n
  
goal: ↑(m + n) = ↑m + ↑n

full_name: ZNum.cast_succ
code: @[simp]
theorem cast_succ [AddGroupWithOne α] (n) : ((succ n : ZNum) : α) = n + 1 
goal: ↑n.succ = ↑n + 1

full_name: ZNum.mul_to_int
code: @[simp, norm_cast]
theorem mul_to_int : ∀ m n, ((m * n : ZNum) : ℤ) = m * n
  
goal: ↑(m * n) = ↑m * ↑n

full_name: ZNum.cast_mul
code: theorem cast_mul [Ring α] (m n) : ((m * n : ZNum) : α) = m * n 
goal: ↑(m * n) = ↑m * ↑n

full_name: ZNum.ofInt'_neg
code: theorem ofInt'_neg : ∀ n : ℤ, ofInt' (-n) = -ofInt' n
  
goal: ZNum.ofInt' (-n) = -ZNum.ofInt' n

full_name: ZNum.of_to_int'
code: theorem of_to_int' : ∀ n : ZNum, ZNum.ofInt' n = n
  
goal: ZNum.ofInt' ↑n = n

full_name: ZNum.to_int_inj
code: theorem to_int_inj {m n : ZNum} : (m : ℤ) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: ZNum.cmp_to_int
code: theorem cmp_to_int : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℤ) < n) (m = n) ((n : ℤ) < m) : Prop)
  
goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)

full_name: ZNum.lt_to_int
code: @[norm_cast]
theorem lt_to_int {m n : ZNum} : (m : ℤ) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: ZNum.le_to_int
code: theorem le_to_int {m n : ZNum} : (m : ℤ) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: ZNum.cast_lt
code: @[simp, norm_cast]
theorem cast_lt [LinearOrderedRing α] {m n : ZNum} : (m : α) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: ZNum.cast_le
code: @[simp, norm_cast]
theorem cast_le [LinearOrderedRing α] {m n : ZNum} : (m : α) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: ZNum.cast_inj
code: @[simp, norm_cast]
theorem cast_inj [LinearOrderedRing α] {m n : ZNum} : (m : α) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: ZNum._aux_Mathlib_Data_Num_Lemmas___macroRules_ZNum_transfer_rw_1
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_int_inj] | rw [← lt_to_int] | rw [← le_to_int]
     repeat first | rw [cast_add] | rw [mul_to_int] | rw [cast_one] | rw [cast_zero]))
goal: Lean.Macro

full_name: ZNum.transfer_rw
code: macro (name := transfer_rw) "transfer_rw" : tactic => `(tactic|
    (repeat first | rw [← to_int_inj] | rw [← lt_to_int] | rw [← le_to_int]
     repeat first | rw [cast_add] | rw [mul_to_int] | rw [cast_one] | rw [cast_zero]))
goal: Lean.ParserDescr

full_name: ZNum._aux_Mathlib_Data_Num_Lemmas___macroRules_ZNum_transfer_1
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp [add_comm, add_left_comm, mul_comm, mul_left_comm]))
goal: Lean.Macro

full_name: ZNum.transfer
code: macro (name := transfer) "transfer" : tactic => `(tactic|
    (intros; transfer_rw; try simp [add_comm, add_left_comm, mul_comm, mul_left_comm]))
goal: Lean.ParserDescr

full_name: ZNum.linearOrder
code: instance linearOrder : LinearOrder ZNum 
goal: LinearOrder ZNum

full_name: ZNum.addMonoid
code: instance addMonoid : AddMonoid ZNum 
goal: AddMonoid ZNum

full_name: ZNum.addCommGroup
code: instance addCommGroup : AddCommGroup ZNum 
goal: AddCommGroup ZNum

full_name: ZNum.addMonoidWithOne
code: instance addMonoidWithOne : AddMonoidWithOne ZNum 
goal: AddMonoidWithOne ZNum

full_name: _private.Mathlib.Data.Num.Lemmas.0.ZNum.mul_comm
code: private theorem mul_comm : ∀ (a b : ZNum), a * b = b * a 
goal: a * b = b * a

full_name: _private.Mathlib.Data.Num.Lemmas.0.ZNum.add_le_add_left
code: private theorem add_le_add_left : ∀ (a b : ZNum), a ≤ b → ∀ (c : ZNum), c + a ≤ c + b 
goal: a ≤ b → ∀ (c : ZNum), c + a ≤ c + b

full_name: ZNum.linearOrderedCommRing
code: instance linearOrderedCommRing : LinearOrderedCommRing ZNum 
goal: LinearOrderedCommRing ZNum

full_name: ZNum.cast_sub
code: @[simp, norm_cast]
theorem cast_sub [Ring α] (m n) : ((m - n : ZNum) : α) = m - n 
goal: ↑(m - n) = ↑m - ↑n

full_name: ZNum.neg_of_int
code: @[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem neg_of_int : ∀ n, ((-n : ℤ) : ZNum) = -n
  
goal: ↑(-n) = -↑n

full_name: ZNum.ofInt'_eq
code: @[simp]
theorem ofInt'_eq : ∀ n : ℤ, ZNum.ofInt' n = n
  
goal: ZNum.ofInt' n = ↑n

full_name: ZNum.of_nat_toZNum
code: @[simp]
theorem of_nat_toZNum (n : ℕ) : Num.toZNum n = n 
goal: (↑n).toZNum = ↑n

full_name: ZNum.of_to_int
code: @[simp high, norm_cast]
theorem of_to_int (n : ZNum) : ((n : ℤ) : ZNum) = n 
goal: ↑↑n = n

full_name: ZNum.to_of_int
code: theorem to_of_int (n : ℤ) : ((n : ZNum) : ℤ) = n 
goal: ↑↑n = n

full_name: ZNum.of_nat_toZNumNeg
code: @[simp]
theorem of_nat_toZNumNeg (n : ℕ) : Num.toZNumNeg n = -n 
goal: (↑n).toZNumNeg = -↑n

full_name: ZNum.of_intCast
code: @[simp, norm_cast]
theorem of_intCast [AddGroupWithOne α] (n : ℤ) : ((n : ZNum) : α) = n 
goal: ↑↑n = ↑n

full_name: ZNum.of_natCast
code: @[simp, norm_cast]
theorem of_natCast [AddGroupWithOne α] (n : ℕ) : ((n : ZNum) : α) = n 
goal: ↑↑n = ↑n

full_name: ZNum.dvd_to_int
code: @[simp, norm_cast]
theorem dvd_to_int (m n : ZNum) : (m : ℤ) ∣ n ↔ m ∣ n 
goal: ↑m ∣ ↑n ↔ m ∣ n

full_name: PosNum.divMod_to_nat_aux
code: theorem divMod_to_nat_aux {n d : PosNum} {q r : Num} (h₁ : (r : ℕ) + d * ((q : ℕ) + q) = n)
    (h₂ : (r : ℕ) < 2 * d) :
    ((divModAux d q r).2 + d * (divModAux d q r).1 : ℕ) = ↑n ∧ ((divModAux d q r).2 : ℕ) < d 
goal: ↑(d.divModAux q r).2 + ↑d * ↑(d.divModAux q r).1 = ↑n ∧ ↑(d.divModAux q r).2 < ↑d

full_name: PosNum.divMod_to_nat
code: theorem divMod_to_nat (d n : PosNum) :
    (n / d : ℕ) = (divMod d n).1 ∧ (n % d : ℕ) = (divMod d n).2 
goal: ↑n / ↑d = ↑(d.divMod n).1 ∧ ↑n % ↑d = ↑(d.divMod n).2

full_name: PosNum.div'_to_nat
code: @[simp]
theorem div'_to_nat (n d) : (div' n d : ℕ) = n / d 
goal: ↑(n.div' d) = ↑n / ↑d

full_name: PosNum.mod'_to_nat
code: @[simp]
theorem mod'_to_nat (n d) : (mod' n d : ℕ) = n % d 
goal: ↑(n.mod' d) = ↑n % ↑d

full_name: Num.div_zero
code: @[simp]
protected theorem div_zero (n : Num) : n / 0 = 0 
goal: n / 0 = 0

full_name: Num.div_to_nat
code: @[simp, norm_cast]
theorem div_to_nat : ∀ n d, ((n / d : Num) : ℕ) = n / d
  
goal: ↑(n / d) = ↑n / ↑d

full_name: Num.mod_zero
code: @[simp]
protected theorem mod_zero (n : Num) : n % 0 = n 
goal: n % 0 = n

full_name: Num.mod_to_nat
code: @[simp, norm_cast]
theorem mod_to_nat : ∀ n d, ((n % d : Num) : ℕ) = n % d
  
goal: ↑(n % d) = ↑n % ↑d

full_name: Num.gcd_to_nat_aux
code: theorem gcd_to_nat_aux :
    ∀ {n} {a b : Num}, a ≤ b → (a * b).natSize ≤ n → (gcdAux n a b : ℕ) = Nat.gcd a b
  
goal: a ≤ b → (a * b).natSize ≤ n → ↑(Num.gcdAux n a b) = (↑a).gcd ↑b

full_name: Num.gcd_to_nat
code: @[simp]
theorem gcd_to_nat : ∀ a b, (gcd a b : ℕ) = Nat.gcd a b 
goal: ↑(a.gcd b) = (↑a).gcd ↑b

full_name: Num.dvd_iff_mod_eq_zero
code: theorem dvd_iff_mod_eq_zero {m n : Num} : m ∣ n ↔ n % m = 0 
goal: m ∣ n ↔ n % m = 0

full_name: Num.decidableDvd
code: instance decidableDvd : DecidableRel ((· ∣ ·) : Num → Num → Prop)
  
goal: DecidableRel fun x x_1 => x ∣ x_1

full_name: PosNum.decidableDvd
code: instance PosNum.decidableDvd : DecidableRel ((· ∣ ·) : PosNum → PosNum → Prop)
  
goal: DecidableRel fun x x_1 => x ∣ x_1

full_name: ZNum.div_zero
code: @[simp]
protected theorem div_zero (n : ZNum) : n / 0 = 0 
goal: n / 0 = 0

full_name: ZNum.div_to_int
code: @[simp, norm_cast]
theorem div_to_int : ∀ n d, ((n / d : ZNum) : ℤ) = n / d
  
goal: ↑(n / d) = ↑n / ↑d

full_name: ZNum.mod_to_int
code: @[simp, norm_cast]
theorem mod_to_int : ∀ n d, ((n % d : ZNum) : ℤ) = n % d
  
goal: ↑(n % d) = ↑n % ↑d

full_name: ZNum.gcd_to_nat
code: @[simp]
theorem gcd_to_nat (a b) : (gcd a b : ℕ) = Int.gcd a b 
goal: ↑(a.gcd b) = (↑a).gcd ↑b

full_name: ZNum.dvd_iff_mod_eq_zero
code: theorem dvd_iff_mod_eq_zero {m n : ZNum} : m ∣ n ↔ n % m = 0 
goal: m ∣ n ↔ n % m = 0

full_name: ZNum.decidableDvd
code: instance decidableDvd : DecidableRel ((· ∣ ·) : ZNum → ZNum → Prop)
  
goal: DecidableRel fun x x_1 => x ∣ x_1

full_name: Int.ofSnum
code: /-- Cast a `SNum` to the corresponding integer. -/
def ofSnum : SNum → ℤ 
goal: SNum → ℤ

full_name: Int.snumCoe
code: instance snumCoe : Coe SNum ℤ 
goal: Coe SNum ℤ

full_name: SNum.lt
code: instance SNum.lt : LT SNum 
goal: LT SNum

full_name: SNum.le
code: instance SNum.le : LE SNum 
goal: LE SNum