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

Information

Files

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

Defined Constants

• Data
  • Word16
    • fromBytes
    • toBytes

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.
    toBytes w =
    (fromNatural (toNatural w), fromNatural (toNatural (shiftRight w 8)))

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

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

External Type Operators

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

External Constants

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

Assumptions

⊦ ⊤

⊦ ¬odd 0

⊦ ¬⊥ ⇔ ⊤

⊦ ¬⊤ ⇔ ⊥

⊦ length [] = 0

⊦ bit0 0 = 0

⊦ ∀x. x = x

⊦ ∀t. t ⇒ t

⊦ ∀n. n ≤ n

⊦ ⊥ ⇔ ∀p. p

⊦ ∀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 = 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

⊦ ∀n. n mod 1 = 0

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

⊦ ∀m n. m ≤ m + n

⊦ width = 16

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

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

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

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

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

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

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

⊦ ∀a b. fst (a, b) = a

⊦ ∀a b. snd (a, b) = b

⊦ ∀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

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

⊦ ∀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. ¬(∃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

⊦ ∀t₁ t₂. ¬(t₁ ∧ t₂) ⇔ ¬t₁ ∨ ¬t₂

⊦ ∀m n. m ↑ suc n = m * m ↑ 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₂. or w₁ w₂ = toWord (zipWith (∨) (fromWord w₁) (fromWord w₂))

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

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

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

⊦ ∀m n. m < n ⇔ ∃d. n = m + suc d

⊦ ∀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

⊦ ∀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 * 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

⊦ ∀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

⊦ ∀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

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

⊦ ∀a b a' b'. (a, b) = (a', b') ⇔ a = a' ∧ b = 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 p. ¬(n * p = 0) ⇒ m div n mod p = m mod n * p div n

⊦ ∀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 document generated by opentheory 1.3 (release 20141119)