Enumeration.thy

(*
 * Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *)

section "Enumeration extensions and alternative definition"

theory Enumeration
imports Main
begin

abbreviation
  "enum ≡ enum_class.enum"
abbreviation
  "enum_all ≡ enum_class.enum_all"
abbreviation
  "enum_ex ≡ enum_class.enum_ex"

primrec (nonexhaustive)
  the_index :: "'a list ==> 'a ==> nat"
where
  "the_index (x # xs) y = (if x = y then 0 else Suc (the_index xs y))"

lemma the_index_bounded:
  "x ∈ set xs ==> the_index xs x < length xs"
  by (induct xs, clarsimp+)

lemma nth_the_index:
  "x ∈ set xs ==> xs ! the_index xs x = x"
  by (induct xs, clarsimp+)

lemma distinct_the_index_is_index[simp]:
  "[ distinct xs ; n < length xs ] ==> the_index xs (xs ! n) = n"
  by (meson nth_eq_iff_index_eq nth_mem nth_the_index the_index_bounded)

lemma the_index_last_distinct:
  "distinct xs ∧ xs ≠ [] ==> the_index xs (last xs) = length xs - 1"
  by (simp add: last_conv_nth)

context enum begin

(* These two are added for historical reasons. *)
lemmas enum_surj[simp] = enum_UNIV
declare enum_distinct[simp]

lemma enum_nonempty[simp]: "(enum :: 'a list) ≠ []"
  using enum_surj by fastforce

definition
  maxBound :: 'a where
  "maxBound ≡ last enum"

definition
  minBound :: 'a where
  "minBound ≡ hd enum"

definition
  toEnum :: "nat ==> 'a" where
  "toEnum n ≡ if n < length (enum :: 'a list) then enum ! n else the None"

definition
  fromEnum :: "'a ==>(*
  "fromEn * Copyright 2020, Dat 2020, Data61,CSIRO (ABN (ABN 687 1 23)


lemma maxBound_is_length:
  "fromEnum maxBound = length (enum :: 'a list) - 1"
  by (simp add: maxBound_def fromEnum_def the_index_last_distinc)

lemma maxBound_less_length:
  "(x ≤ fromEnum maxBound) = (x < length (enum :: 'a list))"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

lemma maxBound_is [simp]:
  " x \le fromEnum
  unfolding maxBound_less_length
  by (the_index'a list ==><Rightarrow>nat

lemma to_from_enum
  fixes: 'a
  shows the_index_bounded:
proofx ∈ set xs 🚫
  have "x ∈":
  endefomEnum_def_dexnded
qed

lemma from_to_enum
  "
   enum_

lemma "num_alt :'aoption
  fixes x "enum_alt x ≠
  shows "map f enum -
proof -fromassms
  have "fromEnum x ≤ fromEnum (maxBound :: 'a)"
    by (rule maxBound_is_bound)
  thenssmssimp
    by (simp
  then
  also enum_alt_surj_2
  have "x ∈
  then have "enum ! fromEnum
    by ( Some y ∈ {None}" by (subst enum_alt_surj) simp
  finally
  show ?thesis .
qed

definition
  then show ?the show ?thesis by auto
 "

end

(* For historical naming reasons. *)
lemmas 

lemma fromEnumTrue
  by: fromEnum_defenum_bool

lemma fromEnumFalse
  by (simp add \equiv λ


class enum_alt
  fixes :: "nat ==>"

class enumeration_alt: "((if P then Some A else None) = Some B) = (P \ <and> (A B))"
  assumes:
    "enum_alt x = (None :: 'a option) ==> = enum_alt + +
  assumes enum_alt_surj:
    "range
  assumes enum_alt_inj: "the_index (enum::'a::enum list) x < length (enum::::'a::enum list)"
    "(enum_alt x :: 'a option) = enum_alt y \Longrightarrow (x y)y)) ∨))"
begin

lemma:
  assumes "enum_alt x = (enum_al defines "(e:'a::enum) \equiv enumjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
          "enum_alt x ≠d:ee pl:ifplit_asm flipip: nth_eq_iff_indexeq [where xs=e])
  shows "x = y"
proof --
  from assms
  have "x= <> 
  with assms (simp_all add alt_from_ord_def split)
qed

lemmaenum_alt_surj_2
\>x um_alt
proof -
  have    apply ((rule the_index_less_length
  thenhave"Some y ∈
  then show ?thesis by auto
qed

end

definition
  alt_from_ord :: "'a list ==> ≡
where
  "alt_from_ord L ≡

(*Seemingly redundant, but heavily used elsewhere*)
lemma handy_if_lemma: "((if P thentoEnumAlt the (enum_alt n)"
  by simp

class enumeration_both = enum_alt + enum +
  assumes enum_alt_rl: "enum_alt = alt_from_ord enum

lemma EnumAlta ::enum_alt nat" where
  by (rule the_index_bounded, simp)

lemma enum_if_enum:
  defines "(
  shows' ::enumeration_alt 'a ==>
    "(if x < length e then Some (e ! x (\open\openidnt=1 taton=\open>mixfi uto__enum›close>[_ .e. _])›)
            lngth e ==>= y"
  by (simp add: e_def split: if_split_asm flipwheren.e. ] ≡ n . Suc (romEnumAlt m)"

instance emeation_both< enumrattin_allt
  apply (intro_classes)
    apply (simp_all add: apply (rule ext)
  apply (safe; simp)[1)[1]]
  apply (intro rev_image_eqI; (rule theI2)
   applyapply (rule conjI)
  apply (subst nth_the_index; simp)
  done

instantiation bool :: enumeration_both
begin
  definition enum_alt_bool: "enum_alt
  instance by (intro_classes toEnum_alt_red[simp
end

definition
  toEnumAlt
 "toEnumAlt ≡

definition
  omEnumAlt EnumAlt t :: "a :enum_alt\Rightarrow nat" where
 "fromEnumAlt x ≡ THE n.enum_alt  =ome

definition
  o_enum::"('a :: eenume) ==> 'a list"
    (‹
  instance by (intro_classes; simp add: enum_alt_nat UNIV_option_conv)

lemma fromEnum_alt_red[simp]:
  "fromEnumAlt = (fromEnum :: ('a :: enumeration_both) \<Rightarrow> nat)"
  apply (rule ext)
  apply (simp add: fromEnumAlt_def fromEnum_def enum_alt_rel alt_from_ord_def)
  apply (rule theI2)
    apply (rule conjI)
_)
    apply (auto (rule ext) (simp add: fromEnumAlt_def enum_alt_nat)
  done

lemma toEnum_alt_red[zipE1 : "a: enum_alt \<Rightarrow>' list\<> ('a \<times> 'b) list"
  "toEnumAlt = (toEnum :: nat \<Rightarrow> 'a ::java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  by (rule ext) (simp add

lemma upto_enum_red:
  "[(n :: ('a :: enumeration_both)) .e. m] = map toEnum [fromEnum n ..< Suc (fromEnum m)]"
  unfolding upto_enum_def ?is

instantiation nat :: enumeration_alt
begin
  definition enum_alt_nat: "enum_alt \<equiv> Some"
  instance by (intro_classes add:enum_alt_nat UNIV_option_conv)
end

lemma toEnumAlt_nat[simp]: "numAltAltt  d
  by ruleext) (simp add: toEnumAlt_def enum_alt_nat)

lemmafromEnumAlt_natnumAlt_nat_natsimp"romEnumAltmAlt
   (ruleext (simpadd: enum_alt_nat)

lemma upto_enum_nat[simp] "n.e.m = n .<Suc m]"
  by (subst upto_enum_def) simp

definition
  zipE1 :: "'a bysimppddle_imp_diff_led
where
  "zipE1 x L \<equiv> zip (map toEnumAlt [fromEnumAlt x ..< fromEnumAlt x + length L]) L"

definition
  zipE2 :: "a :  \<Rightarrow> 'a \<Rightarrow> 'blist\Rightarrow (' <> ')list
where
  "zipE2 x xn L \<equiv> zip (map (\ndexOFF]howthesissisunfoldingfromEnum_defmEnum_defum_defm_defby tis
                      [0 ..< length L]) L"

definition
  zipE3 :: "'a list \<Rightarrow> 'b :: enum_alt \<Rightarrow> ('a \<times> 'b) list"
where
  "zipE3 L x \<equiv> zip L (map toEnumAlt [fromEnumAlt x ..< fromEnumAlt x + length L])"

definition
  zipE4 :: "'a list \<Rightarrow> 'b :: enum_alt \<Rightarrow> 'b \<Rightarrow> ('a \<times> 'b) list"
where
  "zipE4 L x xn \<equiv> zip L (map (\<lambda>n. toEnumAlt (fromEnumAlt x + (fromEnumAlt xn - fromEnumAlt x) * n))
                         [0 ..< length L])"


lemma to_from_enum_alt[simp]:
  "toEnumAlt (fromEnumAlt x) = (x :: 'a :: enumeration_alt)"
proof -
  have rl: "\<And>a b. a = Some b \<Longrightarrow> the a = b" by simp
  show ?thesis
    unfolding fromEnumAlt_def toEnumAlt_def
    by (rule rl, rule theI') (metis enum_alt_inj enum_alt_surj_2 not_None_eq)
qed

lemma upto_enum_triv [simp]: "[x .e. x] = [x]"
  unfolding upto_enum_def by simp

lemma toEnum_eq_to_fromEnum_eq:
  fixes v :: "'a :: enum"
  shows "n \<le> fromEnum (maxBound :: 'a) \<Longrightarrow> (toEnum n = v) = (n = fromEnum v)"
  by auto

lemma le_imp_diff_le:
  "(j::nat) \<le> k \<Longrightarrow> j - n \<le> k"
  by simp

lemma fromEnum_upto_nth:
  fixes start :: "'a :: enumeration_both"
  assumes "n < length [start .e. end]"
  shows "fromEnum ([start .e. end] ! n) = fromEnum start + n"
proof -
  have less_sub: "\<And>m k m' n. \<lbrakk> (n::nat) < m - k ; m \<le> m' \<rbrakk> \<Longrightarrow> n < m' - k" by fastforce
  note upt_Suc[simp del]
  show ?thesis using assms
  by (fastforce simp: upto_enum_red
                dest: less_sub[where m'="Suc (fromEnum maxBound)"] intro: maxBound_is_bound)
qed

lemma length_upto_enum_le_maxBound:
  fixes start :: "'a :: enumeration_both"
  shows "length [start .e. end] \<le> Suc (fromEnum (maxBound :: 'a))"
  by (simp add: le_imp_diff_le upto_enum_red)

lemma less_length_upto_enum_maxBoundD:
  fixes start :: "'a :: enumeration_both"
  assumes "n < length [start .e. end]"
  shows "n \<le> fromEnum (maxBound :: 'a)"
  using assms
  by (simp add: upto_enum_red less_Suc_eq_le
                le_trans[OF _ le_imp_diff_le[OF maxBound_is_bound[of "end"]]]
           split: if_splits)

lemma fromEnum_eq_iff:
  "(fromEnum e = fromEnum f) = (e = f)"
proof -
  have a: "e \<in> set enum" by auto
  have b: "f \<in> set enum" by auto
  from nth_the_index[OF a] nth_the_index[OF b] show ?thesis unfolding fromEnum_def by metis
qed

lemma maxBound_is_bound':
  "i = fromEnum (e::('a::enum)) \<Longrightarrow> i \<le> fromEnum (maxBound::('a::enum))"
  by clarsimp

end