Theory "list"

Parents     ind_type pair

Signature

Type Arity
list 1
Constant Type
FLAT :'a list list -> 'a list
LENGTH :'a list -> num
dest_list :'a list -> 'a recspace
LAST :'a list -> 'a
MAP2 :('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
EL :num -> 'a list -> 'a
HD :'a list -> 'a
TL :'a list -> 'a list
FOLDL :('b -> 'a -> 'b) -> 'b -> 'a list -> 'b
FOLDR :('a -> 'b -> 'b) -> 'b -> 'a list -> 'b
UNZIP :('a # 'b) list -> 'a list # 'b list
list_size :('a -> num) -> 'a list -> num
EVERY :('a -> bool) -> 'a list -> bool
NULL :'a list -> bool
list0 :'a list
list1 :'a -> 'a list -> 'a list
FRONT :'a list -> 'a list
REVERSE :'a list -> 'a list
FILTER :('a -> bool) -> 'a list -> 'a list
list_case :'b -> ('a -> 'a list -> 'b) -> 'a list -> 'b
MAP :('a -> 'b) -> 'a list -> 'b list
MEM :'a -> 'a list -> bool
NIL :'a list
EXISTS :('a -> bool) -> 'a list -> bool
APPEND :'a list -> 'a list -> 'a list
SUM :num list -> num
ZIP :'a list # 'b list -> ('a # 'b) list
mk_list :'a recspace -> 'a list
CONS :'a -> 'a list -> 'a list

Definitions

MAP2
|- (!f. MAP2 f [] [] = []) /\
   !f h1 t1 h2 t2. MAP2 f (h1::t1) (h2::t2) = f h1 h2::MAP2 f t1 t2
EL
|- (!l. EL 0 l = HD l) /\ !l n. EL (SUC n) l = EL n (TL l)
EXISTS_DEF
|- (!P. SOME_EL P [] = F) /\ !P h t. SOME_EL P (h::t) = P h \/ SOME_EL P t
EVERY_DEF
|- (!P. ALL_EL P [] = T) /\ !P h t. ALL_EL P (h::t) = P h /\ ALL_EL P t
FOLDL
|- (!f e. FOLDL f e [] = e) /\ !f e x l. FOLDL f e (x::l) = FOLDL f (f e x) l
FOLDR
|- (!f e. FOLDR f e [] = e) /\ !f e x l. FOLDR f e (x::l) = f x (FOLDR f e l)
FILTER
|- (!P. FILTER P [] = []) /\
   !P h t. FILTER P (h::t) = (if P h then h::FILTER P t else FILTER P t)
MEM
|- (!x. IS_EL x [] = F) /\ !x h t. IS_EL x (h::t) = (x = h) \/ IS_EL x t
MAP
|- (!f. MAP f [] = []) /\ !f h t. MAP f (h::t) = f h::MAP f t
LENGTH
|- (LENGTH [] = 0) /\ !h t. LENGTH (h::t) = SUC (LENGTH t)
FLAT
|- (FLAT [] = []) /\ !h t. FLAT (h::t) = APPEND h (FLAT t)
APPEND
|- (!l. APPEND [] l = l) /\ !l1 l2 h. APPEND (h::l1) l2 = h::APPEND l1 l2
SUM
|- (SUM [] = 0) /\ !h t. SUM (h::t) = h + SUM t
TL
|- !h t. TL (h::t) = t
HD
|- !h t. HD (h::t) = h
NULL_DEF
|- (NULL [] = T) /\ !h t. NULL (h::t) = F
list_TY_DEF
|- ?rep.
     TYPE_DEFINITION
       (\a0'.
          !'list'.
            (!a0'.
               (a0' = CONSTR 0 (@v. T) (\n. BOTTOM)) \/
               (?a0 a1.
                  (a0' =
                   (\a0 a1. CONSTR (SUC 0) a0 (FCONS a1 (\n. BOTTOM))) a0
                     a1) /\ 'list' a1) ==>
               'list' a0') ==>
            'list' a0') rep
list_repfns
|- (!a. mk_list (dest_list a) = a) /\
   !r.
     (\a0'.
        !'list'.
          (!a0'.
             (a0' = CONSTR 0 (@v. T) (\n. BOTTOM)) \/
             (?a0 a1.
                (a0' =
                 (\a0 a1. CONSTR (SUC 0) a0 (FCONS a1 (\n. BOTTOM))) a0 a1) /\
                'list' a1) ==>
             'list' a0') ==>
          'list' a0') r =
     (dest_list (mk_list r) = r)
list0_def
|- list0 = mk_list (CONSTR 0 (@v. T) (\n. BOTTOM))
list1_def
|- list1 =
   (\a0 a1.
      mk_list
        ((\a0 a1. CONSTR (SUC 0) a0 (FCONS a1 (\n. BOTTOM))) a0
           (dest_list a1)))
NIL
|- [] = list0
CONS_def
|- CONS = list1
list_case_def
|- (!v f. case v f [] = v) /\ !v f a0 a1. case v f (a0::a1) = f a0 a1
list_size_def
|- (!f. list_size f [] = 0) /\
   !f a0 a1. list_size f (a0::a1) = 1 + (f a0 + list_size f a1)
ZIP
|- (ZIP ([],[]) = []) /\
   !x1 l1 x2 l2. ZIP (x1::l1,x2::l2) = (x1,x2)::ZIP (l1,l2)
UNZIP
|- (UNZIP [] = ([],[])) /\
   !x l. UNZIP (x::l) = (FST x::FST (UNZIP l),SND x::SND (UNZIP l))
REVERSE_DEF
|- (REVERSE [] = []) /\ !h t. REVERSE (h::t) = APPEND (REVERSE t) [h]
LAST_DEF
|- !h t. LAST (h::t) = (if t = [] then h else LAST t)
FRONT_DEF
|- !h t. BUTLAST (h::t) = (if t = [] then [] else h::BUTLAST t)


Theorems

list_CASES
|- !l. (l = []) \/ ?t h. l = h::t
list_induction
|- !P. P [] /\ (!t. P t ==> !h. P (h::t)) ==> !l. P l
list_Axiom
|- !f0 f1. ?fn. (fn [] = f0) /\ !a0 a1. fn (a0::a1) = f1 a0 a1 (fn a1)
list_INDUCT
|- !P. P [] /\ (!t. P t ==> !h. P (h::t)) ==> !l. P l
NULL
|- NULL [] /\ !h t. ~NULL (h::t)
list_Axiom_old
|- !x f. ?!fn1. (fn1 [] = x) /\ !h t. fn1 (h::t) = f (fn1 t) h t
list_11
|- !a0 a1 a0' a1'. (a0::a1 = a0'::a1') = (a0 = a0') /\ (a1 = a1')
list_distinct
|- !a1 a0. ~([] = a0::a1)
list_case_cong
|- !M M' v f.
     (M = M') /\ ((M' = []) ==> (v = v')) /\
     (!a0 a1. (M' = a0::a1) ==> (f a0 a1 = f' a0 a1)) ==>
     (case v f M = case v' f' M')
list_nchotomy
|- !l. (l = []) \/ ?t h. l = h::t
list_case_compute
|- !l. case b f l = (if NULL l then b else f (HD l) (TL l))
CONS_11
|- !a0 a1 a0' a1'. (a0::a1 = a0'::a1') = (a0 = a0') /\ (a1 = a1')
NOT_NIL_CONS
|- !a1 a0. ~([] = a0::a1)
NOT_CONS_NIL
|- !a1 a0. ~(a0::a1 = [])
LIST_NOT_EQ
|- !l1 l2. ~(l1 = l2) ==> !h1 h2. ~(h1::l1 = h2::l2)
NOT_EQ_LIST
|- !h1 h2. ~(h1 = h2) ==> !l1 l2. ~(h1::l1 = h2::l2)
EQ_LIST
|- !h1 h2. (h1 = h2) ==> !l1 l2. (l1 = l2) ==> (h1::l1 = h2::l2)
CONS
|- !l. ~NULL l ==> (HD l::TL l = l)
APPEND_NIL
|- !l. APPEND l [] = l
APPEND_ASSOC
|- !l1 l2 l3. APPEND l1 (APPEND l2 l3) = APPEND (APPEND l1 l2) l3
LENGTH_APPEND
|- !l1 l2. LENGTH (APPEND l1 l2) = LENGTH l1 + LENGTH l2
MAP_APPEND
|- !f l1 l2. MAP f (APPEND l1 l2) = APPEND (MAP f l1) (MAP f l2)
LENGTH_MAP
|- !l f. LENGTH (MAP f l) = LENGTH l
MAP_EQ_NIL
|- !l f. ((MAP f l = []) = (l = [])) /\ (([] = MAP f l) = (l = []))
EVERY_EL
|- !l P. ALL_EL P l = !n. n < LENGTH l ==> P (EL n l)
EVERY_CONJ
|- !l. ALL_EL (\x. P x /\ Q x) l = ALL_EL P l /\ ALL_EL Q l
EVERY_MEM
|- !P l. ALL_EL P l = !e. IS_EL e l ==> P e
EXISTS_MEM
|- !P l. SOME_EL P l = ?e. IS_EL e l /\ P e
MEM_APPEND
|- !e l1 l2. IS_EL e (APPEND l1 l2) = IS_EL e l1 \/ IS_EL e l2
EVERY_APPEND
|- !P l1 l2. ALL_EL P (APPEND l1 l2) = ALL_EL P l1 /\ ALL_EL P l2
EXISTS_APPEND
|- !P l1 l2. SOME_EL P (APPEND l1 l2) = SOME_EL P l1 \/ SOME_EL P l2
NOT_EVERY
|- !P l. ~ALL_EL P l = SOME_EL ($~ o P) l
NOT_EXISTS
|- !P l. ~SOME_EL P l = ALL_EL ($~ o P) l
MEM_MAP
|- !l f x. IS_EL x (MAP f l) = ?y. (x = f y) /\ IS_EL y l
LENGTH_NIL
|- !l. (LENGTH l = 0) = (l = [])
LENGTH_CONS
|- !l n. (LENGTH l = SUC n) = ?h l'. (LENGTH l' = n) /\ (l = h::l')
LENGTH_EQ_CONS
|- !P n.
     (!l. (LENGTH l = SUC n) ==> P l) =
     !l. (LENGTH l = n) ==> (\l. !x. P (x::l)) l
LENGTH_EQ_NIL
|- !P. (!l. (LENGTH l = 0) ==> P l) = P []
CONS_ACYCLIC
|- !l x. ~(l = x::l) /\ ~(x::l = l)
APPEND_eq_NIL
|- (!l1 l2. ([] = APPEND l1 l2) = (l1 = []) /\ (l2 = [])) /\
   !l1 l2. (APPEND l1 l2 = []) = (l1 = []) /\ (l2 = [])
APPEND_11
|- (!l1 l2 l3. (APPEND l1 l2 = APPEND l1 l3) = (l2 = l3)) /\
   !l1 l2 l3. (APPEND l2 l1 = APPEND l3 l1) = (l2 = l3)
EL_compute
|- !n. EL n l = (if n = 0 then HD l else EL (PRE n) (TL l))
WF_LIST_PRED
|- WF (\L1 L2. ?h. L2 = h::L1)
list_size_cong
|- !M N f f'.
     (M = N) /\ (!x. IS_EL x N ==> (f x = f' x)) ==>
     (list_size f M = list_size f' N)
FOLDR_CONG
|- !l l' b b' f f'.
     (l = l') /\ (b = b') /\ (!x a. IS_EL x l' ==> (f x a = f' x a)) ==>
     (FOLDR f b l = FOLDR f' b' l')
FOLDL_CONG
|- !l l' b b' f f'.
     (l = l') /\ (b = b') /\ (!x a. IS_EL x l' ==> (f a x = f' a x)) ==>
     (FOLDL f b l = FOLDL f' b' l')
MAP_CONG
|- !l1 l2 f f'.
     (l1 = l2) /\ (!x. IS_EL x l2 ==> (f x = f' x)) ==> (MAP f l1 = MAP f' l2)
EXISTS_CONG
|- !l1 l2 P P'.
     (l1 = l2) /\ (!x. IS_EL x l2 ==> (P x = P' x)) ==>
     (SOME_EL P l1 = SOME_EL P' l2)
EVERY_CONG
|- !l1 l2 P P'.
     (l1 = l2) /\ (!x. IS_EL x l2 ==> (P x = P' x)) ==>
     (ALL_EL P l1 = ALL_EL P' l2)
EVERY_MONOTONIC
|- !P Q. (!x. P x ==> Q x) ==> !l. ALL_EL P l ==> ALL_EL Q l
LENGTH_ZIP
|- !l1 l2.
     (LENGTH l1 = LENGTH l2) ==>
     (LENGTH (ZIP (l1,l2)) = LENGTH l1) /\ (LENGTH (ZIP (l1,l2)) = LENGTH l2)
LENGTH_UNZIP
|- !pl.
     (LENGTH (FST (UNZIP pl)) = LENGTH pl) /\
     (LENGTH (SND (UNZIP pl)) = LENGTH pl)
ZIP_UNZIP
|- !l. ZIP (UNZIP l) = l
UNZIP_ZIP
|- !l1 l2. (LENGTH l1 = LENGTH l2) ==> (UNZIP (ZIP (l1,l2)) = (l1,l2))
ZIP_MAP
|- !l1 l2 f1 f2.
     (LENGTH l1 = LENGTH l2) ==>
     (ZIP (MAP f1 l1,l2) = MAP (\p. (f1 (FST p),SND p)) (ZIP (l1,l2))) /\
     (ZIP (l1,MAP f2 l2) = MAP (\p. (FST p,f2 (SND p))) (ZIP (l1,l2)))
MEM_ZIP
|- !l1 l2 p.
     (LENGTH l1 = LENGTH l2) ==>
     (IS_EL p (ZIP (l1,l2)) = ?n. n < LENGTH l1 /\ (p = (EL n l1,EL n l2)))
EL_ZIP
|- !l1 l2 n.
     (LENGTH l1 = LENGTH l2) /\ n < LENGTH l1 ==>
     (EL n (ZIP (l1,l2)) = (EL n l1,EL n l2))
MAP2_ZIP
|- !l1 l2.
     (LENGTH l1 = LENGTH l2) ==>
     !f. MAP2 f l1 l2 = MAP (UNCURRY f) (ZIP (l1,l2))
MEM_EL
|- !l x. IS_EL x l = ?n. n < LENGTH l /\ (x = EL n l)
REVERSE_APPEND
|- !l1 l2. REVERSE (APPEND l1 l2) = APPEND (REVERSE l2) (REVERSE l1)
REVERSE_REVERSE
|- !l. REVERSE (REVERSE l) = l
LAST_CONS
|- (!x. LAST [x] = x) /\ !x y z. LAST (x::y::z) = LAST (y::z)
FRONT_CONS
|- (!x. BUTLAST [x] = []) /\ !x y z. BUTLAST (x::y::z) = x::BUTLAST (y::z)
APPEND_FRONT_LAST
|- !l. ~(l = []) ==> (APPEND (BUTLAST l) [LAST l] = l)