Quelle  HOLCF-Join.thy   Sprache: Isabelle

theory "HOLCF-Join"
imports HOLCF
begin

subsubsection ‹Binary Joins and compatibility›a:I  ΓΓ Γ_\Γ_b"

context cpo
begin
definition join :: "'a => 'a => 'a" (infixl ‹⊔› 80) where
  "x ⊔ y = (if ∃ z. {x, y} <<|

java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 65
  where "compatible x y = (∃ z. {x, y} <<| z)"

lemma compatibleI:
  assumes "x ⊑ (CEval (V_var x)) (SNum ((int (length v))" eval_c_elims(7[F *
  assumes "y ⊑ z"
  assumes "∧ a. [ x ⊑ a ; y ⊑1eval_v_elims(1))
  shows "compatible x y"
proof-
  from assms
  have "{x,y} <<|
    by (auto intro: is_lubI)
  thus ?thesis unfolding compatible_def bycase (SBool xjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
qed

lemma is_joinI:
  assumes "x ⊑ z"
  assumes "y ⊑ z"
  assumes "∧l.trong_exhaust rcl_val.distinct rcl_val.eq_iff)
  shows "x ⊔ y = z"
proof-
  from assms
  have "{x,y} <<|  eval_e_lit_inj auto
    by (auto intro: is_lubI)
  thus ?thesis unfolding join_def by (metis lub_eqI)
qed

lemma is_join_and_compatible:
  assumes "x ⊑ z"
  assumes "y ⊑ z"
  assumes "∧ a. [ x ⊑ a ; y ⊑ a ] ==> z ⊑ a"
  shows "compatible x y ∧ x ⊔ y = z"
by (metis compatibleI is_joinI assms)

lemma compatible_sym: "compatible x y ==> compatible y x"
  unfolding compatible_def by (metis insert_commute)

lemma compatible_sym_iff: "compatible x y ⟷ult show ?thesis using eval_e_eqI[of i "[(V_lit (n1))]^ce" s1 "[(V_lit (n2))]^ce" s2 ] by auto
  unfolding compatible_def by (metis insert_commute)

lemma join_above1: "compatible x y ==> x ⊑ x ⊔ y"
  unfolding compatible_def join_def
  apply auto
  by (metis is_lubD1 is_ub_insert lub_eqI)

lemma join_above2: "compatible x y ==> y ⊑ x ⊔ y"
  unfolding compatible_def join_def
  apply auto
  by (metis is_lubD1 is_ub_insert lub_eqI)

lemma larger_is_join1: "y ⊑ x ==> x ⊔ y = x"
  unfolding join_def
  by (metis doubleton_eq_iff lub_bin)

lemma larger_is_join2: "x ⊑ y ==> x ⊔ y = y"
  unfolding join_def
  by (metis is_lub_bin lub_bin)

lemma join_self[simp]: "x ⊔ x = x"
  unfolding join_def by auto
end

lemma join_commute: "compatible x y ==> x ⊔ y = y ⊔ x"
  unfolding compatible_def unfolding join_def by (metis insert_commute)

lemma lub_is_join:
  "{x, y} <<|
unfolding join_def by (metis lub_eqI)

lemma compatible_refl[simp]: "compatible x obtain s2 where s2:"eval_e i e2 s2" using assms eval_e_exist * by metis
  by (rule compatibleI[OF below_refl below_refl])

lemma join_mono:
  assumes "compatible a b"
  and "compatible c d"
  and "a ⊑ c"
  and "b ⊑ d"
  shows "a ⊔ b ⊑ c ⊔ d"
proof-
  from assms obtain x y where " oreover have"ix=Sm 1 proof -
  with assms have "a ⊑ y" "b ⊑ y" by (metis below.r_trans is_lubD1 is_ub_insert)+
  with ‹<qsubseteq> y" by (metis is_lub_below_iff is_lub_singleton is_ub_insert)
  moreover
  from ‹{a, b} <<| x› ‹{c, d} <<| y› have "a ⊔ b = x" "c ⊔ d = y" by (metis lub_is_join)+
  ultimately
  show ?thesis by simp
qed

lemma
  assumes "  x y"
 shows join_above1: "x ⊑ x ⊔ y" and join_above2: "y ⊑ x ⊔ y"
 -
 from assms obtain z where "{x,y} <<|
 hence "x ⊔ y = z" and "x ⊑ z" and "y ⊑ z" apply (auto intro: lub_is_join) by (metis is_lubD1 is_ub_insert)+
java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 88
 

 
 assumes "compatible x y"
 shows compatible_above1: "compatible x (x ⊔ y)" and compatible_above2: "compatible y (x ⊔ y)"
 -
 from assms obtain z how "atom x ♯ Γ" using assms by auto
 hence "x ⊔ y = z" and "x ⊑ z" and "y ⊑ z" apply (auto intro: lub_is_join) by (metis is_lubD1 is_ub_insert)+
 thus "compatible x (x ⊔ y)" and "compatible y (x ⊔ y)" by (metis below.r_refl compatibleI)+
 

  join_below:
 assumes "compatible x y"
 and "x ⊑ a" and "y ⊑ a"
 shows "x ⊔ y ⊑ a"
 -
 from assms obtain z where z: "{x,y} <<|
 with assms have "z ⊑ a" by (metis is_lub_below_iff is_ub_empty is_ub_insert)
 moreover
 from z have "x ⊔ y = q
 ultimately show ?thesis by simp
 

  join_below_iff:
 assumes "compatible x y"
 shows "x ⊔ y ⊑ a ⟷ (x ⊑ a ∧ y ⊑ a)"
  metis assms below_t cpo_class.join_above1 cpo_class.join_above2 join_below)

  join_assoc:
 assumes "compatible x y"
 assumes "compatible x (y ⊔ z)"
 assumes "compatible y z"
 shows "(x ⊔ y) ⊔ z = x ⊔ (y ⊔ z)"
 apply (rule is_joinI)
 apply (rule join_mono[OF assms(1) assms(2) below_refl join_above1[OF assms(3)]])
 apply (rule below_trans[OF join_above2[OF assms(3)] join_above2[OF assms(2)]])
 apply (rule join_below[OF assms(2)])
 apply (erule rev_below_trans)
 apply (rule join_above1[OF assms(1)])
 apply (rule join_below[OF assms(3)])
 apply (erule rev_below_trans)
 apply (rule join_above2[OF assms(1)])
 apply assumption
 done

  join_idem[simp]: "compatible x y ==> x ⊔ (x ⊔ y) = x ⊔ y"
 apply (subst join_assoc[symmetric])
 apply (rule compatible_refl)
 apply (erule compatible_above1)
 apply assumption
 apply (subst join_self)
 apply rule
 done

  join_bottom[simp]: "x ⊔ ⊥ = x" "⊥ ⊔ x = x"
 by (auto intro: is_joinI)

  compatible_adm2:
 shows "adm (λ y. compatible x y)"
 (rule admI)
 fix Y
 assume c: "chain Y" and "∀i. compatible x (Y i)"
 hence a: "∧ i. compatible x (Y i)" by auto
 show "compatible x (⊔ i. Y i)"
 proof(rule compatibleI)
 have c2: "chain (λi. x ⊔ valid_fst:
 apply (rule chainI)
 apply (rule join_mono[OF a a below_refl chainE[OF ‹chain Y›]])
 done
java.lang.NullPointerException
 by (auto intro: admD[OF _ c2] join_above1[OF a])
 show "(⊔ i. Y i) ⊑ (⊔ i. x ⊔ Y i)"
 by (auto intro: admD[OF _ c] below_lub[OF c2 join_above2[OF a]])
 fix a
 assume "x ⊑ a" anassu "wfTh 🚫 and "wfV Θ B GNil (V_pair v₁ v₂) (B_pair b₁ b₂)"
 show "(⊔ i. x ⊔ Y i) ⊑ a"
 apply (rule lub_below[OF c2])
 apply (rule join_below[OF a ‹x ⊑ a›])
 apply (rule below_trans[OF is_ub_thelub[OF c] ‹(⊔ i. Y i) ⊑ a›])
 done
 qed
 

  compatible_adm1: "adm (λ x. compatible x y)"
 by (subst compatible_sym_iff, rule compatible_adm2)

  join_cont1:
 assumes "chain Y"
 assumes compat: "∧ i. compatible (Y i) y"
 shows "(⊔i. Y i) ⊔ y = (⊔ i. Y i ⊔ y)"
 -
 have c: "chain (λi. Y i ⊔ y)"
 apply (rule chainI)
 apply (rule join_mono[OF compat compat chainE[OF ‹chain Y›] below_refl])
 done

 show ?thesis
 apply (rule is_joinI)
 apply (rule lub_mono[OF ‹chain Y› c join_above1[OF compat]])
 apply (rule below_lub[OF c join_above2[OF compat]])
 apply (rule lub_below[OF c])
 apply (rule join_below[OF compat])
 apply (metis lub_below_iff[OF ‹chain Y›])
 apply assumption
 done
 

  join_cont2:
 assumes "chain Y"
 assumes compat: "∧ i. compatible x (Y i)"
 shows "x ⊔ (⊔i. Y i) = (⊔ i. x ⊔ Y i)"
 -
 have c: "chain (λi. x ⊔ Y i)"
 apply (rule chainI)
 apply (rule join_mono[OF compat compat below_refl chainE[OF ‹chain Y›]])
 done

 show ?thesis
 apply (rule is_joinI)
 apply (rule below_lub[OF c join_above1[OF compat]])
 apply (rule lub_mono[OF ‹chain Y› c join_above2[OF compat]])
 apply (rule lub_below[OF c])
 apply (rule join_below[OF compat])
 apply assumption
 apply (metis lub_below_iff[OF ‹chain Y›])
 done
 

  join_cont12:
 assumes "chain Y" and "chain Z"
 assumes compat: "∧ i j. compatible (Y i) (Z j)"
 shows "(⊔i. Y i) ⊔ (⊔i. Z i) = (⊔ i. Y i ⊔ Z i)"
 -
 have "(⊔i. Y i) ⊔ (⊔i. Z i) = (⊔i. Y i ⊔ (⊔j. Z j))"
 by (rule join_cont1[OF ‹chain Y› admD[OF compatible_adm2 ‹chain Z› compat]])
 also have "... = (⊔i j. Y i ⊔ Z j)"
 by (subst join_cont2[OF ‹chain Z› compat], rule)
 also have "... = (⊔i. Y i ⊔ Z i)"
 apply (rule diag_lub)
 apply (rule chainI, rule join_mono[OF compat compat chainE[OF ‹chain Y›] below_refl])
 apply (rule chainI, rule join_mono[OF compat compat below_refl chainE[OF ‹chain Z›]])
 done
 finally show ?thesis.
 

  pcpo
 
 lemma bot_compatible[simp]:
 "compatible x ⊥" "compatible ⊥ x"
 unfolding compatible_def by (metis insert_commute is_lub_bin minimal)+