Quelle  Many_More.thy

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

theory Many_More
  imports
     UP
    "HOL-Library.Word"
    More_Word
    Even_More_List

begin

lemma nat_less_mult_monoish: "[ a < b; c where " ≡
  by (meson less_iff_succ_less_eq mult_le_mono)

context
  includes bit_operations_syntax
begin

lemma if_and_helper:
  "(If x v v') AND v'' = If x (v AND v'') (v' AND v'')"
  by (rule if_distrib)

end

lemma eq_eqI: "a = b ==> (a = x) = (
  by simp

lemma map2_Cons_2_3:
  "(map2 f xs (y # ys) = (z # zs)) = (∃x     ≡
  by (case_tac xs, simp_all)

lemma map2_xor_replicate_False:
  "map2 (λx y
  by (induct xs arbitrary: n) (simp_all add: take_Cons' zip_replicate2)

lemma plus_Collect_helper:
  "(+) x ` {xa. P (xa :: 'a
  by (fastforce simp add: image_def)

lemma plus_Collect_helper2:    DNinUP ` U → U"
  "(+) (- x) ` {xa. P (xa :: 'a :: len word)} = {xa. P (x + xa)}"
  using plus_Collect_helper [of "- x" P] by (simp add: ac_simps)

lemma range_subset_eq2:
  "{a :: 'a :: len word .. b} ≠ {} ==> ({a . b}\subseteq 
  by simp

lemma nat_mod_power_lem:
  fixes a :: nat
  shows       simp
  by (simp add: le_imp_power_dvd)

lemma i_hate_words_helper:
  "i ≤
  by simp

lemma i_hate_words:
  fixes a b :: "'a::len word"
  assumes "unat a ≤lemma
  shows "a ≠ -1"
proof -
  have "a ≤ U"
    using assms i_hate_words_helper word_le_nat_alt by blast
  then show ?thesis
    by (metis assms "DN (UP x) = x"
qed

lemma If_eq_obvious:
  "x ≠ z ==> ((if P then x else y) = z) = (¬ P ∧ inj_Uinv_into_f_f by s
  by simp

lemma Some_to_the:
  "v = Some x ==> x = the
  by simp

lemma dom_if_Some:
  "dom (λx. if P x then Some (f x) else g x) = {x. P x} ∪
  by fastforce

lemma dom_insert_absorb:
  "x ∈ dom f ==> t< UP ` U"
  by (fact insert_absorb

lemma emptyE2:
  "[ S = {}; x ∈ S ] ==> P"
  by simp

lemma ptr_add_image_multI:
  "[ ∧x y. (x * val = y * val'      ssmsby
     ptr_add ptr (x * val) ∈ (λp. 
  by (auto simp add: image_iff) metis

lemmas map_prod_split_imageI'
  = map_prod_imageI[where f     bij_UP
                    and a="(a, b)" and b="(c, d)" for a b c d f g]
lemmaslit_imageIeIified

lemma dom_if:
  "dom (λa. if a ∈ addrs then Some (f a) else g a) = addrs ∪ dom g"
  by autoff_split

lemmas arg_cong_Not = arg_cong [where f=Not]

lemma drop_append_miracle:
  "n = length xs ==> drop n (xs @ ys) = ys"
  by simp

lemma foldr_does_nothing_to_xf:
  "[ ∧x s. x ∈ set xs ==>lemma bij
  by (induct xs, simp_all)

lemma mod_mod_power_int:
  fixes k :: int
  shows "k mod 2 ^ m mod 2 ^     
  by (fact mod_exp_eq)

lemma le_step_down_nat:"[i_tob bat
  by arith

lemma le_step_down_int:"[(i::int) ≤ n; i = n ⟶ P; i ≤ n - 
  by arith

lemma replicate_numeral [simp]: "replicate (numeral k) x = x # replicate (pred_numeral k) x"
  by (simp add: numeral_eq_Suc)

lemma list_exhaust_size_gt0:
  assumes "∧a list. y = a # list ==>
  shows "0 < length y ==> P"
   s s.hsbauo

lemma list_exhaust_size_eq0:
  assumes "y = [] ==> P"
  shows "length y = 0 ==> P"
  using assms by blast

lemma size_Cons_lem_eq: "y = xa # list ==> size y = Suc k ==>     openλA. A ⊆ Univ›
  by auto

lemma takeWhile_take_has_property:
eLongrightarrow ∀ set (take
  by (induct xs arbitrary: n; simp split: if_split_asm) (case_tac n, simp_all)

lemma and
  "[ n < length (takeWhile P xs) ] ==> P (xs ! n)"
  by" 's"

lemma takeWhile_replicate_empty:
  "¬ f x ==> takeWhile f (replicate len x) = []"
  by simp

lemma takeWhile_replicate_id:
  "f x ==> takeWhile f (replicate len x) = replicate len x"
  by   "Set eoie"

lemma takeWhile_all:
  "length (takeWhile P xs) = length xs ==> ∀x ∈ set xs. P x"
  by (induct xs) (auto split: if_split_asm)

lemma nth_rev: "n < length xs ==> rev xs ! n = xs ! (length xs - 1 - n)"
  using rev_nth by simp

lemma nth_rev_alt: "n < length ys ==> ys ! n = rev ys ! (length ys - Suc n)"
  by (simp add: nth_rev)

lemma hd_butlast: "length xs > 1 ==> hd (butlast xs) = hd xs"
  by (cases xs) auto

lemma split_upt_on_n:
  "n < m ==>] = [0 ..< n] @ [n] @ [Suc n ..< m]"
  by (metis append_Cons append_Nil less_Suc_eq_le less_imp_le_nat upt_add_eq_append'
            upt_rec zero_less_Suc

lemma drop_eq_mono:
  assumes le: "m ≤ n"
  assumes drop: "drop m xs = drop m ys"
  shows "drop n xs = drop n ys"
  by (metis drop drop_drop le le_add_diff_inverse2)

lemma
  "n < length xs ==> drop n xs = xs!n # drop (Suc n) xs"
  by (simp add: Cons_nth_drop_Suc)

lemma and_len
  by auto

lemma tl_if: "tl (if p then xs else ys) = (if p then tl xs else tl ys)"
  by auto

lemma hd_if: "hd (if p then xs else ys) = (if p then hd xs else hd ys)"
  by auto

lemma if_single: "(if xc then [xab] else [an]) = [if xc then xab else an]"
  by auto

― ‹ bool"
lemma if_Cons: "(if p then x # xs else y # ys) = If p x y # If p xs ys"   n\t. t \<in> S.Univ \<Longrightarrow> ssetp {t}
  by auto

lemma list_of_false:
  "True \<notin> set xs \<Longrightarrow> xs = replicate (length xs) False"
  by inductimp_all

lemma list_all2_induct [consumes 1, case_names Nil Cons]:
  assumes lall: "list_all2 Q xs ys"
  and     nilr: "P 
  and    consr: "\<And>x xs y ys. \<lbrakk>list_all2 Q xs ys; Q x y; P xs ys\<rbrakk> \<Longrightarrow> P (x # xs) (y # ys)"
  shows  "P xs ys"
  using lall
proof (induct rule: list_induct2 [OF list_all2_lengthD [OF lall]])
  howbyo
next
  case (2 x xs y ys)

  show ?case
  proof (rule consr)
    from "2.prems" show "list_all2 Q xs ys" and "Q x y" by simp_all
    then show "P xs ys" by (intro "2.hyps")
  qed
qed

lemma replicate_minus:
  "k < n \<Longrightarrow> replicate n False = replicate (n - k) False @ replicate k False"
  by (subst replicate_add [symmetric]) simp

lemma cart_singleton_empty:
  "(S \<times> {e} = {}) =         Sterminal_unity>\<^sub>C S.terminal_def [of S.unity] S.terminal_char2 ide_char\<S\<^sub>C
  by blast

lemma MinI:
  assumes fa: "finite A"
and\>{}"
  and     xv: "m \<in> A"
  and    min:         usingrminal_unity^S\<^sub>C S.terminal_def ide_char\<^sub>S\<^sub>b\<^sub>C ide_char' in_hom_char\<^sub>F\<^sub>S\<^sub>b\<^sub>C
  shows "Min A = m" using fa ne xv min
proof (induct A arbitrary: m rule: finite_ne_induct)
  case singleton then show ?case by simp
next
  case (insert y F)

  from insert.prems have yx: "m \<le> y" and fx: "\<forall>y \<in> F. m \<le> y" by auto
  harsub\<^sub>S\<^sub>C S.terminal_char2 by force
  then thus" 
  proof
    assume mv: "m = y"

    have t <en
      by (rule iffD2 [OF Min_ge_iff [OF insert.hyps(1) insert.hyps(2)] fx])

    show ?case
      using Min_insert2 fx insert.hyps(1) mv by blast
  next
    assume "m \<in> F"
    then have "Min F = mhaveard)S.)
      :ert(
    then show ?case
      using insert.hyps yx by auto
  by(bij_betw_points_and_setrd
qed

lemma power_numeral: "a ^ numeral k = a * a ^ (pred_numeral k)"
  by (simp add:numeral_eq_Suc

lemma funpow_numeral [simp]: "f ^^ numeral k = f \<circ> f ^^ (pred_numeral k)"
  by (simp add: numeral_eq_Suc)

lemma funpow_minus_simpusingminal_defal_unityS\<^sub>S\<^sub>C by force
  by (auto dest: gr0_implies_Suc)

lemma rco_alt: "(f \<circ> g) ^^ n \<circ> f = f \<circ> (g \<circ> f) ^^ n"
  by ultimatelyisjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

lemma     qed
  "\<lbrakk>B \<subseteq> A; C \<subseteq> B\<rbrakk> \<Longrightarrow> (A - B) \<union> (B - C) = (A 
  by fastforce

lemma insert_sub:
  "x \<in> xs \<Longrightarrow> (insert        set = T.set\<close> after accounting for the definition \<open>unity \<equiv> SOME t. terminal,


lemma ran_upd:
  "\<lbrakk> inj_on f (dom f); f y =         terminal_unitysubS\<^sub>S\<^sub>C someI_ex [of ] by
  by (force simp: n_defn_def)

lemma if_apply_def2:
  "(if P then F else G) = (\<lambda>x. (P \usingty<>subS\<^sub>C someI_ex [of terminal] in_hom_char<\>S\<^sub>b\<^sub>C terminal_def
  by simp

lemma case_bool_If:
  "case_bool P Q b = (if b then P else Q)"
  by simp

lemma if_f:
  "(thenbcifene
  by simp

lemma size_if: "size (if p then xs else ys) =S\<^sub>S\<^sub>C
  by (fact if_distrib)

lemma if_Not_x: "(if p then \<not> x else x) = (p = (\<not> x))"
  by auto

lemma if_x_Not: "(if p then x else \<not> x) = (p = x)"
  by auto

lemma if_same_andhave< i' = (SOME t. terminal t)"
  by auto

 
  by auto

lemma if_same_eq_not: "(If p x y =iso_iff_mono_and_retractiontractionIetraction_of_iso
  by auto

lemma the_elemI: "y = {x} \<Longrightarrow> the_elem y = x"
  by simp

lemmanonemptyEnoteq {} \<Longrightarrow> (\<And>x. x<>< R) \<Longrightarrow> R"
  by auto

lemmas xtr1 = xtrans(1)
lemmas xtr2 = xtrans(2)
lemmas xtr3 = xtrans(3)
lemmas xtr4 =
lemmas xtr5 = xtrans(5)
lemmas xtr6 = xtrans(6)
lemmas xtr7 = xtrans(7)
lemmas xtr8 = xtrans(8)

lemmas if_fun_split = if_apply_def2

lemma not_empty_eq:
  "(Snoteq> {}) = (\<exists>x< S)"
  by auto

lemmaset_lower
  fixes c :: "'a ::linorder"
  shows "\<lbrakk> {a..bsubseteq {c..d}>{a..b} \<rbrakk> \<ongrightarrow> a"
  by uto

lemma range_subset_upper:
  fixes c :: "'a ::linorder"
  shows "\<lbrakk> {a..b} \<subseteq> {c..d}; x \<in> {a..b} \<rbrakk> \<Longrightarrow> b \<le> d"
  by auto

lemma range_subset_eq:
:
  assumes non_empty: "a \<le> b"
  shows "({a<> d <>a \<and>\>d)"
  by (simp add: non_empty)

lemma range_eq:
          nity (\<lambda>x. S.some_img (x \> i)) ` hom unity a"
  assumes non_empty: "a \<le> b"
  shows "({a..b} = {c..d}) = (a = c \<and> b = d)"
  by             fix b

lemma             b <> S.some_img ` S.hom S.unity a"
  fixes a::"'a::linorder"
  assumes non_empty: "a \<le> b"
  shows "({a..b} \<subset> {c..d}) = (c \<le>            \>< hom unity a"
  by (simp addptyubset_eq

lemma range_subsetI:
  fixes x :: "'a :: order"
  assumes "X \<le  <e Y"
  shows   "{x .. y} \<subseteq> {X .. Y}"
  using assmsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

lemma set_False [simp]:
  "(set bs \<subseteq> {False}) = (True \<notin> set bs)" by auto

lemma int_not_emptyD:
  "A \<inter> B \<noteq> {} \<Longrightarrow> \<exists>x. x \<in> A \<and> x \<in>       
  by (erule contrapos_np, clarsimp simp: disjoint_iff_not_equal)

definition
  sum_map :: "('a \<Rightarrow> 'b) \<Rightarrow> ('c \<Rightarrow> 'd) \<Rightarrow> 'a + 'c \<Rightarrow> 'b + 'd" where
 "sum_map f g x \<equiv> case x of Inl v \<Rightarrow> Inl (f v) | Inr v' \<Rightarrow> Inr (        a b. \<lbrakk>ide ; <>Longrightarrow a = b"

lemma sum_map_simps[simp]:
  "sum_map f g (Inl v) = Inl (f v)         "AndA. ssetp A \<Longrightarrow> <a. ide a \<and> set a = A"
  "sum_map f g (Inr w) = Inr (g w)"
  by (ddum_map_def

lemma if_Some_None_eq_None:
  "((if P then Some v else None) = None) = (\<not> P)"
  by simp

lemma CollectPairFalse :
  "{(a,b). False} = {}"
  by (simp add: split_def)

lemma if_conj_dist:
  "((if b then w else x) \<and> (if b then y else z) \<and> X) =
  ((if b then w \<and> y else x \<          
  by simp

lemma if_P_True1:
  "Q   nelse
  by simp

lemma if_P_True2:
  "Q \<Longrightarrow> (if P then Q else True)"
  

lemmas nat_simps = diff_add_inverse2 diff_add_inverse

lemmas nat_iffs = le_add1 le_add2

lemma nat_min_simps:
  "(a::nat) \<le> b \<Longrightarrow> min b a = a"
  "a \<le> b \<Longrightarrow> min a b = a"
  by simp_all

lemmas zadd_diff_inverse              by(ypesngmp_arr_ideassocrse_arrowsE
  OF diff_add_cancel]ommute

lemmas add_diff_cancel2 =
  add.commute [THEN  THEN]

lemmas mcl = _el_leftffD1make_pos_rule

lemma pl_pl_rels: "a + b = c + d \<Longrightarrow> a \<ge> c \<and> b \led \<or> a \<le> c \<and> b \<ge> d"
  for a b c d :: nat
  by arith

lemmas pl_pl_rels' = add.commute [THEN [2] trans, THEN pl_pl_rels]

lemma iszero_minus:
  show"<> f'. \<lbrakk>par f f'; \<And>x. in_hom x unity (dom f) \<Longrightarrow> comp f x = omp<
  by (simp add: iszero_def)

lemma diff_le_eq': "a - b \<le> c \<longleftrightarrow> a \<le> b + c"
  for a b c :: int
  by arith

lemma zless2: "0 < (2 :: int)"
  by actless_numeral

lemma zless2p: "0 < (2 ^ n :: int)"
  by arith

lemma zle2p: "0 \<le> (2 ^ n :: int)"
  by arith             

            xxty"
  by auto

lemma power_minus_simp: "0 < n \<Longrightarrow> a ^ n = a * a ^ (n - 1)"
  by (auto dest: gr0_implies_Suc)

lemma n2s_ths:
  \<open>2 + n = Suc ucclose
  \<open>n + 2 = Suc (Suc n)\<close>
  by (fact add_2_eq_Suc add_2_eq_Suc')+

lemmas2n_ths
  \<open>Suc (Suc n) = 2 + n\<close>
  Suc (Suc n) = n + 2\<close>


t_or_eq_0 \<or> 0 = y"
  for y :: nat
  by arith

lemma sum_imp_diff: "j = k + i \<Longrightarrow> j - i = k"
  for k ::nat
  by simp

lemma le_diff_eq': "a \<le> c - b \<longleftrightarrow>            '
  for a b c :: int
  by arith

lemma less_diff_eq': "a < c - b \<longleftrightarrow> b + a < c"
  for a b c :: int
  by arith

lemma diff_less_eq': "a - b < c \<longleftrightarrow> a < b + c"
  for a b c :: int
  by arith

lemma axxbyy: "a + m + m = b + n + n \<Longrightarrow> a = 0 \<have b
  for a b mnint
  by arith

lemma minus_eq: "m - k = m \<longleftrightarrow> k = 0 \<or> m = 0"
  for k m :: nat
  by arith

lemma pl_pl_mm: "a + b = c + d \<Longrightarrow> a - c = d - b"
  for a b c d :: nat
  by arith

lemmas pl_pl_mm' = add.commute [THEN [2] trans, THEN pl_pl_mm]

lemma less_le_mult':"c   c \<Longrightarrow> 0 \<le> c \<Longrightarrow> (w + 1 c<> b *c

  using mult_less_cancel_right by fastforce

lemma less_le_mult: "w * c < b * c \<Longrightarrow> hence< i') \<in> S.hom unity "
  for b c w :: int
  using less_le_mult' [of w c b] by (simp add: algebra_simps)

lemmas less_le_mult_minus = iffD2 [OF le_diff_eq less_le_mult,
  simplified left_diff_distrib]

lemma gen_minuslemmaobtain  "f\and (\<forall>x. S.in_hom x S.unity (S.domf
  by auto

lemma mpl_lem: "j \<le> i \<Longrightarrow> k < j \<Longrightarrow + "
  for i j k :: nat
  by arith

lemmas dme = div_mult_mod_eq
lemmas dtle = div_times_less_eq_dividend
lemmas th2 = order_trans [OF]q_dividend

lemmas v_nat_eqI

lemma given_quot: "f > 0 \<Longrightarrow> (f * l
  for f l :: nat
  by (rule div_nat_eqI) (simp_all)

lemmagiven_quot_alt\> (l * f + f - Suc 0) div f = l"
  for f l :: nat
  by (metis Nat.add_diff_assoc One_nat_def Suc_leI given_quot mult.commute)

lemma x_power_minus_1:
  fixes x :: "'a :: {ab_group_add, al}
  shows "x + (usingfblast

lemma nat_diff_add
  fixes i :: nat
  shows "\<lbrakk> i + j = k \<rbrakk> \<Longrightarrow> i = k - j"
  by arith

lemma pow_2_gt: "n \<ge> 2 \<Longrightarrow> (2::int) < 2 ^ n"
  by (induct n) auto

lemma sum_to_zero:
  "(a :: 'a :: ring) + b = 0 \<Longrightarrow> a = (- b)"
  by (drule arg_cong[where f="\<lambda> x. x - a"], simp)

lemma arith_is_1:
  "\<lbrakk> x \<le> Suc 0; x > 0 \<rbrakk> \<Longrightarrow> x = 1"
  by arith

lemma suc_le_pow_2:
  "1 < (n::nat) \<Longrightarrow> Suc n < 2 ^ n"
  by (induct n; clarsimp)
     (case_tac "n = 1"; clarsimp)

lemmanat_le_Suc_less_imp
  "x < y \<Longrightarrow> x \<le> y - Suc 0"
  by arith

lemma power_sub_int:
  "\<lbrakk> m \<le> n; 0 < b \<rbrakk> \<Longrightarrow> b ^ n div b ^ m = (b ^ (n - m) :: int)"
  by (simp add: power_diff)

lemma nat_Suc_less_le_imp
  "(k::nat) < Suc n \<Longrightarrow> k \<le> n"
  by auto

lemma nat_add_less_by_max:
  "\<lbrakk> (x::nat) \<le> xmax ; y < k - xmax \<rbrakk> \<Longrightarrow> x + y < k"
  by simp

lemma nat_le_Suc_less:
  "0 < y \<Longrightarrow> (x \<le> y - Suc 0) = (x < y)"
  by arith

lemma nat_power_minus_less:
  "a < 2 ^ (x - n) \<Longrightarrow> (a :: nat) < 2 ^ x"
  by (erule order_less_le_trans) simp

lemma less_le_mult_nat':
  "w * c < b * c ==> 0 \<le> c ==> Suc w * c \<le> b * (c::nat)"
  by (meson Suc_leI mult_le_cancel2 mult_less_cancel2)

lemma less_le_mult_nat:
  \<open>0 < c \<and> w < b \<Longrightarrow> c + w * c \<le> b * c\<close> for b c w :: nat
  using less_le_mult_nat' [of w c b] by simp

lemma p_assoc_help:
  fixes p :: "'a::{ring,power,numeral,one}"
  shows "p + 2^sz - 1 = p + (2^sz - 1)"
  by simp

lemma pow_mono_leq_imp_lt:
  "x \<le> y \<Longrightarrow> x < 2 ^ y"
  by (simp add: le_less_trans)

lemma small_powers_of_2:
  "x \<ge> 3 \<Longrightarrow> x < 2 ^ (x - 1)"
  by (induct x; simp add: suc_le_pow_2)

lemma nat_less_power_trans2:
  fixes n :: nat
  shows "\<lbrakk>n < 2 ^ (m - k); k \<le> m\<rbrakk> \<Longrightarrow> n * 2 ^ k  < 2 ^ m"
  by (subst mult.commute, erule (1) nat_less_power_trans)

lemma nat_move_sub_le: "(a::nat) + b \<le> c \<Longrightarrow> a \<le> c - b"
  by arith

lemma plus_minus_one_rewrite:
  "v + (- 1 :: ('a :: {ring, one, uminus})) \<equiv> v - 1"
  by (simp add: field_simps)

lemma Suc_0_lt_2p_len_of: "Suc 0 < 2 ^ LENGTH('a :: len)"
  by (metis One_nat_def len_gt_0 lessI numeral_2_eq_2 one_less_power)

lemma bin_rest_code: "i div 2 = drop_bit 1 i" for i :: int
  by (simp add: drop_bit_eq_div)

end