Package word16-bytes-thm: Properties of 16-bit word to byte pair conversions

Information

Files

• Package tarball word16-bytes-thm-1.64.tgz
• Theory file word16-bytes-thm.thy (included in the package tarball)

Theorems

⊦ ∀b. fromNatural (toNatural b) = toWord (fromByte b)

⊦ ∀w. fromNatural (toNatural w) = toByte (fromWord w)

⊦ ∀w. ∃b₀ b₁. w = fromBytes b₀ b₁

⊦ ∀b₀ b₁. toWord (fromByte b₁ @ fromByte b₀) = fromBytes b₀ b₁

⊦ ∀w. ∃b₀ b₁. w = fromBytes b₀ b₁ ∧ toBytes w = (b₀, b₁)

⊦ ∀w.
    (toByte (drop 8 (fromWord w)), toByte (take 8 (fromWord w))) =
    toBytes w

Input Type Operators

• →
• bool
• Data
  • Byte
    • byte
  • List
    • list
  • Pair
    • ×
  • Word16
    • word16
• Number
  • Natural
    • natural

Input Constants

• =
• Data
  • Bool
    • ∀
    • ∧
    • ⇒
    • ∃
    • ∨
    • ¬
    • cond
    • ⊥
    • ⊤
  • Byte
    • bit
    • fromNatural
    • modulus
    • toNatural
    • width
    • Bits
      • fromByte
      • toByte
  • List
    • ::
    • @
    • []
    • drop
    • length
    • nth
    • replicate
    • take
    • zipWith
  • Pair
    • ,
    • fst
    • snd
  • Word16
    • and
    • bit
    • fromBytes
    • fromNatural
    • modulus
    • or
    • shiftLeft
    • shiftRight
    • toBytes
    • toNatural
    • width
    • Bits
      • fromWord
      • toWord
• Number
  • Natural
    • *
    • +
    • -
    • <
    • ≤
    • ↑
    • bit0
    • bit1
    • div
    • even
    • mod
    • odd
    • suc
    • zero

Assumptions

⊦ ⊤

⊦ ¬⊥ ⇔ ⊤

⊦ ¬⊤ ⇔ ⊥

⊦ odd 0 ⇔ ⊥

⊦ length [] = 0

⊦ bit0 0 = 0

⊦ ∀x. x = x

⊦ ∀t. t ⇒ t

⊦ ∀n. 0 ≤ n

⊦ ⊥ ⇔ ∀p. p

⊦ toWord [] = 0

⊦ ∀t. t ∨ ¬t

⊦ (¬) = λp. p ⇒ ⊥

⊦ ∀t. (∀x. t) ⇔ t

⊦ ∀t. (λx. t x) = t

⊦ (∀) = λp. p = λx. ⊤

⊦ ∀x. replicate x 0 = []

⊦ ∀t. ¬¬t ⇔ t

⊦ ∀t. (⊤ ⇔ t) ⇔ t

⊦ ∀t. (t ⇔ ⊤) ⇔ t

⊦ ∀t. ⊥ ∧ t ⇔ ⊥

⊦ ∀t. ⊤ ∧ t ⇔ t

⊦ ∀t. t ∧ ⊥ ⇔ ⊥

⊦ ∀t. t ∧ ⊤ ⇔ t

⊦ ∀t. t ∧ t ⇔ t

⊦ ∀t. ⊥ ⇒ t ⇔ ⊤

⊦ ∀t. ⊤ ⇒ t ⇔ t

⊦ ∀t. t ⇒ ⊤ ⇔ ⊤

⊦ ∀t. ⊥ ∨ t ⇔ t

⊦ ∀t. ⊤ ∨ t ⇔ ⊤

⊦ ∀t. t ∨ ⊥ ⇔ t

⊦ ∀t. t ∨ ⊤ ⇔ ⊤

⊦ ∀w. toByte (fromByte w) = w

⊦ ∀w. length (fromByte w) = width

⊦ ∀w. toWord (fromWord w) = w

⊦ ∀w. length (fromWord w) = width

⊦ ∀n. ¬(suc n = 0)

⊦ ∀n. 0 * n = 0

⊦ ∀m. m * 0 = 0

⊦ ∀n. 0 + n = n

⊦ ∀m. m + 0 = m

⊦ ∀l. [] @ l = l

⊦ ∀l. drop 0 l = l

⊦ ∀l. take 0 l = []

⊦ modulus = 2 ↑ width

⊦ width = 8

⊦ modulus = 2 ↑ width

⊦ ∀t. (⊥ ⇔ t) ⇔ ¬t

⊦ ∀t. (t ⇔ ⊥) ⇔ ¬t

⊦ ∀t. t ⇒ ⊥ ⇔ ¬t

⊦ ∀n. bit1 n = suc (bit0 n)

⊦ ∀m. m ↑ 0 = 1

⊦ ∀m. m * 1 = m

⊦ ∀n. n mod 1 = 0

⊦ ∀m. 1 * m = m

⊦ ∀f. zipWith f [] [] = []

⊦ width = 16

⊦ (⇒) = λp q. p ∧ q ⇔ p

⊦ ∀t. (t ⇔ ⊤) ∨ (t ⇔ ⊥)

⊦ ∀n. even (suc n) ⇔ ¬even n

⊦ ∀n. odd (suc n) ⇔ ¬odd n

⊦ ∀m. m ≤ 0 ⇔ m = 0

⊦ ∀n. toNatural (fromNatural n) = n mod modulus

⊦ ∀n. toNatural (fromNatural n) = n mod modulus

⊦ ∀xy. (fst xy, snd xy) = xy

⊦ ∀t₁ t₂. (if ⊥ then t₁ else t₂) = t₂

⊦ ∀t₁ t₂. (if ⊤ then t₁ else t₂) = t₁

⊦ ∀x y. fst (x, y) = x

⊦ ∀x y. snd (x, y) = y

⊦ ∀n. bit0 (suc n) = suc (suc (bit0 n))

⊦ ∀x y. x = y ⇒ y = x

⊦ ∀t₁ t₂. t₁ ∨ t₂ ⇔ t₂ ∨ t₁

⊦ ∀m n. m + n = n + m

⊦ ∀m n. m ≤ n ∨ n ≤ m

⊦ ∀m n. m + n - m = n

⊦ ∀m n. m + n - n = m

⊦ ∀n. 2 * n = n + n

⊦ ∀h t. length (h :: t) = suc (length t)

⊦ ∀m n. ¬(m < n ∧ n ≤ m)

⊦ ∀m n. ¬(m ≤ n ∧ n < m)

⊦ ∀m n. ¬(m < n) ⇔ n ≤ m

⊦ ∀m n. ¬(m ≤ n) ⇔ n < m

⊦ ∀m n. suc m ≤ n ⇔ m < n

⊦ ∀m. m = 0 ∨ ∃n. m = suc n

⊦ (∧) = λp q. (λf. f p q) = λf. f ⊤ ⊤

⊦ ∀p. ¬(∀x. p x) ⇔ ∃x. ¬p x

⊦ (∃) = λp. ∀q. (∀x. p x ⇒ q) ⇒ q

⊦ ∀w₁ w₂. fromByte w₁ = fromByte w₂ ⇔ w₁ = w₂

⊦ ∀w₁ w₂. fromWord w₁ = fromWord w₂ ⇔ w₁ = w₂

⊦ ∀m n. m < n ⇒ m div n = 0

⊦ ∀m n. m + suc n = suc (m + n)

⊦ ∀m n. suc m + n = suc (m + n)

⊦ ∀m n. suc m = suc n ⇔ m = n

⊦ ∀n. odd n ⇔ n mod 2 = 1

⊦ ∀x n. replicate x (suc n) = x :: replicate x n

⊦ ∀m n. even (m * n) ⇔ even m ∨ even n

⊦ ∀m n. even (m + n) ⇔ even m ⇔ even n

⊦ ∀m n. m * suc n = m + m * n

⊦ ∀m n. m ↑ suc n = m * m ↑ n

⊦ ∀m n. suc m * n = m * n + n

⊦ ∀m n. ¬(n = 0) ⇒ m mod n < n

⊦ ∀m n. m ≤ n ⇔ ∃d. n = m + d

⊦ (∨) = λp q. ∀r. (p ⇒ r) ⇒ (q ⇒ r) ⇒ r

⊦ ∀w₁ w₂. and w₁ w₂ = toWord (zipWith (∧) (fromWord w₁) (fromWord w₂))

⊦ ∀w₁ w₂. or w₁ w₂ = toWord (zipWith (∨) (fromWord w₁) (fromWord w₂))

⊦ ∀m n. m ≤ n ⇔ m < n ∨ m = n

⊦ ∀m n. n ≤ m ⇒ n + (m - n) = m

⊦ ∀m n. odd (m + n) ⇔ ¬(odd m ⇔ odd n)

⊦ ∀m n. m ≤ n ∧ n ≤ m ⇔ m = n

⊦ ∀l n. shiftLeft (toWord l) n = toWord (replicate ⊥ n @ l)

⊦ ∀p q. p ∨ (∃x. q x) ⇔ ∃x. p ∨ q x

⊦ ∀x y z. x = y ∧ y = z ⇒ x = z

⊦ ∀t₁ t₂ t₃. (t₁ ∧ t₂) ∧ t₃ ⇔ t₁ ∧ t₂ ∧ t₃

⊦ ∀t₁ t₂ t₃. (t₁ ∨ t₂) ∨ t₃ ⇔ t₁ ∨ t₂ ∨ t₃

⊦ ∀m n p. m + (n + p) = m + n + p

⊦ ∀m n p. m < n ∧ n ≤ p ⇒ m < p

⊦ ∀n. toWord (odd n :: fromWord (fromNatural (n div 2))) = fromNatural n

⊦ ∀l h t. (h :: t) @ l = h :: t @ l

⊦ ∀w n. bit w n ⇔ odd (toNatural w div 2 ↑ n)

⊦ ∀w n. bit w n ⇔ odd (toNatural w div 2 ↑ n)

⊦ ∀m n. m ≤ suc n ⇔ m = suc n ∨ m ≤ n

⊦ ∀m n. m * n = 0 ⇔ m = 0 ∨ n = 0

⊦ ∀p. p 0 ∧ (∀n. p n ⇒ p (suc n)) ⇒ ∀n. p n

⊦ ∀m n. m ↑ n = 0 ⇔ m = 0 ∧ ¬(n = 0)

⊦ ∀m n p. m * (n + p) = m * n + m * p

⊦ ∀m n p. m ↑ (n + p) = m ↑ n * m ↑ p

⊦ ∀m n p. (m + n) * p = m * p + n * p

⊦ ∀p q. (∀x. p x ∧ q x) ⇔ (∀x. p x) ∧ ∀x. q x

⊦ ∀p q. (∃x. p x) ∨ (∃x. q x) ⇔ ∃x. p x ∨ q x

⊦ ∀m n. ¬(n = 0) ⇒ (m div n) * n + m mod n = m

⊦ ∀w₁ w₂. (∀i. i < width ⇒ (bit w₁ i ⇔ bit w₂ i)) ⇒ w₁ = w₂

⊦ ∀w₁ w₂. (∀i. i < width ⇒ (bit w₁ i ⇔ bit w₂ i)) ⇒ w₁ = w₂

⊦ ∀n h t. n ≤ length t ⇒ drop (suc n) (h :: t) = drop n t

⊦ ∀m n p. m * n = m * p ⇔ m = 0 ∨ n = p

⊦ ∀m n p. m * n ≤ m * p ⇔ m = 0 ∨ n ≤ p

⊦ ∀b₁ b₂.
    fromBytes b₁ b₂ =
    or (shiftLeft (fromNatural (toNatural b₁)) 8)
      (fromNatural (toNatural b₂))

⊦ ∀l n. bit (toByte l) n ⇔ n < width ∧ n < length l ∧ nth l n

⊦ ∀l n. bit (toWord l) n ⇔ n < width ∧ n < length l ∧ nth l n

⊦ ∀m n p. m * n < m * p ⇔ ¬(m = 0) ∧ n < p

⊦ ∀h₁ h₂ t₁ t₂. h₁ :: t₁ = h₂ :: t₂ ⇔ h₁ = h₂ ∧ t₁ = t₂

⊦ ∀x y a b. (x, y) = (a, b) ⇔ x = a ∧ y = b

⊦ ∀n h t. n ≤ length t ⇒ take (suc n) (h :: t) = h :: take n t

⊦ ∀l.
    fromByte (toByte l) =
    if length l ≤ width then l @ replicate ⊥ (width - length l)
    else take width l

⊦ ∀l.
    fromWord (toWord l) =
    if length l ≤ width then l @ replicate ⊥ (width - length l)
    else take width l

⊦ ∀m n p. ¬(n * p = 0) ⇒ m mod n * p mod n = m mod n

⊦ ∀m n q r. m = q * n + r ∧ r < n ⇒ m div n = q

⊦ ∀m n q r. m = q * n + r ∧ r < n ⇒ m mod n = r

⊦ ∀m n p. ¬(n * p = 0) ⇒ m div n mod p = m mod n * p div n

⊦ ∀w.
    toBytes w =
    (fromNatural (toNatural (shiftRight w 8)),
     fromNatural (toNatural (and w 255)))

⊦ ∀f h₁ h₂ t₁ t₂.
    length t₁ = length t₂ ⇒
    zipWith f (h₁ :: t₁) (h₂ :: t₂) = f h₁ h₂ :: zipWith f t₁ t₂

⊦ ∀x m n. x ↑ m ≤ x ↑ n ⇔ if x = 0 then m = 0 ⇒ n = 0 else x = 1 ∨ m ≤ n

⊦ ∀b.
    ∃x₀ x₁ x₂ x₃ x₄ x₅ x₆ x₇.
      b = toByte (x₀ :: x₁ :: x₂ :: x₃ :: x₄ :: x₅ :: x₆ :: x₇ :: [])

⊦ ∀l n.
    shiftRight (toWord l) n =
    if length l ≤ width then
      if length l ≤ n then toWord [] else toWord (drop n l)
    else if width ≤ n then toWord []
    else toWord (drop n (take width l))

⊦ ∀w.
    ∃x₀ x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ x₉ x₁₀ x₁₁ x₁₂ x₁₃ x₁₄ x₁₅.
      w =
      toWord
        (x₀ :: x₁ :: x₂ :: x₃ :: x₄ :: x₅ :: x₆ :: x₇ :: x₈ :: x₉ :: x₁₀ ::
         x₁₁ :: x₁₂ :: x₁₃ :: x₁₄ :: x₁₅ :: [])

OpenTheory package summary generated by opentheory 1.1 (release 20120326)