(*  Title:      HOL/List.thy

    ID:         $Id$

    Author:     Tobias Nipkow

*)

header {* The datatype of finite lists *}

theory List

imports ATP_Linkup

uses "Tools/string_syntax.ML"

begin

datatype 'a list =

    Nil    ("[]")

  | Cons 'a  "'a list"    (infixr "#" 65)

subsection{*Basic list processing functions*}

consts

  filter:: "('a => bool) => 'a list => 'a list"

  concat:: "'a list list => 'a list"

  foldl :: "('b => 'a => 'b) => 'b => 'a list => 'b"

  foldr :: "('a => 'b => 'b) => 'a list => 'b => 'b"

  hd:: "'a list => 'a"

  tl:: "'a list => 'a list"

  last:: "'a list => 'a"

  butlast :: "'a list => 'a list"

  set :: "'a list => 'a set"

  map :: "('a=>'b) => ('a list => 'b list)"

  listsum ::  "'a list => 'a::monoid_add"

  nth :: "'a list => nat => 'a"    (infixl "!" 100)

  list_update :: "'a list => nat => 'a => 'a list"

  take:: "nat => 'a list => 'a list"

  drop:: "nat => 'a list => 'a list"

  takeWhile :: "('a => bool) => 'a list => 'a list"

  dropWhile :: "('a => bool) => 'a list => 'a list"

  rev :: "'a list => 'a list"

  zip :: "'a list => 'b list => ('a * 'b) list"

  upt :: "nat => nat => nat list" ("(1[_..</_'])")

  remdups :: "'a list => 'a list"

  remove1 :: "'a => 'a list => 'a list"

  "distinct":: "'a list => bool"

  replicate :: "nat => 'a => 'a list"

  splice :: "'a list \<Rightarrow> 'a list \<Rightarrow> 'a list"

nonterminals lupdbinds lupdbind

syntax

  -- {* list Enumeration *}

  "@list" :: "args => 'a list"    ("[(_)]")

  -- {* Special syntax for filter *}

  "@filter" :: "[pttrn, 'a list, bool] => 'a list"    ("(1[_<-_./ _])")

  -- {* list update *}

  "_lupdbind":: "['a, 'a] => lupdbind"    ("(2_ :=/ _)")

  "" :: "lupdbind => lupdbinds"    ("_")

  "_lupdbinds" :: "[lupdbind, lupdbinds] => lupdbinds"    ("_,/ _")

  "_LUpdate" :: "['a, lupdbinds] => 'a"    ("_/[(_)]" [900,0] 900)

translations

  "[x, xs]" == "x#[xs]"

  "[x]" == "x#[]"

  "[x<-xs . P]"== "filter (%x. P) xs"

  "_LUpdate xs (_lupdbinds b bs)"== "_LUpdate (_LUpdate xs b) bs"

  "xs[i:=x]" == "list_update xs i x"

syntax (xsymbols)

  "@filter" :: "[pttrn, 'a list, bool] => 'a list"("(1[_\<leftarrow>_ ./ _])")

syntax (HTML output)

  "@filter" :: "[pttrn, 'a list, bool] => 'a list"("(1[_\<leftarrow>_ ./ _])")

text {*

  Function @{text size} is overloaded for all datatypes. Users may

  refer to the list version as @{text length}. *}

abbreviation

  length :: "'a list => nat" where

  "length == size"

primrec

  "hd(x#xs) = x"

primrec

  "tl([]) = []"

  "tl(x#xs) = xs"

primrec

  "last(x#xs) = (if xs=[] then x else last xs)"

primrec

  "butlast []= []"

  "butlast(x#xs) = (if xs=[] then [] else x#butlast xs)"

primrec

  "set [] = {}"

  "set (x#xs) = insert x (set xs)"

primrec

  "map f [] = []"

  "map f (x#xs) = f(x)#map f xs"

primrec

  append :: "'a list \<Rightarrow> 'a list \<Rightarrow> 'a list" (infixr "@" 65)

where

  append_Nil:"[] @ ys = ys"

  | append_Cons: "(x#xs) @ ys = x # xs @ ys"

primrec

  "rev([]) = []"

  "rev(x#xs) = rev(xs) @ [x]"

primrec

  "filter P [] = []"

  "filter P (x#xs) = (if P x then x#filter P xs else filter P xs)"

primrec

  foldl_Nil:"foldl f a [] = a"

  foldl_Cons: "foldl f a (x#xs) = foldl f (f a x) xs"

primrec

  "foldr f [] a = a"

  "foldr f (x#xs) a = f x (foldr f xs a)"

primrec

  "concat([]) = []"

  "concat(x#xs) = x @ concat(xs)"

primrec

"listsum [] = 0"

"listsum (x # xs) = x + listsum xs"

primrec

  drop_Nil:"drop n [] = []"

  drop_Cons: "drop n (x#xs) = (case n of 0 => x#xs | Suc(m) => drop m xs)"

  -- {*Warning: simpset does not contain this definition, but separate

       theorems for @{text "n = 0"} and @{text "n = Suc k"} *}

primrec

  take_Nil:"take n [] = []"

  take_Cons: "take n (x#xs) = (case n of 0 => [] | Suc(m) => x # take m xs)"

  -- {*Warning: simpset does not contain this definition, but separate

       theorems for @{text "n = 0"} and @{text "n = Suc k"} *}

primrec

  nth_Cons:"(x#xs)!n = (case n of 0 => x | (Suc k) => xs!k)"

  -- {*Warning: simpset does not contain this definition, but separate

       theorems for @{text "n = 0"} and @{text "n = Suc k"} *}

primrec

  "[][i:=v] = []"

  "(x#xs)[i:=v] = (case i of 0 => v # xs | Suc j => x # xs[j:=v])"

primrec

  "takeWhile P [] = []"

  "takeWhile P (x#xs) = (if P x then x#takeWhile P xs else [])"

primrec

  "dropWhile P [] = []"

  "dropWhile P (x#xs) = (if P x then dropWhile P xs else x#xs)"

primrec

  "zip xs [] = []"

  zip_Cons: "zip xs (y#ys) = (case xs of [] => [] | z#zs => (z,y)#zip zs ys)"

  -- {*Warning: simpset does not contain this definition, but separate

       theorems for @{text "xs = []"} and @{text "xs = z # zs"} *}

primrec

  upt_0: "[i..<0] = []"

  upt_Suc: "[i..<(Suc j)] = (if i <= j then [i..<j] @ [j] else [])"

primrec

  "distinct [] = True"

  "distinct (x#xs) = (x ~: set xs \<and> distinct xs)"

primrec

  "remdups [] = []"

  "remdups (x#xs) = (if x : set xs then remdups xs else x # remdups xs)"

primrec

  "remove1 x [] = []"

  "remove1 x (y#xs) = (if x=y then xs else y # remove1 x xs)"

primrec

  replicate_0: "replicate 0 x = []"

  replicate_Suc: "replicate (Suc n) x = x # replicate n x"

definition

  rotate1 :: "'a list \<Rightarrow> 'a list" where

  "rotate1 xs = (case xs of [] \<Rightarrow> [] | x#xs \<Rightarrow> xs @ [x])"

definition

  rotate :: "nat \<Rightarrow> 'a list \<Rightarrow> 'a list" where

  "rotate n = rotate1 ^ n"

definition

  list_all2 :: "('a => 'b => bool) => 'a list => 'b list => bool" where

  [code func del]: "list_all2 P xs ys =

    (length xs = length ys \<and> (\<forall>(x, y) \<in> set (zip xs ys). P x y))"

definition

  sublist :: "'a list => nat set => 'a list" where

  "sublist xs A = map fst (filter (\<lambda>p. snd p \<in> A) (zip xs [0..<size xs]))"

primrec

  "splice [] ys = ys"

  "splice (x#xs) ys = (if ys=[] then x#xs else x # hd ys # splice xs (tl ys))"

    -- {*Warning: simpset does not contain the second eqn but a derived one. *}

text{* The following simple sort functions are intended for proofs,

not for efficient implementations. *}

context linorder

begin

fun sorted :: "'a list \<Rightarrow> bool" where

"sorted [] \<longleftrightarrow> True" |

"sorted [x] \<longleftrightarrow> True" |

"sorted (x#y#zs) \<longleftrightarrow> x <= y \<and> sorted (y#zs)"

primrec insort :: "'a \<Rightarrow> 'a list \<Rightarrow> 'a list" where

"insort x [] = [x]" |

"insort x (y#ys) = (if x <= y then (x#y#ys) else y#(insort x ys))"

primrec sort :: "'a list \<Rightarrow> 'a list" where

"sort [] = []" |

"sort (x#xs) = insort x (sort xs)"

end

subsubsection {* List comprehension *}

text{* Input syntax for Haskell-like list comprehension notation.

Typical example: @{text"[(x,y). x \<leftarrow> xs, y \<leftarrow> ys, x \<noteq> y]"},

the list of all pairs of distinct elements from @{text xs} and @{text ys}.

The syntax is as in Haskell, except that @{text"|"} becomes a dot

(like in Isabelle's set comprehension): @{text"[e. x \<leftarrow> xs, \<dots>]"} rather than

\verb![e| x <- xs, ...]!.

The qualifiers after the dot are

\begin{description}

\item[generators] @{text"p \<leftarrow> xs"},

 where @{text p} is a pattern and @{text xs} an expression of list type, or

\item[guards] @{text"b"}, where @{text b} is a boolean expression.

%\item[local bindings] @ {text"let x = e"}.

\end{description}

Just like in Haskell, list comprehension is just a shorthand. To avoid

misunderstandings, the translation into desugared form is not reversed

upon output. Note that the translation of @{text"[e. x \<leftarrow> xs]"} is

optmized to @{term"map (%x. e) xs"}.

It is easy to write short list comprehensions which stand for complex

expressions. During proofs, they may become unreadable (and

mangled). In such cases it can be advisable to introduce separate

definitions for the list comprehensions in question.  *}

(*

Proper theorem proving support would be nice. For example, if

@{text"set[f x y. x \<leftarrow> xs, y \<leftarrow> ys, P x y]"}

produced something like

@{term"{z. EX x: set xs. EX y:set ys. P x y \<and> z = f x y}"}.

*)

nonterminals lc_qual lc_quals

syntax

"_listcompr" :: "'a \<Rightarrow> lc_qual \<Rightarrow> lc_quals \<Rightarrow> 'a list"  ("[_ . __")

"_lc_gen" :: "'a \<Rightarrow> 'a list \<Rightarrow> lc_qual" ("_ <- _")

"_lc_test" :: "bool \<Rightarrow> lc_qual" ("_")

(*"_lc_let" :: "letbinds => lc_qual"  ("let _")*)

"_lc_end" :: "lc_quals" ("]")

"_lc_quals" :: "lc_qual \<Rightarrow> lc_quals \<Rightarrow> lc_quals" (", __")

"_lc_abs" :: "'a => 'b list => 'b list"

(* These are easier than ML code but cannot express the optimized

   translation of [e. p<-xs]

translations

"[e. p<-xs]" => "concat(map (_lc_abs p [e]) xs)"

"_listcompr e (_lc_gen p xs) (_lc_quals Q Qs)"

 => "concat (map (_lc_abs p (_listcompr e Q Qs)) xs)"

"[e. P]" => "if P then [e] else []"

"_listcompr e (_lc_test P) (_lc_quals Q Qs)"

 => "if P then (_listcompr e Q Qs) else []"

"_listcompr e (_lc_let b) (_lc_quals Q Qs)"

 => "_Let b (_listcompr e Q Qs)"

*)

syntax (xsymbols)

"_lc_gen" :: "'a \<Rightarrow> 'a list \<Rightarrow> lc_qual" ("_ \<leftarrow> _")

syntax (HTML output)

"_lc_gen" :: "'a \<Rightarrow> 'a list \<Rightarrow> lc_qual" ("_ \<leftarrow> _")

parse_translation (advanced) {*

let

  val NilC = Syntax.const @{const_name Nil};

  val ConsC = Syntax.const @{const_name Cons};

  val mapC = Syntax.const @{const_name map};

  val concatC = Syntax.const @{const_name concat};

  val IfC = Syntax.const @{const_name If};

  fun singl x = ConsC $ x $ NilC;

   fun pat_tr ctxt p e opti = (* %x. case x of p => e | _ => [] *)

    let

      val x = Free (Name.variant (add_term_free_names (p$e, [])) "x", dummyT);

      val e = if opti then singl e else e;

      val case1 = Syntax.const "_case1" $ p $ e;

      val case2 = Syntax.const "_case1" $ Syntax.const Term.dummy_patternN

                                        $ NilC;

      val cs = Syntax.const "_case2" $ case1 $ case2

      val ft = DatatypeCase.case_tr false DatatypePackage.datatype_of_constr

                 ctxt [x, cs]

    in lambda x ft end;

  fun abs_tr ctxt (p as Free(s,T)) e opti =

        let val thy = ProofContext.theory_of ctxt;

            val s' = Sign.intern_const thy s

        in if Sign.declared_const thy s'

           then (pat_tr ctxt p e opti, false)

           else (lambda p e, true)

        end

    | abs_tr ctxt p e opti = (pat_tr ctxt p e opti, false);

  fun lc_tr ctxt [e, Const("_lc_test",_)$b, qs] =

        let val res = case qs of Const("_lc_end",_) => singl e

                      | Const("_lc_quals",_)$q$qs => lc_tr ctxt [e,q,qs];

        in IfC $ b $ res $ NilC end

    | lc_tr ctxt [e, Const("_lc_gen",_) $ p $ es, Const("_lc_end",_)] =

        (case abs_tr ctxt p e true of

           (f,true) => mapC $ f $ es

         | (f, false) => concatC $ (mapC $ f $ es))

    | lc_tr ctxt [e, Const("_lc_gen",_) $ p $ es, Const("_lc_quals",_)$q$qs] =

        let val e' = lc_tr ctxt [e,q,qs];

        in concatC $ (mapC $ (fst(abs_tr ctxt p e' false)) $ es) end

in [("_listcompr", lc_tr)] end

*}

(*

term "[(x,y,z). b]"

term "[(x,y,z). x\<leftarrow>xs]"

term "[e x y. x\<leftarrow>xs, y\<leftarrow>ys]"

term "[(x,y,z). x<a, x>b]"

term "[(x,y,z). x\<leftarrow>xs, x>b]"

term "[(x,y,z). x<a, x\<leftarrow>xs]"

term "[(x,y). Cons True x \<leftarrow> xs]"

term "[(x,y,z). Cons x [] \<leftarrow> xs]"

term "[(x,y,z). x<a, x>b, x=d]"

term "[(x,y,z). x<a, x>b, y\<leftarrow>ys]"

term "[(x,y,z). x<a, x\<leftarrow>xs,y>b]"

term "[(x,y,z). x<a, x\<leftarrow>xs, y\<leftarrow>ys]"

term "[(x,y,z). x\<leftarrow>xs, x>b, y<a]"

term "[(x,y,z). x\<leftarrow>xs, x>b, y\<leftarrow>ys]"

term "[(x,y,z). x\<leftarrow>xs, y\<leftarrow>ys,y>x]"

term "[(x,y,z). x\<leftarrow>xs, y\<leftarrow>ys,z\<leftarrow>zs]"

term "[(x,y). x\<leftarrow>xs, let xx = x+x, y\<leftarrow>ys, y \<noteq> xx]"

*)

subsubsection {* @{const Nil} and @{const Cons} *}

lemma not_Cons_self [simp]:

  "xs \<noteq> x # xs"

by (induct xs) auto

lemmas not_Cons_self2 [simp] = not_Cons_self [symmetric]

lemma neq_Nil_conv: "(xs \<noteq> []) = (\<exists>y ys. xs = y # ys)"

by (induct xs) auto

lemma length_induct:

  "(\<And>xs. \<forall>ys. length ys < length xs \<longrightarrow> P ys \<Longrightarrow> P xs) \<Longrightarrow> P xs"

by (rule measure_induct [of length]) iprover

subsubsection {* @{const length} *}

text {*

  Needs to come before @{text "@"} because of theorem @{text

  append_eq_append_conv}.

*}

lemma length_append [simp]: "length (xs @ ys) = length xs + length ys"

by (induct xs) auto

lemma length_map [simp]: "length (map f xs) = length xs"

by (induct xs) auto

lemma length_rev [simp]: "length (rev xs) = length xs"

by (induct xs) auto

lemma length_tl [simp]: "length (tl xs) = length xs - 1"

by (cases xs) auto

lemma length_0_conv [iff]: "(length xs = 0) = (xs = [])"

by (induct xs) auto

lemma length_greater_0_conv [iff]: "(0 < length xs) = (xs \<noteq> [])"

by (induct xs) auto

lemma length_pos_if_in_set: "x : set xs \<Longrightarrow> length xs > 0"

by auto

lemma length_Suc_conv:

"(length xs = Suc n) = (\<exists>y ys. xs = y # ys \<and> length ys = n)"

by (induct xs) auto

lemma Suc_length_conv:

"(Suc n = length xs) = (\<exists>y ys. xs = y # ys \<and> length ys = n)"

apply (induct xs, simp, simp)

apply blast

done

lemma impossible_Cons: "length xs <= length ys ==> xs = x # ys = False"

  by (induct xs) auto

lemma list_induct2 [consumes 1, case_names Nil Cons]:

  "length xs = length ys \<Longrightarrow> P [] [] \<Longrightarrow>

   (\<And>x xs y ys. length xs = length ys \<Longrightarrow> P xs ys \<Longrightarrow> P (x#xs) (y#ys))

   \<Longrightarrow> P xs ys"

proof (induct xs arbitrary: ys)

  case Nil then show ?case by simp

next

  case (Cons x xs ys) then show ?case by (cases ys) simp_all

qed

lemma list_induct3 [consumes 2, case_names Nil Cons]:

  "length xs = length ys \<Longrightarrow> length ys = length zs \<Longrightarrow> P [] [] [] \<Longrightarrow>

   (\<And>x xs y ys z zs. length xs = length ys \<Longrightarrow> length ys = length zs \<Longrightarrow> P xs ys zs \<Longrightarrow> P (x#xs) (y#ys) (z#zs))

   \<Longrightarrow> P xs ys zs"

proof (induct xs arbitrary: ys zs)

  case Nil then show ?case by simp

next

  case (Cons x xs ys zs) then show ?case by (cases ys, simp_all)

    (cases zs, simp_all)

qed

lemma list_induct2': 

  "\<lbrakk> P [] [];

  \<And>x xs. P (x#xs) [];

  \<And>y ys. P [] (y#ys);

   \<And>x xs y ys. P xs ys  \<Longrightarrow> P (x#xs) (y#ys) \<rbrakk>

 \<Longrightarrow> P xs ys"

by (induct xs arbitrary: ys) (case_tac x, auto)+

lemma neq_if_length_neq: "length xs \<noteq> length ys \<Longrightarrow> (xs = ys) == False"

by (rule Eq_FalseI) auto

simproc_setup list_neq ("(xs::'a list) = ys") = {*

(*

Reduces xs=ys to False if xs and ys cannot be of the same length.

This is the case if the atomic sublists of one are a submultiset

of those of the other list and there are fewer Cons's in one than the other.

*)

let

fun len (Const("List.list.Nil",_)) acc = acc

  | len (Const("List.list.Cons",_) $ _ $ xs) (ts,n) = len xs (ts,n+1)

  | len (Const("List.append",_) $ xs $ ys) acc = len xs (len ys acc)

  | len (Const("List.rev",_) $ xs) acc = len xs acc

  | len (Const("List.map",_) $ _ $ xs) acc = len xs acc

  | len t (ts,n) = (t::ts,n);

fun list_neq _ ss ct =

  let

    val (Const(_,eqT) $ lhs $ rhs) = Thm.term_of ct;

    val (ls,m) = len lhs ([],0) and (rs,n) = len rhs ([],0);

    fun prove_neq() =

      let

        val Type(_,listT::_) = eqT;

        val size = HOLogic.size_const listT;

        val eq_len = HOLogic.mk_eq (size $ lhs, size $ rhs);

        val neq_len = HOLogic.mk_Trueprop (HOLogic.Not $ eq_len);

        val thm = Goal.prove (Simplifier.the_context ss) [] [] neq_len

          (K (simp_tac (Simplifier.inherit_context ss @{simpset}) 1));

      in SOME (thm RS @{thm neq_if_length_neq}) end

  in

    if m < n andalso submultiset (op aconv) (ls,rs) orelse

       n < m andalso submultiset (op aconv) (rs,ls)

    then prove_neq() else NONE

  end;

in list_neq end;

*}

subsubsection {* @{text "@"} -- append *}

lemma append_assoc [simp]: "(xs @ ys) @ zs = xs @ (ys @ zs)"

by (induct xs) auto

lemma append_Nil2 [simp]: "xs @ [] = xs"

by (induct xs) auto

interpretation semigroup_append: semigroup_add ["op @"]

by unfold_locales simp

interpretation monoid_append: monoid_add ["[]" "op @"]

by unfold_locales (simp+)

lemma append_is_Nil_conv [iff]: "(xs @ ys = []) = (xs = [] \<and> ys = [])"

by (induct xs) auto

lemma Nil_is_append_conv [iff]: "([] = xs @ ys) = (xs = [] \<and> ys = [])"

by (induct xs) auto

lemma append_self_conv [iff]: "(xs @ ys = xs) = (ys = [])"

by (induct xs) auto

lemma self_append_conv [iff]: "(xs = xs @ ys) = (ys = [])"

by (induct xs) auto

lemma append_eq_append_conv [simp, noatp]:

 "length xs = length ys \<or> length us = length vs

 ==> (xs@us = ys@vs) = (xs=ys \<and> us=vs)"

apply (induct xs arbitrary: ys)

 apply (case_tac ys, simp, force)

apply (case_tac ys, force, simp)

done

lemma append_eq_append_conv2: "(xs @ ys = zs @ ts) =

  (EX us. xs = zs @ us & us @ ys = ts | xs @ us = zs & ys = us@ ts)"

apply (induct xs arbitrary: ys zs ts)

 apply fastsimp

apply(case_tac zs)

 apply simp

apply fastsimp

done

lemma same_append_eq [iff]: "(xs @ ys = xs @ zs) = (ys = zs)"

by simp

lemma append1_eq_conv [iff]: "(xs @ [x] = ys @ [y]) = (xs = ys \<and> x = y)"

by simp

lemma append_same_eq [iff]: "(ys @ xs = zs @ xs) = (ys = zs)"

by simp

lemma append_self_conv2 [iff]: "(xs @ ys = ys) = (xs = [])"

using append_same_eq [of _ _ "[]"] by auto

lemma self_append_conv2 [iff]: "(ys = xs @ ys) = (xs = [])"

using append_same_eq [of "[]"] by auto

lemma hd_Cons_tl [simp,noatp]: "xs \<noteq> [] ==> hd xs # tl xs = xs"

by (induct xs) auto

lemma hd_append: "hd (xs @ ys) = (if xs = [] then hd ys else hd xs)"

by (induct xs) auto

lemma hd_append2 [simp]: "xs \<noteq> [] ==> hd (xs @ ys) = hd xs"

by (simp add: hd_append split: list.split)

lemma tl_append: "tl (xs @ ys) = (case xs of [] => tl ys | z#zs => zs @ ys)"

by (simp split: list.split)

lemma tl_append2 [simp]: "xs \<noteq> [] ==> tl (xs @ ys) = tl xs @ ys"

by (simp add: tl_append split: list.split)

lemma Cons_eq_append_conv: "x#xs = ys@zs =

 (ys = [] & x#xs = zs | (EX ys'. x#ys' = ys & xs = ys'@zs))"

by(cases ys) auto

lemma append_eq_Cons_conv: "(ys@zs = x#xs) =

 (ys = [] & zs = x#xs | (EX ys'. ys = x#ys' & ys'@zs = xs))"

by(cases ys) auto

text {* Trivial rules for solving @{text "@"}-equations automatically. *}

lemma eq_Nil_appendI: "xs = ys ==> xs = [] @ ys"

by simp

lemma Cons_eq_appendI:

"[| x # xs1 = ys; xs = xs1 @ zs |] ==> x # xs = ys @ zs"

by (drule sym) simp

lemma append_eq_appendI:

"[| xs @ xs1 = zs; ys = xs1 @ us |] ==> xs @ ys = zs @ us"

by (drule sym) simp

text {*

Simplification procedure for all list equalities.

Currently only tries to rearrange @{text "@"} to see if

- both lists end in a singleton list,

- or both lists end in the same list.

*}

ML {*

local

fun last (cons as Const("List.list.Cons",_) $ _ $ xs) =

  (case xs of Const("List.list.Nil",_) => cons | _ => last xs)

  | last (Const("List.append",_) $ _ $ ys) = last ys

  | last t = t;

fun list1 (Const("List.list.Cons",_) $ _ $ Const("List.list.Nil",_)) = true

  | list1 _ = false;

fun butlast ((cons as Const("List.list.Cons",_) $ x) $ xs) =

  (case xs of Const("List.list.Nil",_) => xs | _ => cons $ butlast xs)

  | butlast ((app as Const("List.append",_) $ xs) $ ys) = app $ butlast ys

  | butlast xs = Const("List.list.Nil",fastype_of xs);

val rearr_ss = HOL_basic_ss addsimps [@{thm append_assoc},

  @{thm append_Nil}, @{thm append_Cons}];

fun list_eq ss (F as (eq as Const(_,eqT)) $ lhs $ rhs) =

  let

    val lastl = last lhs and lastr = last rhs;

    fun rearr conv =

      let

        val lhs1 = butlast lhs and rhs1 = butlast rhs;

        val Type(_,listT::_) = eqT

        val appT = [listT,listT] ---> listT

        val app = Const("List.append",appT)

        val F2 = eq $ (app$lhs1$lastl) $ (app$rhs1$lastr)

        val eq = HOLogic.mk_Trueprop (HOLogic.mk_eq (F,F2));

        val thm = Goal.prove (Simplifier.the_context ss) [] [] eq

          (K (simp_tac (Simplifier.inherit_context ss rearr_ss) 1));

      in SOME ((conv RS (thm RS trans)) RS eq_reflection) end;

  in

    if list1 lastl andalso list1 lastr then rearr @{thm append1_eq_conv}

    else if lastl aconv lastr then rearr @{thm append_same_eq}

    else NONE

  end;

in

val list_eq_simproc =

  Simplifier.simproc @{theory} "list_eq" ["(xs::'a list) = ys"] (K list_eq);

end;

Addsimprocs [list_eq_simproc];

*}

subsubsection {* @{text map} *}

lemma map_ext: "(!!x. x : set xs --> f x = g x) ==> map f xs = map g xs"

by (induct xs) simp_all

lemma map_ident [simp]: "map (\<lambda>x. x) = (\<lambda>xs. xs)"

by (rule ext, induct_tac xs) auto

lemma map_append [simp]: "map f (xs @ ys) = map f xs @ map f ys"

by (induct xs) auto

lemma map_compose: "map (f o g) xs = map f (map g xs)"

by (induct xs) (auto simp add: o_def)

lemma rev_map: "rev (map f xs) = map f (rev xs)"

by (induct xs) auto

lemma map_eq_conv[simp]: "(map f xs = map g xs) = (!x : set xs. f x = g x)"

by (induct xs) auto

lemma map_cong [fundef_cong, recdef_cong]:

"xs = ys ==> (!!x. x : set ys ==> f x = g x) ==> map f xs = map g ys"

-- {* a congruence rule for @{text map} *}

by simp

lemma map_is_Nil_conv [iff]: "(map f xs = []) = (xs = [])"

by (cases xs) auto

lemma Nil_is_map_conv [iff]: "([] = map f xs) = (xs = [])"

by (cases xs) auto

lemma map_eq_Cons_conv:

 "(map f xs = y#ys) = (\<exists>z zs. xs = z#zs \<and> f z = y \<and> map f zs = ys)"

by (cases xs) auto

lemma Cons_eq_map_conv:

 "(x#xs = map f ys) = (\<exists>z zs. ys = z#zs \<and> x = f z \<and> xs = map f zs)"

by (cases ys) auto

lemmas map_eq_Cons_D = map_eq_Cons_conv [THEN iffD1]

lemmas Cons_eq_map_D = Cons_eq_map_conv [THEN iffD1]

declare map_eq_Cons_D [dest!]  Cons_eq_map_D [dest!]

lemma ex_map_conv:

  "(EX xs. ys = map f xs) = (ALL y : set ys. EX x. y = f x)"

by(induct ys, auto simp add: Cons_eq_map_conv)

lemma map_eq_imp_length_eq:

  "map f xs = map f ys ==> length xs = length ys"

apply (induct ys arbitrary: xs)

 apply simp

apply (metis Suc_length_conv length_map)

done

lemma map_inj_on:

 "[| map f xs = map f ys; inj_on f (set xs Un set ys) |]

  ==> xs = ys"

apply(frule map_eq_imp_length_eq)

apply(rotate_tac -1)

apply(induct rule:list_induct2)

 apply simp

apply(simp)

apply (blast intro:sym)

done

lemma inj_on_map_eq_map:

 "inj_on f (set xs Un set ys) \<Longrightarrow> (map f xs = map f ys) = (xs = ys)"

by(blast dest:map_inj_on)

lemma map_injective:

 "map f xs = map f ys ==> inj f ==> xs = ys"

by (induct ys arbitrary: xs) (auto dest!:injD)

lemma inj_map_eq_map[simp]: "inj f \<Longrightarrow> (map f xs = map f ys) = (xs = ys)"

by(blast dest:map_injective)

lemma inj_mapI: "inj f ==> inj (map f)"

by (iprover dest: map_injective injD intro: inj_onI)

lemma inj_mapD: "inj (map f) ==> inj f"

apply (unfold inj_on_def, clarify)

apply (erule_tac x = "[x]" in ballE)

 apply (erule_tac x = "[y]" in ballE, simp, blast)

apply blast

done

lemma inj_map[iff]: "inj (map f) = inj f"

by (blast dest: inj_mapD intro: inj_mapI)

lemma inj_on_mapI: "inj_on f (\<Union>(set ` A)) \<Longrightarrow> inj_on (map f) A"

apply(rule inj_onI)

apply(erule map_inj_on)

apply(blast intro:inj_onI dest:inj_onD)

done

lemma map_idI: "(\<And>x. x \<in> set xs \<Longrightarrow> f x = x) \<Longrightarrow> map f xs = xs"

by (induct xs, auto)

lemma map_fun_upd [simp]: "y \<notin> set xs \<Longrightarrow> map (f(y:=v)) xs = map f xs"

by (induct xs) auto

lemma map_fst_zip[simp]:

  "length xs = length ys \<Longrightarrow> map fst (zip xs ys) = xs"

by (induct rule:list_induct2, simp_all)

lemma map_snd_zip[simp]:

  "length xs = length ys \<Longrightarrow> map snd (zip xs ys) = ys"

by (induct rule:list_induct2, simp_all)

subsubsection {* @{text rev} *}

lemma rev_append [simp]: "rev (xs @ ys) = rev ys @ rev xs"

by (induct xs) auto

lemma rev_rev_ident [simp]: "rev (rev xs) = xs"

by (induct xs) auto

lemma rev_swap: "(rev xs = ys) = (xs = rev ys)"

by auto

lemma rev_is_Nil_conv [iff]: "(rev xs = []) = (xs = [])"

by (induct xs) auto

lemma Nil_is_rev_conv [iff]: "([] = rev xs) = (xs = [])"

by (induct xs) auto

lemma rev_singleton_conv [simp]: "(rev xs = [x]) = (xs = [x])"

by (cases xs) auto

lemma singleton_rev_conv [simp]: "([x] = rev xs) = (xs = [x])"

by (cases xs) auto

lemma rev_is_rev_conv [iff]: "(rev xs = rev ys) = (xs = ys)"

apply (induct xs arbitrary: ys, force)

apply (case_tac ys, simp, force)

done

lemma inj_on_rev[iff]: "inj_on rev A"

by(simp add:inj_on_def)

lemma rev_induct [case_names Nil snoc]:

  "[| P []; !!x xs. P xs ==> P (xs @ [x]) |] ==> P xs"

apply(simplesubst rev_rev_ident[symmetric])

apply(rule_tac list = "rev xs" in list.induct, simp_all)

done

lemma rev_exhaust [case_names Nil snoc]:

  "(xs = [] ==> P) ==>(!!ys y. xs = ys @ [y] ==> P) ==> P"

by (induct xs rule: rev_induct) auto

lemmas rev_cases = rev_exhaust

lemma rev_eq_Cons_iff[iff]: "(rev xs = y#ys) = (xs = rev ys @ [y])"

by(rule rev_cases[of xs]) auto

subsubsection {* @{text set} *}

lemma finite_set [iff]: "finite (set xs)"

by (induct xs) auto

lemma set_append [simp]: "set (xs @ ys) = (set xs \<union> set ys)"

by (induct xs) auto

lemma hd_in_set[simp]: "xs \<noteq> [] \<Longrightarrow> hd xs : set xs"

by(cases xs) auto

lemma set_subset_Cons: "set xs \<subseteq> set (x # xs)"

by auto

lemma set_ConsD: "y \<in> set (x # xs) \<Longrightarrow> y=x \<or> y \<in> set xs" 

by auto

lemma set_empty [iff]: "(set xs = {}) = (xs = [])"

by (induct xs) auto

lemma set_empty2[iff]: "({} = set xs) = (xs = [])"

by(induct xs) auto

lemma set_rev [simp]: "set (rev xs) = set xs"

by (induct xs) auto

lemma set_map [simp]: "set (map f xs) = f`(set xs)"

by (induct xs) auto

lemma set_filter [simp]: "set (filter P xs) = {x. x : set xs \<and> P x}"

by (induct xs) auto

lemma set_upt [simp]: "set[i..<j] = {k. i \<le> k \<and> k < j}"

apply (induct j, simp_all)

apply (erule ssubst, auto)

done

lemma split_list: "x : set xs \<Longrightarrow> \<exists>ys zs. xs = ys @ x # zs"

proof (induct xs)

  case Nil thus ?case by simp

next

  case Cons thus ?case by (auto intro: Cons_eq_appendI)

qed

lemma in_set_conv_decomp: "(x : set xs) = (\<exists>ys zs. xs = ys @ x # zs)"

by (metis Un_upper2 insert_subset set.simps(2) set_append split_list)

lemma split_list_first: "x : set xs \<Longrightarrow> \<exists>ys zs. xs = ys @ x # zs \<and> x \<notin> set ys"

proof (induct xs)

  case Nil thus ?case by simp

next

  case (Cons a xs)

  show ?case

  proof cases

    assume "x = a" thus ?case using Cons by fastsimp

  next

    assume "x \<noteq> a" thus ?case using Cons by(fastsimp intro!: Cons_eq_appendI)

  qed

qed

lemma in_set_conv_decomp_first:

  "(x : set xs) = (\<exists>ys zs. xs = ys @ x # zs \<and> x \<notin> set ys)"

by (metis in_set_conv_decomp split_list_first)

lemma split_list_last: "x : set xs \<Longrightarrow> \<exists>ys zs. xs = ys @ x # zs \<and> x \<notin> set zs"

proof (induct xs rule:rev_induct)

  case Nil thus ?case by simp

next

  case (snoc a xs)

  show ?case

  proof cases

    assume "x = a" thus ?case using snoc by simp (metis ex_in_conv set_empty2)

  next

    assume "x \<noteq> a" thus ?case using snoc by fastsimp

  qed

qed

lemma in_set_conv_decomp_last:

  "(x : set xs) = (\<exists>ys zs. xs = ys @ x # zs \<and> x \<notin> set zs)"

by (metis in_set_conv_decomp split_list_last)

lemma split_list_prop: "\<exists>x \<in> set xs. P x \<Longrightarrow> \<exists>ys x zs. xs = ys @ x # zs & P x"

proof (induct xs)

  case Nil thus ?case by simp

next

  case Cons thus ?case

    by(simp add:Bex_def)(metis append_Cons append.simps(1))

qed

lemma split_list_propE:

assumes "\<exists>x \<in> set xs. P x"

obtains ys x zs where "xs = ys @ x # zs" and "P x"

by(metis split_list_prop[OF assms])

lemma split_list_first_prop:

  "\<exists>x \<in> set xs. P x \<Longrightarrow>

   \<exists>ys x zs. xs = ys@x#zs \<and> P x \<and> (\<forall>y \<in> set ys. \<not> P y)"

proof(induct xs)

  case Nil thus ?case by simp

next

  case (Cons x xs)

  show ?case

  proof cases

    assume "P x"

    thus ?thesis by simp (metis Un_upper1 contra_subsetD in_set_conv_decomp_first self_append_conv2 set_append)

  next

    assume "\<not> P x"

    hence "\<exists>x\<in>set xs. P x" using Cons(2) by simp

    thus ?thesis using `\<not> P x` Cons(1) by (metis append_Cons set_ConsD)

  qed

qed

lemma split_list_first_propE:

assumes "\<exists>x \<in> set xs. P x"

obtains ys x zs where "xs = ys @ x # zs" and "P x" and "\<forall>y \<in> set ys. \<not> P y"

by(metis split_list_first_prop[OF assms])

lemma split_list_first_prop_iff:

  "(\<exists>x \<in> set xs. P x) \<longleftrightarrow>

   (\<exists>ys x zs. xs = ys@x#zs \<and> P x \<and> (\<forall>y \<in> set ys. \<not> P y))"

by(metis split_list_first_prop[where P=P] in_set_conv_decomp)

lemma split_list_last_prop:

  "\<exists>x \<in> set xs. P x \<Longrightarrow>

   \<exists>ys x zs. xs = ys@x#zs \<and> P x \<and> (\<forall>z \<in> set zs. \<not> P z)"

proof(induct xs rule:rev_induct)

  case Nil thus ?case by simp

next

  case (snoc x xs)

  show ?case

  proof cases

    assume "P x" thus ?thesis by (metis emptyE set_empty)

  next

    assume "\<not> P x"

    hence "\<exists>x\<in>set xs. P x" using snoc(2) by simp

    thus ?thesis using `\<not> P x` snoc(1) by fastsimp

  qed

qed

lemma split_list_last_propE:

assumes "\<exists>x \<in> set xs. P x"

obtains ys x zs where "xs = ys @ x # zs" and "P x" and "\<forall>z \<in> set zs. \<not> P z"

by(metis split_list_last_prop[OF assms])

lemma split_list_last_prop_iff:

  "(\<exists>x \<in> set xs. P x) \<longleftrightarrow>

   (\<exists>ys x zs. xs = ys@x#zs \<and> P x \<and> (\<forall>z \<in> set zs. \<not> P z))"

by(metis split_list_last_prop[where P=P] in_set_conv_decomp)

lemma finite_list: "finite A ==> EX xs. set xs = A"

apply (erule finite_induct, auto)

apply (metis set.simps(2))

done

lemma card_length: "card (set xs) \<le> length xs"

by (induct xs) (auto simp add: card_insert_if)

lemma set_minus_filter_out:

  "set xs - {y} = set (filter (\<lambda>x. \<not> (x = y)) xs)"

  by (induct xs) auto

subsubsection {* @{text filter} *}

lemma filter_append [simp]: "filter P (xs @ ys) = filter P xs @ filter P ys"

by (induct xs) auto

lemma rev_filter: "rev (filter P xs) = filter P (rev xs)"

by (induct xs) simp_all

lemma filter_filter [simp]: "filter P (filter Q xs) = filter (\<lambda>x. Q x \<and> P x) xs"

by (induct xs) auto

lemma length_filter_le [simp]: "length (filter P xs) \<le> length xs"

by (induct xs) (auto simp add: le_SucI)

lemma sum_length_filter_compl:

  "length(filter P xs) + length(filter (%x. ~P x) xs) = length xs"

by(induct xs) simp_all

lemma filter_True [simp]: "\<forall>x \<in> set xs. P x ==> filter P xs = xs"

by (induct xs) auto

lemma filter_False [simp]: "\<forall>x \<in> set xs. \<not> P x ==> filter P xs = []"

by (induct xs) auto

lemma filter_empty_conv: "(filter P xs = []) = (\<forall>x\<in>set xs. \<not> P x)" 

by (induct xs) simp_all