Theory: more_string

Parents


Type constants


Term constants


Axioms


Definitions

bit0_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit0 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b0
bit1_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit1 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b1
bit2_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit2 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b2
bit3_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit3 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b3
bit4_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit4 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b4
bit5_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit5 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b5
bit6_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit6 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b6
bit7_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7. bit7 (ASCII b7 b6 b5 b4 b3 b2 b1 b0) = b7
ltascii_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7.
     ltascii (ASCII b7 b6 b5 b4 b3 b2 b1 b0) =
     (\a2.
       (~b7 /\ bit7 a2)
       => T
       | ((b7 /\ ~(bit7 a2))
          => F
          | ((~b6 /\ bit6 a2)
             => T
             | ((b6 /\ ~(bit6 a2))
                => F
                | ((~b5 /\ bit5 a2)
                   => T
                   | ((b5 /\ ~(bit5 a2))
                      => F
                      | ((~b4 /\ bit4 a2)
                         => T
                         | ((b4 /\ ~(bit4 a2))
                            => F
                            | ((~b3 /\ bit3 a2)
                               => T
                               | ((b3 /\ ~(bit3 a2))
                                  => F
                                  | ((~b2 /\ bit2 a2)
                                     => T
                                     | ((b2 /\ ~(bit2 a2))
                                        => F
                                        | ((~b1 /\ bit1 a2)
                                           => T
                                           | ((b1 /\ ~(bit1 a2))
                                              => F
                                              | ((~b0 /\ bit0 a2)
                                                 => T
                                                 | F)))))))))))))))
empty_str_DEF
|- (empty_str "" = T) /\ (!s a. empty_str (STRING a s) = F)
first_char_DEF
|- !s a. first_char (STRING a s) = a
rest_string_DEF
|- !s a. rest_string (STRING a s) = s
ltstring_DEF
|- (!s2. ltstring "" s2 = ~(empty_str s2)) /\
   (!a s s2.
     ltstring (STRING a s) s2 =
     ((a = first_char s2)
      => (ltstring s (rest_string s2))
      | (ltascii a (first_char s2))))
string_size_DEF
|- (string_size "" = INT 0) /\
   (!s a. string_size (STRING a s) = INT 1 plus string_size s)
ord_char_DEF
|- !b0 b1 b2 b3 b4 b5 b6 b7.
     ord_char (ASCII b7 b6 b5 b4 b3 b2 b1 b0) =
     INT
       ((b7 => 128 | 0) +
        (b6 => 64 | 0) +
        (b5 => 32 | 0) +
        (b4 => 16 | 0) +
        (b3 => 8 | 0) +
        (b2 => 4 | 0) +
        (b1 => 2 | 0) +
        (b0 => 1 | 0))
ord_str_DEF
|- !s a. ord_str (STRING a s) = ord_char a
getchar_DEF
|- !i.
     getchar i =
     (let b7 = ((i below INT 128) => F | T)
      in
      let i2 = i minus (b7 => (INT 128) | (INT 0))
      in
      let b6 = ((i2 below INT 64) => F | T)
      in
      let i3 = i2 minus (b6 => (INT 64) | (INT 0))
      in
      let b5 = ((i3 below INT 32) => F | T)
      in
      let i4 = i3 minus (b5 => (INT 32) | (INT 0))
      in
      let b4 = ((i4 below INT 16) => F | T)
      in
      let i5 = i4 minus (b4 => (INT 16) | (INT 0))
      in
      let b3 = ((i5 below INT 8) => F | T)
      in
      let i6 = i5 minus (b3 => (INT 8) | (INT 0))
      in
      let b2 = ((i6 below INT 4) => F | T)
      in
      let i7 = i6 minus (b2 => (INT 4) | (INT 0))
      in
      let b1 = ((i7 below INT 2) => F | T)
      in
      let i8 = i7 minus (b1 => (INT 2) | (INT 0))
      in
      let b0 = ((i8 below INT 1) => F | T)
      in
      STRING (ASCII b7 b6 b5 b4 b3 b2 b1 b0) "")

Theorems

ltascii_lemma
|- !b7 b6 b5 b4 b3 b2 b1 b0 c7 c6 c5 c4 c3 c2 c1 c0.
     ltascii (ASCII b7 b6 b5 b4 b3 b2 b1 b0) (ASCII c7 c6 c5 c4 c3 c2 c1 c0) =
     ((~b7 /\ c7)
      => T
      | ((b7 /\ ~c7)
         => F
         | ((~b6 /\ c6)
            => T
            | ((b6 /\ ~c6)
               => F
               | ((~b5 /\ c5)
                  => T
                  | ((b5 /\ ~c5)
                     => F
                     | ((~b4 /\ c4)
                        => T
                        | ((b4 /\ ~c4)
                           => F
                           | ((~b3 /\ c3)
                              => T
                              | ((b3 /\ ~c3)
                                 => F
                                 | ((~b2 /\ c2)
                                    => T
                                    | ((b2 /\ ~c2)
                                       => F
                                       | ((~b1 /\ c1)
                                          => T
                                          | ((b1 /\ ~c1)
                                             => F
                                             | ((~b0 /\ c0)
                                                => T
                                                | F)))))))))))))))