ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Num.cast_toZNumNeg
@[simp]
theorem cast_toZNumNeg [AddGroup α] [One α] : ∀ n : Num, (n.toZNumNeg : α) = -n
  
Arguments: {α : Type u_1} [AddGroup α] [One α] (n : Num)
Goal: ↑n.toZNumNeg = -↑n
-- Num.add_toZNum
@[simp]
theorem add_toZNum (m n : Num) : Num.toZNum (m + n) = m.toZNum + n.toZNum 
Arguments: (m n : Num)
Goal: (m + n).toZNum = m.toZNum + n.toZNum
-- PosNum.pred_to_nat
theorem pred_to_nat {n : PosNum} (h : 1 < n) : (pred n : ℕ) = Nat.pred n 
Arguments: {n : PosNum} (h : 1 < n)
Goal: ↑n.pred = (↑n).pred
-- PosNum.sub'_one
theorem sub'_one (a : PosNum) : sub' a 1 = (pred' a).toZNum 
Arguments: (a : PosNum)
Goal: a.sub' 1 = a.pred'.toZNum
-- PosNum.one_sub'
theorem one_sub' (a : PosNum) : sub' 1 a = (pred' a).toZNumNeg 
Arguments: (a : PosNum)
Goal: PosNum.sub' 1 a = a.pred'.toZNumNeg
-- PosNum.lt_iff_cmp
theorem lt_iff_cmp {m n} : m < n ↔ cmp m n = Ordering.lt 
Arguments: {m n : PosNum}
Goal: m < n ↔ m.cmp n = Ordering.lt
-- PosNum.le_iff_cmp
theorem le_iff_cmp {m n} : m ≤ n ↔ cmp m n ≠ Ordering.gt 
Arguments: {m n : PosNum}
Goal: m ≤ n ↔ m.cmp n ≠ Ordering.gt
-- Num.pred_to_nat
theorem pred_to_nat : ∀ n : Num, (pred n : ℕ) = Nat.pred n
  
Arguments: (n : Num)
Goal: ↑n.pred = (↑n).pred
-- Num.ppred_to_nat
theorem ppred_to_nat : ∀ n : Num, (↑) <$> ppred n = Nat.ppred n
  
Arguments: (n : Num)
Goal: castNum <$> n.ppred = (↑n).ppred
-- Num.cmp_swap
theorem cmp_swap (m n) : (cmp m n).swap = cmp n m 
Arguments: (m n : Num)
Goal: (m.cmp n).swap = n.cmp m
-- Num.cmp_eq
theorem cmp_eq (m n) : cmp m n = Ordering.eq ↔ m = n 
Arguments: (m n : Num)
Goal: m.cmp n = Ordering.eq ↔ m = n
-- Num.cast_lt
@[simp, norm_cast]
theorem cast_lt [LinearOrderedSemiring α] {m n : Num} : (m : α) < n ↔ m < n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] {m n : Num}
Goal: ↑m < ↑n ↔ m < n
-- Num.cast_le
@[simp, norm_cast]
theorem cast_le [LinearOrderedSemiring α] {m n : Num} : (m : α) ≤ n ↔ m ≤ n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] {m n : Num}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Num.cast_inj
@[simp, norm_cast]
theorem cast_inj [LinearOrderedSemiring α] {m n : Num} : (m : α) = n ↔ m = n 
Arguments: {α : Type u_1} [LinearOrderedSemiring α] {m n : Num}
Goal: ↑m = ↑n ↔ m = n
-- Num.lt_iff_cmp
theorem lt_iff_cmp {m n} : m < n ↔ cmp m n = Ordering.lt 
Arguments: {m n : Num}
Goal: m < n ↔ m.cmp n = Ordering.lt
-- Num.le_iff_cmp
theorem le_iff_cmp {m n} : m ≤ n ↔ cmp m n ≠ Ordering.gt 
Arguments: {m n : Num}
Goal: m ≤ n ↔ m.cmp n ≠ Ordering.gt
-- Num.castNum_eq_bitwise
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 
Arguments: {f : Num → Num → Num} {g : Bool → Bool → Bool} (p : PosNum → PosNum → Num) (gff : g false false = false) (f00 : f 0 0 = 0) (f0n : ∀ (n : PosNum), f 0 (Num.pos n) = bif g false true then Num.pos n else 0) (fn0 : ∀ (n : PosNum), f (Num.pos n) 0 = bif g true false then Num.pos n else 0) (fnn : ∀ (m n : PosNum), f (Num.pos m) (Num.pos n) = p m n) (p11 : p 1 1 = bif g true true then 1 else 0) (p1b : ∀ (b : Bool) (n : PosNum), p 1 (PosNum.bit b n) = Num.bit (g true b) (bif g false true then Num.pos n else 0)) (pb1 : ∀ (a : Bool) (m : PosNum), p (PosNum.bit a m) 1 = Num.bit (g a true) (bif g true false then Num.pos m else 0)) (pbb : ∀ (a b : Bool) (m n : PosNum), p (PosNum.bit a m) (PosNum.bit b n) = Num.bit (g a b) (p m n)) (m n : Num)
Goal: ↑(f m n) = Nat.bitwise g ↑m ↑n
-- Num.castNum_or
@[simp, norm_cast]
theorem castNum_or : ∀ m n : Num, ↑(m ||| n) = (↑m ||| ↑n : ℕ) 
Arguments: (m n : Num)
Goal: ↑(m ||| n) = ↑m ||| ↑n
-- Num.castNum_and
@[simp, norm_cast]
theorem castNum_and : ∀ m n : Num, ↑(m &&& n) = (↑m &&& ↑n : ℕ) 
Arguments: (m n : Num)
Goal: ↑(m &&& n) = ↑m &&& ↑n
-- Num.castNum_ldiff
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n 
Arguments: (m n : Num)
Goal: ↑(m.ldiff n) = (↑m).ldiff ↑n
-- Num.castNum_xor
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) 
Arguments: (m n : Num)
Goal: ↑(m ^^^ n) = ↑m ^^^ ↑n
-- Num.castNum_shiftLeft
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) 
Arguments: (m : Num) (n : ℕ)
Goal: ↑(m <<< n) = ↑m <<< n
-- Num.castNum_shiftRight
@[simp, norm_cast]
theorem castNum_shiftRight (m : Num) (n : Nat) : ↑(m >>> n) = (m : ℕ) >>> (n : ℕ) 
Arguments: (m : Num) (n : ℕ)
Goal: ↑(m >>> n) = ↑m >>> n
-- Num.castNum_testBit
@[simp]
theorem castNum_testBit (m n) : testBit m n = Nat.testBit m n 
Arguments: (m : Num) (n : ℕ)
Goal: m.testBit n = (↑m).testBit n
-- ZNum.cast_zero
@[simp, norm_cast]
theorem cast_zero [Zero α] [One α] [Add α] [Neg α] : ((0 : ZNum) : α) = 0 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α]
Goal: ↑0 = 0
-- ZNum.cast_zero'
@[simp]
theorem cast_zero' [Zero α] [One α] [Add α] [Neg α] : (ZNum.zero : α) = 0 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α]
Goal: ↑ZNum.zero = 0
-- ZNum.cast_one
@[simp, norm_cast]
theorem cast_one [Zero α] [One α] [Add α] [Neg α] : ((1 : ZNum) : α) = 1 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α]
Goal: ↑1 = 1
-- ZNum.cast_pos
@[simp]
theorem cast_pos [Zero α] [One α] [Add α] [Neg α] (n : PosNum) : (pos n : α) = n 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α] (n : PosNum)
Goal: ↑(ZNum.pos n) = ↑n
-- ZNum.cast_neg
@[simp]
theorem cast_neg [Zero α] [One α] [Add α] [Neg α] (n : PosNum) : (neg n : α) = -n 
Arguments: {α : Type u_1} [Zero α] [One α] [Add α] [Neg α] (n : PosNum)
Goal: ↑(ZNum.neg n) = -↑n
-- ZNum.cast_zneg
@[simp, norm_cast]
theorem cast_zneg [AddGroup α] [One α] : ∀ n, ((-n : ZNum) : α) = -n
  
Arguments: {α : Type u_1} [AddGroup α] [One α] (n : ZNum)
Goal: ↑(-n) = -↑n
-- ZNum.neg_zero
theorem neg_zero : (-0 : ZNum) = 0 
Goal: -0 = 0
-- ZNum.zneg_pos
theorem zneg_pos (n : PosNum) : -pos n = neg n 
Arguments: (n : PosNum)
Goal: -ZNum.pos n = ZNum.neg n
-- ZNum.zneg_neg
theorem zneg_neg (n : PosNum) : -neg n = pos n 
Arguments: (n : PosNum)
Goal: -ZNum.neg n = ZNum.pos n
-- ZNum.zneg_zneg
theorem zneg_zneg (n : ZNum) : - -n = n 
Arguments: (n : ZNum)
Goal: - -n = n
-- ZNum.zneg_bit1
theorem zneg_bit1 (n : ZNum) : -n.bit1 = (-n).bitm1 
Arguments: (n : ZNum)
Goal: -n.bit1 = (-n).bitm1
-- ZNum.zneg_bitm1
theorem zneg_bitm1 (n : ZNum) : -n.bitm1 = (-n).bit1 
Arguments: (n : ZNum)
Goal: -n.bitm1 = (-n).bit1
-- ZNum.zneg_succ
theorem zneg_succ (n : ZNum) : -n.succ = (-n).pred 
Arguments: (n : ZNum)
Goal: -n.succ = (-n).pred
-- ZNum.zneg_pred
theorem zneg_pred (n : ZNum) : -n.pred = (-n).succ 
Arguments: (n : ZNum)
Goal: -n.pred = (-n).succ
-- ZNum.abs_to_nat
@[simp]
theorem abs_to_nat : ∀ n, (abs n : ℕ) = Int.natAbs n
  
Arguments: (n : ZNum)
Goal: ↑n.abs = (↑n).natAbs
-- ZNum.abs_toZNum
@[simp]
theorem abs_toZNum : ∀ n : Num, abs n.toZNum = n
  
Arguments: (n : Num)
Goal: n.toZNum.abs = n
-- ZNum.cast_to_int
@[simp, norm_cast]
theorem cast_to_int [AddGroupWithOne α] : ∀ n : ZNum, ((n : ℤ) : α) = n
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑↑n = ↑n
-- ZNum.bit0_of_bit0
theorem bit0_of_bit0 : ∀ n : ZNum, n + n = n.bit0
  
Arguments: (n : ZNum)
Goal: n + n = n.bit0
-- ZNum.bit1_of_bit1
theorem bit1_of_bit1 : ∀ n : ZNum, n + n + 1 = n.bit1
  
Arguments: (n : ZNum)
Goal: n + n + 1 = n.bit1
-- ZNum.cast_bit0
@[simp, norm_cast]
theorem cast_bit0 [AddGroupWithOne α] : ∀ n : ZNum, (n.bit0 : α) = (n : α) + n
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑n.bit0 = ↑n + ↑n
-- ZNum.cast_bit1
@[simp, norm_cast]
theorem cast_bit1 [AddGroupWithOne α] : ∀ n : ZNum, (n.bit1 : α) = ((n : α) + n) + 1
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑n.bit1 = ↑n + ↑n + 1
-- ZNum.cast_bitm1
@[simp]
theorem cast_bitm1 [AddGroupWithOne α] (n : ZNum) : (n.bitm1 : α) = (n : α) + n - 1 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑n.bitm1 = ↑n + ↑n - 1
-- ZNum.add_zero
theorem add_zero (n : ZNum) : n + 0 = n 
Arguments: (n : ZNum)
Goal: n + 0 = n
-- ZNum.zero_add
theorem zero_add (n : ZNum) : 0 + n = n 
Arguments: (n : ZNum)
Goal: 0 + n = n
-- ZNum.add_one
theorem add_one : ∀ n : ZNum, n + 1 = succ n
  
Arguments: (n : ZNum)
Goal: n + 1 = n.succ
-- PosNum.cast_to_znum
theorem cast_to_znum : ∀ n : PosNum, (n : ZNum) = ZNum.pos n
  
Arguments: (n : PosNum)
Goal: ↑n = ZNum.pos n
-- PosNum.cast_sub'
theorem cast_sub' [AddGroupWithOne α] : ∀ m n : PosNum, (sub' m n : α) = m - n
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (m n : PosNum)
Goal: ↑(m.sub' n) = ↑m - ↑n
-- PosNum.to_nat_eq_succ_pred
theorem to_nat_eq_succ_pred (n : PosNum) : (n : ℕ) = n.pred' + 1 
Arguments: (n : PosNum)
Goal: ↑n = ↑n.pred' + 1
-- PosNum.to_int_eq_succ_pred
theorem to_int_eq_succ_pred (n : PosNum) : (n : ℤ) = (n.pred' : ℕ) + 1 
Arguments: (n : PosNum)
Goal: ↑n = ↑↑n.pred' + 1
-- Num.cast_sub'
@[simp]
theorem cast_sub' [AddGroupWithOne α] : ∀ m n : Num, (sub' m n : α) = m - n
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (m n : Num)
Goal: ↑(m.sub' n) = ↑m - ↑n
-- Num.toZNum_succ
theorem toZNum_succ : ∀ n : Num, n.succ.toZNum = n.toZNum.succ
  
Arguments: (n : Num)
Goal: n.succ.toZNum = n.toZNum.succ
-- Num.toZNumNeg_succ
theorem toZNumNeg_succ : ∀ n : Num, n.succ.toZNumNeg = n.toZNumNeg.pred
  
Arguments: (n : Num)
Goal: n.succ.toZNumNeg = n.toZNumNeg.pred
-- Num.pred_succ
@[simp]
theorem pred_succ : ∀ n : ZNum, n.pred.succ = n
  
Arguments: (n : ZNum)
Goal: n.pred.succ = n
-- Num.succ_ofInt'
theorem succ_ofInt' : ∀ n, ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1
  
Arguments: (n : ℤ)
Goal: ZNum.ofInt' (n + 1) = ZNum.ofInt' n + 1
-- Num.ofInt'_toZNum
theorem ofInt'_toZNum : ∀ n : ℕ, toZNum n = ZNum.ofInt' n
  
Arguments: (n : ℕ)
Goal: (↑n).toZNum = ZNum.ofInt' ↑n
-- Num.mem_ofZNum'
theorem mem_ofZNum' : ∀ {m : Num} {n : ZNum}, m ∈ ofZNum' n ↔ n = toZNum m
  
Arguments: {m : Num} {n : ZNum}
Goal: m ∈ Num.ofZNum' n ↔ n = m.toZNum
-- Num.ofZNum'_toNat
theorem ofZNum'_toNat : ∀ n : ZNum, (↑) <$> ofZNum' n = Int.toNat' n
  
Arguments: (n : ZNum)
Goal: castNum <$> Num.ofZNum' n = (↑n).toNat'
-- Num.ofZNum_toNat
@[simp]
theorem ofZNum_toNat : ∀ n : ZNum, (ofZNum n : ℕ) = Int.toNat n
  
Arguments: (n : ZNum)
Goal: ↑(Num.ofZNum n) = (↑n).toNat
-- Num.cast_ofZNum
@[simp]
theorem cast_ofZNum [AddGroupWithOne α] (n : ZNum) : (ofZNum n : α) = Int.toNat n 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑(Num.ofZNum n) = ↑(↑n).toNat
-- Num.sub_to_nat
@[simp, norm_cast]
theorem sub_to_nat (m n) : ((m - n : Num) : ℕ) = m - n 
Arguments: (m n : Num)
Goal: ↑(m - n) = ↑m - ↑n
-- ZNum.cast_add
@[simp, norm_cast]
theorem cast_add [AddGroupWithOne α] : ∀ m n, ((m + n : ZNum) : α) = m + n
  
Arguments: {α : Type u_1} [AddGroupWithOne α] (m n : ZNum)
Goal: ↑(m + n) = ↑m + ↑n
-- ZNum.cast_succ
@[simp]
theorem cast_succ [AddGroupWithOne α] (n) : ((succ n : ZNum) : α) = n + 1 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ZNum)
Goal: ↑n.succ = ↑n + 1
-- ZNum.mul_to_int
@[simp, norm_cast]
theorem mul_to_int : ∀ m n, ((m * n : ZNum) : ℤ) = m * n
  
Arguments: (m n : ZNum)
Goal: ↑(m * n) = ↑m * ↑n
-- ZNum.cast_mul
theorem cast_mul [Ring α] (m n) : ((m * n : ZNum) : α) = m * n 
Arguments: {α : Type u_1} [Ring α] (m n : ZNum)
Goal: ↑(m * n) = ↑m * ↑n
-- ZNum.ofInt'_neg
theorem ofInt'_neg : ∀ n : ℤ, ofInt' (-n) = -ofInt' n
  
Arguments: (n : ℤ)
Goal: ZNum.ofInt' (-n) = -ZNum.ofInt' n
-- ZNum.of_to_int'
theorem of_to_int' : ∀ n : ZNum, ZNum.ofInt' n = n
  
Arguments: (n : ZNum)
Goal: ZNum.ofInt' ↑n = n
-- ZNum.to_int_inj
theorem to_int_inj {m n : ZNum} : (m : ℤ) = n ↔ m = n 
Arguments: {m n : ZNum}
Goal: ↑m = ↑n ↔ m = n
-- ZNum.cmp_to_int
theorem cmp_to_int : ∀ m n, (Ordering.casesOn (cmp m n) ((m : ℤ) < n) (m = n) ((n : ℤ) < m) : Prop)
  
Arguments: (m n : ZNum)
Goal: Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
-- ZNum.lt_to_int
@[norm_cast]
theorem lt_to_int {m n : ZNum} : (m : ℤ) < n ↔ m < n 
Arguments: {m n : ZNum}
Goal: ↑m < ↑n ↔ m < n
-- ZNum.le_to_int
theorem le_to_int {m n : ZNum} : (m : ℤ) ≤ n ↔ m ≤ n 
Arguments: {m n : ZNum}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- ZNum.cast_lt
@[simp, norm_cast]
theorem cast_lt [LinearOrderedRing α] {m n : ZNum} : (m : α) < n ↔ m < n 
Arguments: {α : Type u_1} [LinearOrderedRing α] {m n : ZNum}
Goal: ↑m < ↑n ↔ m < n
-- ZNum.cast_le
@[simp, norm_cast]
theorem cast_le [LinearOrderedRing α] {m n : ZNum} : (m : α) ≤ n ↔ m ≤ n 
Arguments: {α : Type u_1} [LinearOrderedRing α] {m n : ZNum}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- ZNum.cast_inj
@[simp, norm_cast]
theorem cast_inj [LinearOrderedRing α] {m n : ZNum} : (m : α) = n ↔ m = n 
Arguments: {α : Type u_1} [LinearOrderedRing α] {m n : ZNum}
Goal: ↑m = ↑n ↔ m = n
-- _private.Mathlib.Data.Num.Lemmas.0.ZNum.mul_comm
private theorem mul_comm : ∀ (a b : ZNum), a * b = b * a 
Arguments: (a b : ZNum)
Goal: a * b = b * a
-- _private.Mathlib.Data.Num.Lemmas.0.ZNum.add_le_add_left
private theorem add_le_add_left : ∀ (a b : ZNum), a ≤ b → ∀ (c : ZNum), c + a ≤ c + b 
Arguments: (a b : ZNum)
Goal: a ≤ b → ∀ (c : ZNum), c + a ≤ c + b
-- ZNum.cast_sub
@[simp, norm_cast]
theorem cast_sub [Ring α] (m n) : ((m - n : ZNum) : α) = m - n 
Arguments: {α : Type u_1} [Ring α] (m n : ZNum)
Goal: ↑(m - n) = ↑m - ↑n
-- ZNum.neg_of_int
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem neg_of_int : ∀ n, ((-n : ℤ) : ZNum) = -n
  
Arguments: (n : ℤ)
Goal: ↑(-n) = -↑n
-- ZNum.ofInt'_eq
@[simp]
theorem ofInt'_eq : ∀ n : ℤ, ZNum.ofInt' n = n
  
Arguments: (n : ℤ)
Goal: ZNum.ofInt' n = ↑n
-- ZNum.of_nat_toZNum
@[simp]
theorem of_nat_toZNum (n : ℕ) : Num.toZNum n = n 
Arguments: (n : ℕ)
Goal: (↑n).toZNum = ↑n
-- ZNum.of_to_int
@[simp high, norm_cast]
theorem of_to_int (n : ZNum) : ((n : ℤ) : ZNum) = n 
Arguments: (n : ZNum)
Goal: ↑↑n = n
-- ZNum.to_of_int
theorem to_of_int (n : ℤ) : ((n : ZNum) : ℤ) = n 
Arguments: (n : ℤ)
Goal: ↑↑n = n
-- ZNum.of_nat_toZNumNeg
@[simp]
theorem of_nat_toZNumNeg (n : ℕ) : Num.toZNumNeg n = -n 
Arguments: (n : ℕ)
Goal: (↑n).toZNumNeg = -↑n
-- ZNum.of_intCast
@[simp, norm_cast]
theorem of_intCast [AddGroupWithOne α] (n : ℤ) : ((n : ZNum) : α) = n 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ℤ)
Goal: ↑↑n = ↑n
-- ZNum.of_natCast
@[simp, norm_cast]
theorem of_natCast [AddGroupWithOne α] (n : ℕ) : ((n : ZNum) : α) = n 
Arguments: {α : Type u_1} [AddGroupWithOne α] (n : ℕ)
Goal: ↑↑n = ↑n
-- ZNum.dvd_to_int
@[simp, norm_cast]
theorem dvd_to_int (m n : ZNum) : (m : ℤ) ∣ n ↔ m ∣ n 
Arguments: (m n : ZNum)
Goal: ↑m ∣ ↑n ↔ m ∣ n
-- PosNum.divMod_to_nat_aux
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 
Arguments: {n d : PosNum} {q r : Num} (h₁ : ↑r + ↑d * (↑q + ↑q) = ↑n) (h₂ : ↑r < 2 * ↑d)
Goal: ↑(d.divModAux q r).2 + ↑d * ↑(d.divModAux q r).1 = ↑n ∧ ↑(d.divModAux q r).2 < ↑d
-- PosNum.divMod_to_nat
theorem divMod_to_nat (d n : PosNum) :
    (n / d : ℕ) = (divMod d n).1 ∧ (n % d : ℕ) = (divMod d n).2 
Arguments: (d n : PosNum)
Goal: ↑n / ↑d = ↑(d.divMod n).1 ∧ ↑n % ↑d = ↑(d.divMod n).2
-- PosNum.div'_to_nat
@[simp]
theorem div'_to_nat (n d) : (div' n d : ℕ) = n / d 
Arguments: (n d : PosNum)
Goal: ↑(n.div' d) = ↑n / ↑d
-- PosNum.mod'_to_nat
@[simp]
theorem mod'_to_nat (n d) : (mod' n d : ℕ) = n % d 
Arguments: (n d : PosNum)
Goal: ↑(n.mod' d) = ↑n % ↑d
-- Num.div_zero
@[simp]
protected theorem div_zero (n : Num) : n / 0 = 0 
Arguments: (n : Num)
Goal: n / 0 = 0
-- Num.div_to_nat
@[simp, norm_cast]
theorem div_to_nat : ∀ n d, ((n / d : Num) : ℕ) = n / d
  
Arguments: (n d : Num)
Goal: ↑(n / d) = ↑n / ↑d
-- Num.mod_zero
@[simp]
protected theorem mod_zero (n : Num) : n % 0 = n 
Arguments: (n : Num)
Goal: n % 0 = n
-- Num.mod_to_nat
@[simp, norm_cast]
theorem mod_to_nat : ∀ n d, ((n % d : Num) : ℕ) = n % d
  
Arguments: (n d : Num)
Goal: ↑(n % d) = ↑n % ↑d
-- Num.gcd_to_nat_aux
theorem gcd_to_nat_aux :
    ∀ {n} {a b : Num}, a ≤ b → (a * b).natSize ≤ n → (gcdAux n a b : ℕ) = Nat.gcd a b
  
Arguments: {n : ℕ} {a b : Num}
Goal: a ≤ b → (a * b).natSize ≤ n → ↑(Num.gcdAux n a b) = (↑a).gcd ↑b
-- Num.gcd_to_nat
@[simp]
theorem gcd_to_nat : ∀ a b, (gcd a b : ℕ) = Nat.gcd a b 
Arguments: (a b : Num)
Goal: ↑(a.gcd b) = (↑a).gcd ↑b
-- Num.dvd_iff_mod_eq_zero
theorem dvd_iff_mod_eq_zero {m n : Num} : m ∣ n ↔ n % m = 0 
Arguments: {m n : Num}
Goal: m ∣ n ↔ n % m = 0
-- ZNum.div_zero
@[simp]
protected theorem div_zero (n : ZNum) : n / 0 = 0 
Arguments: (n : ZNum)
Goal: n / 0 = 0
-- ZNum.div_to_int
@[simp, norm_cast]
theorem div_to_int : ∀ n d, ((n / d : ZNum) : ℤ) = n / d
  
Arguments: (n d : ZNum)
Goal: ↑(n / d) = ↑n / ↑d
-- ZNum.mod_to_int
@[simp, norm_cast]
theorem mod_to_int : ∀ n d, ((n % d : ZNum) : ℤ) = n % d
  
Arguments: (n d : ZNum)
Goal: ↑(n % d) = ↑n % ↑d
-- ZNum.gcd_to_nat
@[simp]
theorem gcd_to_nat (a b) : (gcd a b : ℕ) = Int.gcd a b 
Arguments: (a b : ZNum)
Goal: ↑(a.gcd b) = (↑a).gcd ↑b
-- ZNum.dvd_iff_mod_eq_zero
theorem dvd_iff_mod_eq_zero {m n : ZNum} : m ∣ n ↔ n % m = 0 
Arguments: {m n : ZNum}
Goal: m ∣ n ↔ n % m = 0