(*  Title:      HOL/List.thy

    Author:     Tobias Nipkow

*)

header {* The datatype of finite lists *}

theory List

imports Plain Presburger Recdef Code_Numeral Quotient ATP

uses ("Tools/list_code.ML")

begin

datatype 'a list =

    Nil    ("[]")

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

syntax

  -- {* list Enumeration *}

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

translations

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

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

subsection {* Basic list processing functions *}

primrec

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

  "hd (x # xs) = x"

primrec

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

    "tl [] = []"

  | "tl (x # xs) = xs"

primrec

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

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

primrec

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

    "butlast []= []"

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

primrec

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

    "set [] = {}"

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

primrec

  map :: "('a \<Rightarrow> 'b) \<Rightarrow> 'a list \<Rightarrow> 'b list" where

    "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 :: "'a list \<Rightarrow> 'a list" where

    "rev [] = []"

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

primrec

  filter:: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> 'a list" where

    "filter P [] = []"

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

syntax

  -- {* Special syntax for filter *}

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

translations

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

syntax (xsymbols)

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

syntax (HTML output)

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

primrec

  foldl :: "('b \<Rightarrow> 'a \<Rightarrow> 'b) \<Rightarrow> 'b \<Rightarrow> 'a list \<Rightarrow> 'b" where

    foldl_Nil: "foldl f a [] = a"

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

primrec

  foldr :: "('a \<Rightarrow> 'b \<Rightarrow> 'b) \<Rightarrow> 'a list \<Rightarrow> 'b \<Rightarrow> 'b" where

    "foldr f [] a = a"

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

primrec

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

    "concat [] = []"

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

definition (in monoid_add)

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

  "listsum xs = foldr plus xs 0"

primrec

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

    drop_Nil: "drop n [] = []"

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

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

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

primrec

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

    take_Nil:"take n [] = []"

  | take_Cons: "take n (x # xs) = (case n of 0 \<Rightarrow> [] | Suc m \<Rightarrow> 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 :: "'a list => nat => 'a" (infixl "!" 100) where

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

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

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

primrec

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

    "list_update [] i v = []"

  | "list_update (x # xs) i v = (case i of 0 \<Rightarrow> v # xs | Suc j \<Rightarrow> x # list_update xs j v)"

nonterminals lupdbinds lupdbind

syntax

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

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

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

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

translations

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

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

primrec

  takeWhile :: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> 'a list" where

    "takeWhile P [] = []"

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

primrec

  dropWhile :: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> 'a list" where

    "dropWhile P [] = []"

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

primrec

  zip :: "'a list \<Rightarrow> 'b list \<Rightarrow> ('a \<times> 'b) list" where

    "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 :: "nat \<Rightarrow> nat \<Rightarrow> nat list" ("(1[_..</_'])") where

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

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

definition

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

  "insert x xs = (if x \<in> set xs then xs else x # xs)"

hide_const (open) insert

hide_fact (open) insert_def

primrec

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

    "remove1 x [] = []"

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

primrec

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

    "removeAll x [] = []"

  | "removeAll x (y # xs) = (if x = y then removeAll x xs else y # removeAll x xs)"

primrec

  distinct :: "'a list \<Rightarrow> bool" where

    "distinct [] \<longleftrightarrow> True"

  | "distinct (x # xs) \<longleftrightarrow> x \<notin> set xs \<and> distinct xs"

primrec

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

    "remdups [] = []"

  | "remdups (x # xs) = (if x \<in> set xs then remdups xs else x # remdups xs)"

primrec

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

    replicate_0: "replicate 0 x = []"

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

text {*

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

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

abbreviation

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

  "length \<equiv> size"

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

  "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]))"

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

"splice [] ys = ys" |

"splice xs [] = xs" |

"splice (x#xs) (y#ys) = x # y # splice xs ys"

text{*

\begin{figure}[htbp]

\fbox{

\begin{tabular}{l}

@{lemma "[a,b]@[c,d] = [a,b,c,d]" by simp}\\

@{lemma "length [a,b,c] = 3" by simp}\\

@{lemma "set [a,b,c] = {a,b,c}" by simp}\\

@{lemma "map f [a,b,c] = [f a, f b, f c]" by simp}\\

@{lemma "rev [a,b,c] = [c,b,a]" by simp}\\

@{lemma "hd [a,b,c,d] = a" by simp}\\

@{lemma "tl [a,b,c,d] = [b,c,d]" by simp}\\

@{lemma "last [a,b,c,d] = d" by simp}\\

@{lemma "butlast [a,b,c,d] = [a,b,c]" by simp}\\

@{lemma[source] "filter (\<lambda>n::nat. n<2) [0,2,1] = [0,1]" by simp}\\

@{lemma "concat [[a,b],[c,d,e],[],[f]] = [a,b,c,d,e,f]" by simp}\\

@{lemma "foldl f x [a,b,c] = f (f (f x a) b) c" by simp}\\

@{lemma "foldr f [a,b,c] x = f a (f b (f c x))" by simp}\\

@{lemma "zip [a,b,c] [x,y,z] = [(a,x),(b,y),(c,z)]" by simp}\\

@{lemma "zip [a,b] [x,y,z] = [(a,x),(b,y)]" by simp}\\

@{lemma "splice [a,b,c] [x,y,z] = [a,x,b,y,c,z]" by simp}\\

@{lemma "splice [a,b,c,d] [x,y] = [a,x,b,y,c,d]" by simp}\\

@{lemma "take 2 [a,b,c,d] = [a,b]" by simp}\\

@{lemma "take 6 [a,b,c,d] = [a,b,c,d]" by simp}\\

@{lemma "drop 2 [a,b,c,d] = [c,d]" by simp}\\

@{lemma "drop 6 [a,b,c,d] = []" by simp}\\

@{lemma "takeWhile (%n::nat. n<3) [1,2,3,0] = [1,2]" by simp}\\

@{lemma "dropWhile (%n::nat. n<3) [1,2,3,0] = [3,0]" by simp}\\

@{lemma "distinct [2,0,1::nat]" by simp}\\

@{lemma "remdups [2,0,2,1::nat,2] = [0,1,2]" by simp}\\

@{lemma "List.insert 2 [0::nat,1,2] = [0,1,2]" by (simp add: List.insert_def)}\\

@{lemma "List.insert 3 [0::nat,1,2] = [3,0,1,2]" by (simp add: List.insert_def)}\\

@{lemma "remove1 2 [2,0,2,1::nat,2] = [0,2,1,2]" by simp}\\

@{lemma "removeAll 2 [2,0,2,1::nat,2] = [0,1]" by simp}\\

@{lemma "nth [a,b,c,d] 2 = c" by simp}\\

@{lemma "[a,b,c,d][2 := x] = [a,b,x,d]" by simp}\\

@{lemma "sublist [a,b,c,d,e] {0,2,3} = [a,c,d]" by (simp add:sublist_def)}\\

@{lemma "rotate1 [a,b,c,d] = [b,c,d,a]" by (simp add:rotate1_def)}\\

@{lemma "rotate 3 [a,b,c,d] = [d,a,b,c]" by (simp add:rotate1_def rotate_def eval_nat_numeral)}\\

@{lemma "replicate 4 a = [a,a,a,a]" by (simp add:eval_nat_numeral)}\\

@{lemma "[2..<5] = [2,3,4]" by (simp add:eval_nat_numeral)}\\

@{lemma "listsum [1,2,3::nat] = 6" by (simp add: listsum_def)}

\end{tabular}}

\caption{Characteristic examples}

\label{fig:Characteristic}

\end{figure}

Figure~\ref{fig:Characteristic} shows characteristic examples

that should give an intuitive understanding of the above functions.

*}

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

not for efficient implementations. *}

context linorder

begin

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

  Nil [iff]: "sorted []"

| Cons: "\<forall>y\<in>set xs. x \<le> y \<Longrightarrow> sorted xs \<Longrightarrow> sorted (x # xs)"

lemma sorted_single [iff]:

  "sorted [x]"

  by (rule sorted.Cons) auto

lemma sorted_many:

  "x \<le> y \<Longrightarrow> sorted (y # zs) \<Longrightarrow> sorted (x # y # zs)"

  by (rule sorted.Cons) (cases "y # zs" rule: sorted.cases, auto)

lemma sorted_many_eq [simp, code]:

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

  by (auto intro: sorted_many elim: sorted.cases)

lemma [code]:

  "sorted [] \<longleftrightarrow> True"

  "sorted [x] \<longleftrightarrow> True"

  by simp_all

primrec insort_key :: "('b \<Rightarrow> 'a) \<Rightarrow> 'b \<Rightarrow> 'b list \<Rightarrow> 'b list" where

"insort_key f x [] = [x]" |

"insort_key f x (y#ys) = (if f x \<le> f y then (x#y#ys) else y#(insort_key f x ys))"

definition sort_key :: "('b \<Rightarrow> 'a) \<Rightarrow> 'b list \<Rightarrow> 'b list" where

"sort_key f xs = foldr (insort_key f) xs []"

definition insort_insert_key :: "('b \<Rightarrow> 'a) \<Rightarrow> 'b \<Rightarrow> 'b list \<Rightarrow> 'b list" where

  "insort_insert_key f x xs = (if f x \<in> f ` set xs then xs else insort_key f x xs)"

abbreviation "sort \<equiv> sort_key (\<lambda>x. x)"

abbreviation "insort \<equiv> insort_key (\<lambda>x. x)"

abbreviation "insort_insert \<equiv> insort_insert_key (\<lambda>x. x)"

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_syntax Nil};

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

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

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

  val IfC = Syntax.const @{const_syntax 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 (fold Term.add_free_names [p, e] []) "x", dummyT);

      val e = if opti then singl e else e;

      val case1 = Syntax.const @{syntax_const "_case1"} $ p $ e;

      val case2 =

        Syntax.const @{syntax_const "_case1"} $

          Syntax.const @{const_syntax dummy_pattern} $ NilC;

      val cs = Syntax.const @{syntax_const "_case2"} $ case1 $ case2;

      val ft = Datatype_Case.case_tr false Datatype.info_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 (@{syntax_const "_lc_test"}, _) $ b, qs] =

        let

          val res =

            (case qs of

              Const (@{syntax_const "_lc_end"}, _) => singl e

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

        in IfC $ b $ res $ NilC end

    | lc_tr ctxt

          [e, Const (@{syntax_const "_lc_gen"}, _) $ p $ es,

            Const(@{syntax_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 (@{syntax_const "_lc_gen"}, _) $ p $ es,

            Const (@{syntax_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 [(@{syntax_const "_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

lemma list_nonempty_induct [consumes 1, case_names single cons]:

  assumes "xs \<noteq> []"

  assumes single: "\<And>x. P [x]"

  assumes cons: "\<And>x xs. xs \<noteq> [] \<Longrightarrow> P xs \<Longrightarrow> P (x # xs)"

  shows "P xs"

using `xs \<noteq> []` proof (induct xs)

  case Nil then show ?case by simp

next

  case (Cons x xs) show ?case proof (cases xs)

    case Nil with single show ?thesis by simp

  next

    case Cons then have "xs \<noteq> []" by simp

    moreover with Cons.hyps have "P xs" .

    ultimately show ?thesis by (rule cons)

  qed

qed

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_induct4 [consumes 3, case_names Nil Cons]:

  "length xs = length ys \<Longrightarrow> length ys = length zs \<Longrightarrow> length zs = length ws \<Longrightarrow>

   P [] [] [] [] \<Longrightarrow> (\<And>x xs y ys z zs w ws. length xs = length ys \<Longrightarrow>

   length ys = length zs \<Longrightarrow> length zs = length ws \<Longrightarrow> P xs ys zs ws \<Longrightarrow>

   P (x#xs) (y#ys) (z#zs) (w#ws)) \<Longrightarrow> P xs ys zs ws"

proof (induct xs arbitrary: ys zs ws)

  case Nil then show ?case by simp

next

  case (Cons x xs ys zs ws) then show ?case by ((cases ys, simp_all), (cases zs,simp_all)) (cases ws, 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(@{const_name Nil},_)) acc = acc

  | len (Const(@{const_name Cons},_) $ _ $ xs) (ts,n) = len xs (ts,n+1)

  | len (Const(@{const_name append},_) $ xs $ ys) acc = len xs (len ys acc)

  | len (Const(@{const_name rev},_) $ xs) acc = len xs acc

  | len (Const(@{const_name 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

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, no_atp]:

 "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, induct_simp]: "(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, induct_simp]: "(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,no_atp]: "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(@{const_name Cons},_) $ _ $ xs) =

  (case xs of Const(@{const_name Nil},_) => cons | _ => last xs)

  | last (Const(@{const_name append},_) $ _ $ ys) = last ys

  | last t = t;

fun list1 (Const(@{const_name Cons},_) $ _ $ Const(@{const_name Nil},_)) = true

  | list1 _ = false;

fun butlast ((cons as Const(@{const_name Cons},_) $ x) $ xs) =

  (case xs of Const(@{const_name Nil},_) => xs | _ => cons $ butlast xs)

  | butlast ((app as Const(@{const_name append},_) $ xs) $ ys) = app $ butlast ys

  | butlast xs = Const(@{const_name 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(@{const_name 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_global @{theory} "list_eq" ["(xs::'a list) = ys"] (K list_eq);

end;

Addsimprocs [list_eq_simproc];

*}

subsubsection {* @{text map} *}

lemma hd_map:

  "xs \<noteq> [] \<Longrightarrow> hd (map f xs) = f (hd xs)"

  by (cases xs) simp_all

lemma map_tl:

  "map f (tl xs) = tl (map f xs)"

  by (cases xs) simp_all

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_map [simp]: "map f (map g xs) = map (f \<circ> g) xs"

by (induct xs) auto

lemma map_comp_map[simp]: "((map f) o (map g)) = map(f o g)"

apply(rule ext)

apply(simp)

done

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 \<Longrightarrow> (\<And>x. x \<in> set ys \<Longrightarrow> f x = g x) \<Longrightarrow> map f xs = map g ys"

  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:

  assumes "map f xs = map g ys"

  shows "length xs = length ys"

using assms proof (induct ys arbitrary: xs)

  case Nil then show ?case by simp

next

  case (Cons y ys) then obtain z zs where xs: "xs = z # zs" by auto

  from Cons xs have "map f zs = map g ys" by simp

  moreover with Cons have "length zs = length ys" by blast

  with xs show ?case by simp

qed

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)

type_mapper map

  by 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] = {i..<j}"

by (induct j) (simp_all add: atLeastLessThanSuc)

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 \<in> set xs \<longleftrightarrow> (\<exists>ys zs. xs = ys @ x # zs)"

  by (auto elim: 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