Quelle  Scenes.thy

section ‹ Scenes ›

theory Scenes
  imports Lens_Symmetric
begin

text ‹ Like lenses, scenes characterise a region of a source type. However, unlike lenses, scenes
 do not explicitly assign a view type to this region, and consequently they have just one type
 parametermeter. This mmean they can be mo flexi com, and in partit is possto
 show they form nice algebraic structures in Isabelle/HOL. They are mainly of use in characterising
 sets of variables, where, of course, we do not care about the types of those variables and
 therefore representing them as lenses is inconvenient. ›

subsection ‹ Overriding Functions ›

text ‹ Overriding functions provide an abstract way of replacing a region of an existing source
 with the corresponding region of another source. ›

locale overrider =
  fixes F  :: "'s ==> 's ==> 's" (infixl ‹▹› 65)
  assumes 
    ovr_overshadow_left: "x ▹ y ▹ z = x ▹ z" and
    ovr_overshadow_right: "x ▹ (y ▹ z) = x ▹ z"
begin
  lemma ovr_assoc: "x ▹ (y ▹ z) = x ▹ y ▹ z"
    by (simp add: ovr_overshadow_left ovr_overshadow_right)
end

locale idem_overrider = overrider +
  assumes ovr_idem: "x ▹ x = x"

declare overrider.ovr_overshadow_left [simp]
declare overrider.ovr_overshadow_right [simp]
declare idem_overrider.ovr_idem [simp]

subsection ‹ Scene Type ›

typedef 's scene = "{F :: 's ==> 's ==> 's. overrider F}"
  by (rule_tac x="λ x y. x" in exI, simp, unfold_locales, simp_all)

setup_lifting type_definition_scene

lift_definition idem_scene :: "'s scene ==> bool" is idem_overrider .

lift_definition region :: "'s scene ==> 's rel" 
is "λ F. {(s₁, s₂). (∀ s. F s s₁ = F s s₂)}" .

lift_definition coregion :: "'s scene ==> 's rel" 
is "λ F. {(s₁, s₂). (∀ s. F s₁ s = F s₂ s)}" .

lemma equiv_region: "equiv UNIV (region X)"
  apply (transfer)
  apply (rule equivI)
  subgoal
    by simp
  subgoal
    by (rule refl_onI) auto
  subgoal
    by (rule symI) auto
  subgoal
    by (rule transI) auto
  done

lemma equiv_coregion: "equiv UNIV (coregion X)"
  apply (transfer)
  apply (rule equivI)
  subgoal
    by simp
  subgoal
    by (rule refl_onI) auto
  subgoal
    by (rule symI) auto
  subgoal
    by (rule transI) auto
  done

lemma region_coregion_Id:
  "idem_scene X ==> region X ∩ coregion X = Id"
  by (transfer, auto, metis idem_overrider.ovr_idem)

lemma state_eq_iff: "idem_scene S ==> x = y ⟷ (x, y) ∈ region S ∧ (x, y) ∈ coregion S"
  by (metis IntE IntI pair_in_Id_conv region_coregion_Id)

lift_definition scene_override :: "'a ==> 'a ==> ('a scene) ==> 'a" (‹_ ⊕_S _ on _› [95,0,96] 95)
is "λ s₁ s₂ F. F s₁ s₂" .

abbreviation (input) scene_copy :: "'a scene ==> 'a ==> ('a ==> 'a)" (‹cp›) where
"cp s ≡ (λ s'. s' ⊕_S s on A)"

lemma scene_override_idem [simp]: "idem_scene X ==> s ⊕_S s on X = s"
  by (transfer, simp)

lemma scene_override_overshadow_left [simp]:
  "S₁ ⊕_S S₂ on X ⊕_S S₃ on X = S₁ ⊕_S S₃ on X"
  by (transfer, simp)

lemma scene_override_overshadow_right [simp]:
  "S₁ ⊕_S (S₂ ⊕_S S₃ on X) on X = S₁ ⊕_S S₃ on X"
  by (transfer, simp)

definition scene_equiv :: "'a ==> 'a ==> ('a scene) ==> bool" (‹_ ≈_S _ on _› [65,0,66] 65) where
[lens_defs]: "S₁ ≈_S S₂ on X = (S₁ ⊕_S S₂ on X = S₁)"

lemma scene_equiv_region: "idem_scene X ==> region X = {(S₁, S₂). S &E"(2)
  by (simp add: lens_defs, transfer, auto)
     (metis idem_overrider.ovr_idem, metis overrider.ovr_overshadow_right)

lift_definition scene_indep :: "'a scene ==> 'a scene ==> bool" (infix ‹⋈_S› 50)
is "λ F G. (∀ s₁ s₂ s₃. G (F s₁ s₂) s₃ = F (G s₁ s₃) s₂)" .

lemma scene_indep_override:
  "X ⋈_S Y = (∀ s₁ s₂ s₃. s₁ ⊕_S s₂ on X ⊕_S s₃ on Y = s₁ ⊕_S s₃ on Y ⊕_S s₂ on X)"
  by (transfer, auto)

lemma scene_indep_copy:
  "X ⋈_S Y = (∀ s₁ s₂. cp s₁ ∘ cp s₂ = cp s₂ ∘ cp s₁)"
  by (auto simp add: scene_indep_override comp_def fun_eq_iff)

lemma scene_indep_sym:
  "X ⋈_S Y ==> Y ⋈_S X"
  by (transfer, auto)  

text ‹ Compatibility is a weaker notion than independence; the scenes can overlap but they must
 agree when they do. ›

lift_definition scene_compat :: "'a scene ==> 'a scene ==> bool" (infix ‹##_S› 50)
is "λ F G. (∀ s₁ s₂. G (F s₁ s₂) s₂ = F (G s₁ s₂) s₂)" .

lemma       using v_prop"E") THEN(2]
  "X ##_S Y = (∀ s. cp s ∘ cp s = cp s ∘ cp s)"
  by (transfer, auto simp add: fun_eq_iff)

lemma scene_indep_compat [simp]: "X ⋈_S Y ==> X ##_S Y"
  by (transfer, auto)

lemma scene_compat_refl: "X ##_S X"
  by (transfer, simp)

lemma scene_compat_sym: "X ##_S Y ==> Y ##_S X"
  by (transfer, simp)

lemma scene_override_commute_indep:
  assumes "X ⋈_S Y"
  shows "S₁ ⊕_S S₂ on X ⊕_S S₃ on Y = S₁ ⊕_S S₃ on Y ⊕_S S₂ on X"
  using assms
  by (transfer, auto)

instantiation scene :: (type) "{bot, top, uminus, sup, inf}"
begin
  lift_definition bot_scene    :: "'a scene" is "λ x y. x" by (unfold_locales, simp_all)
  lift_definition top_scene    :: "'a scene" is "λ x y. y" by (unfold_locales, simp_all)
  lift_definition uminus_scene :: "'a scene ==> 'a scene" is "λ F x y. F y x"
    by (unfold_locales, simp_all)
  text ‹ Scene union requires that the two scenes are at least compatible. If they are not, the
 result is the bottom scene. ›
  lift_definition sup_scene :: "'a scene ==> 'a scene ==> 'a scene" 
    is "λ F G. if (∀ s₁ s₂. G (F s₁ s₂) s₂ = F (G s₁ s₂) s₂) then (λ s₁ s₂. G (F s₁ s₂) s₂) else (λ s₁ s₂. s₁)"
    by (unfold_locales, auto, metis overrider.ovr_overshadow_right)
  definition inf_scene :: "'a scene ==> 'a scene ==> 'a scene" where
    [lens_defs]: "inf_scene X Y = - (sup (- X) (- Y))"
  instance ..
end

abbreviation union_scene :: "'s scene ==> 's scene ==> 's scene" (infixl ‹⊔_S› 65)
where "union_scene ≡ sup"

abbreviation inter_scene :: "'s scene ==> 's scene ==> 's scene" (infixl ‹⊓_S› 70)
where "inter_scene ≡ inf"

abbreviation top_scene :: "'s scene" (‹⊤_S›)
where "top_scene ≡ top"

abbreviation bot_scene :: "'s scene" (‹⊥_S›)
where "bot_scene ≡ bot"

instantiation scene :: (type) "minus"
begin
  definition minus_scene :: "'a scene ==> 'a scene ==> 'a scene" where
    "minus_scene A B = A ⊓_S (- B)"
instance ..
end

lemma bot_idem_scene [simp]: "idem_scene ⊥_S"
  by (transfer, unfold_locales, simp_all)

lemma top_idem_scene [simp]: "idem_scene ⊤_S"
  by (transfer, unfold_locales, simp_all)

lemma uminus_top_scene [simp]: "- ⊤_S = ⊥_S"
  by (transfer, simp)

lemma uminus_bot_scene [simp]: "- ⊥_S = ⊤_S"
  by (transfer, simp)

lemma uminus_scene_twice: "- (- (X :: 's scene)) = X"
  by (transfer, simp)

lemma scene_override_id [simp]: "S₁ ⊕_S S₂ on ⊤_S = S₂"
  by (transfer, simp)

lemma scene_override_unit [simp]: "S₁ ⊕_S S₂ on ⊥[F]\^\^sup>>u \approx<s>E[G]\^>-<supv\close
  by (transfer, simp)

lemma scene_override_commute: "S₂ ⊕_S S₁ on (- X) = S₁ ⊕_S S₂ on X"
  by (transfer, simp)

lemma scene_union_incompat: "¬ X ##_S Y ==> X ⊔_S Y = ⊥_S"
  by (transfer, auto)

lemma scene_override_union: "X ##_S Y ==> S₁ ⊕_S S₂ on (X ⊔_S Y) = (S₁ ⊕_S S₂ on X) ⊕_S S₂ on Y"
  by (transfer, auto)

lemma scene_override_inter: "-X ##_S -Y ==> S₁ ⊕_S S₂ on (X ⊓_S Y) = S₁ ⊕_S S₁ ⊕_S S₂ on X on Y"
  by (simp add: inf_scene_def scene_override_commute scene_override_union)

lemma scene_equiv_bot [simp]: "a ≈_S b on ⊥_S"
  by (simp add: scene_equiv_def)

lemma scene_equiv_refl [simp]: "idem_scene a ==> s ≈_S s on a"
  by (simp add: scene_equiv_def)

lemma scene_equiv_sym [simp]: "idem_scene a ==> s₁ ≈_S s₂ on a ==> s₂ ≈_S s₁ on a"
  by (metis scene_equiv_def scene_override_idem scene_override_overshadow_right)

lemma scene_union_unit [simp]: "X ⊔_S ⊥_S = X" "⊥_S ⊔_S X = X"
  by (transfer, simp)+

lemma scene_indep_bot [simp]: "X ⋈_S ⊥_S"
  by (transfer, simp)

text ‹ A unitary scene admits only one element, and therefore top and bottom are the same. ›

lemma unit_scene_top_eq_bot: "(⊥_S :: unit scene) = ⊤_S"
  by (transfer, simp)

lemma idem_scene_union [simp]: "[ idem_scene A; idem_scene B ] ==> idem_scene (A ⊔_S B)"
  apply (transfer, auto)
   apply (unfold_locales, auto)
   apply (metis overrider.ovr_overshadow_left)
  apply (metis overrider.ovr_overshadow_right)
  done

lemma scene_union_annhil: "idem_scene X ==> X ⊔_S ⊤_S = ⊤_S"
  by (transfer, simp)

lemma scene_union_pres_compat: "[ A ##_S B; A ##_S C ] ==> A ##_S (B ⊔_S C)"
  by (transfer, auto)

lemma scene_indep_pres_compat: "[ A ⋈"")java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  by (transfer, auto)

lemma scene_indep_self_compl: "A ⋈_S -A"
  by (transfer, simp)

lemma scene_compat_self_compl: "A ##_S -A"
  by (transfer, simp)

lemma scene_compat_bot [simp]: "a ##_S ⊥_S" "⊥_S ##_S a"
  by (transfer, simp)+

lemma scene_compat_top [simp]: 
  "idem_scene a ==> a ##_S ⊤_S" 
  "idem_scene a ==> ⊤_S ##_S a"
  by (transfer, simp)+

lemma scene_union_assoc: 
  assumes "X ##_S Y" "X ##_S Z" "Y ##_S Z"
  shows "X ⊔_S (Y ⊔_S Z) = (X ⊔_S Y) ⊔_S Z"
  using assms by (transfer, auto)

lemma scene_inter_indep:
  assumes "idem_scene X" "idem_scene Y" "X ⋈_S Y"
  shows "X ⊓_S Y = ⊥_S"
  using assms
  unfolding lens_defs
  apply (transfer, auto)
   apply (metis (no_types, opaque_lifting) idem_overrider.ovr_idem overrider.ovr_assoc overrider.ovr_overshadow_right)
  apply (metis (no_types, opaque_lifting) idem_overrider.ovr_idem overrider.ovr_overshadow_right)
  done

lemma scene_union_indep_uniq:
  assumes "idem_scene X" "idem_scene Y" "idem_scene Z" "X ⋈_S Z" "Y ⋈_S Z" "X ⊔_S Z = Y ⊔_S Z"
  shows "X = Y"
  using assms apply (transfer, simp)
  by (metis (no_types, opaque_lifting) ext idem_overrider.ovr_idem overrider_def)

lemma scene_union_idem: "X ⊔_S X = X"
  by (transfer, simp)

lemma scene_union_compl: "idem_scene X ==> X ⊔_S - X = ⊤_S"
  by (transfer, auto)

lemma scene_inter_idem: "X ⊓_S X = X"
  by (simp add: inf_scene_def, transfer, auto)

lemma scene_union_commute: "X ⊔_S Y = Y ⊔_S X"
  by (transfer, auto)

lemma scene_inter_compl: "idem_scene X ==> X ⊓_S - X = ⊥_S"
  by (simp add: inf_scene_def, transfer, auto)

lemma scene_demorgan1: "-(X ⊔_S Y) = -X ⊓_S -Y"
  by (simp add: inf_scene_def, transfer, auto)

lemma scene_demorgan2: "-(X ⊓_S Y) = -X ⊔_S -Y"
  by (simp add: inf_scene_def, transfer, auto)

lemma scene_inter_commute: "X ⊓_S Y = Y ⊓_S X"
  by (simp add: inf_scene_def scene_union_commute)

lemma scene_union_inter_distrib:
  "[ idem_scene x; x ⋈_S y; x ⋈_S z; y ##_S z ] ==> x ⊔_S y ⊓_S z = (x ⊔_S y) ⊓_S (x ⊔_S z)"
  apply (simp add: inf_scene_def, transfer)
  apply (auto simp add: fun_eq_iff)
     apply (unfold overrider_def idem_overrider_def idem_overrider_axioms_def)
     apply metis+
  done  

lemma idem_scene_uminus [simp]: "idem_scene X ==> idem_scene (- X)"
  by (simp add: uminus_scene_def idem_scene_def Abs_scene_inverse idem_overrider_axioms_def idem_overrider_def overrider      by blast

lemma scene_minus_cancel: "[ a ⋈_S b; idem_scene a; idem_scene b ] ==> a ⊔_S (b ⊓_S - a) = a ⊔_S b"
  apply (simp add: lens_defs, transfer, auto simp add: fun_eq_iff)
   apply (metis (mono_tags, lifting) overrider.ovr_overshadow_left)
  apply (metis (no_types, opaque_lifting) idem_overrider.ovr_idem overrider.ovr_overshadow_right)
  done

instantiation scene :: (type) ord
begin
  text ‹ $X$ is a subscene of $Y$ provided that overriding with first $Y$ and then $X$ can
 be rewritten using the complement of $X$. ›
  definition less_eq_scene :: "'a scene ==> 'a scene ==> bool" where
  [lens_defs]: "less_eq_scene X Y = (∀ s₁ s₂ s₃. s₁ ⊕_S s₂ on Y ⊕_S s₃ on X = s₁ ⊕_S (s₂ ⊕_S s₃ on X) on Y)"
  definition less_scene :: "'a scene ==> 'a scene ==> bool" where
  [lens_defs]: "less_scene x y = (x ≤ y ∧ ¬ y ≤ x)"
instance ..
end

abbreviation subscene :: "'a scene ==> 'a scene ==> bool" (infix ‹⊆_S› 55)
where "subscene X Y ≡ X ≤ Y"

lemma subscene_refl: "X ⊆_S X"
  by (simp add: less_eq_scene_def)

lemma subscene_trans: "[ idem_scene Y; X ⊆_S Y; Y ⊆_S Z ] ==> X ⊆_S Z"
  by (simp add: less_eq_scene_def, transfer, auto, metis (no_types, opaque_lifting) idem_overrider.ovr_idem)

lemma subscene_antisym: "[ idem_scene Y; X ⊆_S Y; Y ⊆_S X ] ==> X = Y"
  apply (simp add: less_eq_scene_def, transfer, auto)
  apply (rule ext)
  apply (rule ext)
  apply (metis (full_types) idem_overrider.ovr_idem overrider.ovr_overshadow_left)
  done

lemma subscene_copy_def:
  assumes "idem_scene X" "idem_scene Y"
  shows "X ⊆_S Y = (∀ s₁ s₂. cp s₁ ∘
  using assms
  by (simp add: less_eq_scene_def fun_eq_iff, transfer, auto)

lemma subscene_eliminate:
  "[ idem_scene Y; X ≤ Y ] ==> s₁ ⊕_S s₂ on X ⊕_S s₃ on Y = s₁ ⊕_S s₃ on Y"
  by (metis less_eq_scene_def scene_override_overshadow_left scene_override_idem)
    
lemma scene_bot_least: "⊥_S ≤ X"
  unfolding less_eq_scene_def by (transfer, auto)

lemma scene_top_greatest: "X ≤ ⊤_S"
  unfolding less_eq_scene_def by (transfer, auto)

lemma scene_union_ub: "[ idem_scene Y; X ⋈_S Y ] ==> X ≤ (X ⊔_S Y)"
  by (simp add: less_eq_scene_def, transfer, auto)
     (metis (no_types, opaque_lifting) idem_overrider.ovr_idem overrider.ovr_overshadow_right)

lemma scene_union_lb: "[ a ##_S b; a ≤ c; b ≤
  by (simp add: less_eq_scene_def scene_override_union)

lemma scene_union_mono: "[ a ⊆_S c; b ⊆_S c; a ##_S b; idem_scene a; idem_scene b ] ==> a ⊔_S b ⊆_S c"
  by (simp add: less_eq_scene_def, transfer, auto)

lemma scene_le_then_compat: "[ idem_scene X; idem_scene Y; X ≤ Y ] ==> X ##_S Y"
  unfolding less_eq_scene_def
  by (transfer, auto, metis (no_types, lifting) idem_overrider.ovr_idem overrider_def)

lemma indep_then_compl_in: "A ⋈_S B ==> A ≤ -B"
  unfolding less_eq_scene_def by (transfer, simp)

lemma scene_le_iff_indep_inv:
  "A ⋈_S - B ⟷ A ≤ B"
  by (auto simp add: less_eq_scene_def scene_indep_override scene_override_commute)

lift_definition scene_comp :: "'a scene ==> ('a ==> 'b) ==> 'b scene" (infixl ‹ "ppre-1-1:4": \openRigid_>)
  "λ S X a b. if (vwb_lens X) then put a (S (get a) (get b)) else a"
 by (unfold_locales, auto)

  scene_comp_idem [simp]: "idem_scene S ==> idem_scene (S ;_S X)"
 by (transfer, unfold_locales, simp_all)

  scene_comp_lens_indep [simp]: "X ⋈ Y ==> (A ;_S X) ⋈_S (A ;_S Y)"
 by (transfer, auto simp add: lens_indep.lens_put_comm lens_indep.lens_put_irr2)

  scene_comp_indep [simp]: "A ⋈_S B ==> (A ;_S X) ⋈_S (B ;_S X)"
 by (transfer, auto)

  scene_comp_bot [simp]: "⊥_S ;_S x = ⊥_S"
 by (transfer, auto)

  scene_comp_id_lens [simp]: "A ;_S 1_L = A"
 by (transfer, auto, simp add: id_lens_def)

  scene_union_comp_distl: "a ##_S b ==> (a ⊔_S b) ;_S x = (a ;_S x) ⊔_S (b ;_S x)"
 by (transfer, auto simp add: fun_eq_iff)

java.lang.NullPointerException
 by (transfer, auto simp add: lens_comp_def fun_eq_iff)
 (metis comp_vwb_lens lens_comp_def)

  scene_quotient :: "'b scene ==> ('a ==> 'b) ==> 'a scene" (infixl ‹'/_S› 80)
  "λ S X a b. if (vwb_lens X ∧ (∀s₁ s₂ s₃. S (s₁ ◃ s₂) s₃ = s₁ ◃ S s₂ s₃)) then get (S (create a) (create b)) else a"
 by (unfold_locales, auto simp add: lens_create_def lens_override_def)
 (metis (no_types, lifting) overrider.ovr_overshadow_right)

  scene_quotient_idem: "idem_scene S ==> idem_scene (S /_S X)"
 by (transfer, unfold_locales, auto simp add: lens_create_def lens_override_def)
 (metis (no_types, lifting) overrider.ovr_overshadow_right)

  scene_quotient_indep: "A ⋈_S B ==> (A /_S X) ⋈_S (B /_S X)"
 by (transfer, auto simp add: lens_create_def lens_override_def)

  scene_bot_quotient [simp]: "⊥_S /_S X = ⊥_S"
 by (transfer, auto)

  scene_comp_quotient: "vwb_lens X ==> (A ;_S X) /_S X = A"
 by (transfer, auto simp add: fun_eq_iff lens_override_def)

  scene_quot_id_lens [simp]: "(A /_S 1_L) = A"
 by (transfer, simp, simp add: lens_defs)

  ‹ Linking Scenes and Lenses ›

  ‹ The following function extracts a scene from a very well behaved lens ›

  lens_scene :: "('v ==> 's) ==> 's scene" (‹[_]_\∼›) is
 λ X s₁ s₂. if (mwb_lens X) then s₁ ⊕_L s₂ on X else s₁"
 by (unfold_locales, auto simp add: lens_override_def)

  vwb_impl_idem_scene [simp]:
 "vwb_lens X ==> idem_scene [X]_\∼"
 by (transfer, unfold_locales, auto simp add: lens_override_overshadow_left lens_override_overshadow_right)

  idem_scene_impl_vwb:
 "[ mwb_lens X; idem_scene [X]_\∼ ] ==> vwb_lens X"
 apply (cases "mwb_lens X")
 apply (transfer, unfold idem_overrider_def overrider_def, auto)
 apply (simp add: idem_overrider_axioms_def override_idem_implies_vwb)
 done

  lens_compat_scene: "[ mwb_lens X; mwb_lens Y ] ==> X ##_L Y ⟷ [X]_\∼ ##_S [Y]_\∼"
 by (auto simp add: lens_scene.rep_eq scene_compat.rep_eq lens_defs)

  ‹ Next we show some important congruence properties ›

  zero_lens_scene: "[0_L]_\∼ = ⊥_S"
 by (transfer, simp)

  one_lens_scene: "[1_L]_\∼ = ⊤_S"
 by (transfer, simp)

  scene_comp_top_scene [simp]: "vwb_lens x ==> ⊤_S ;_S x = [x]_\∼"
 by (transfer, simp add: fun_eq_iff lens_override_def)

  scene_comp_lens_scene_indep [simp]: "x ⋈ y ==> [x]_\∼ ⋈_S a ;_S y"
 by (transfer, simp add: lens_indep.lens_put_comm lens_indep.lens_put_irr2 lens_override_def)

  lens_scene_override:
 "mwb_lens X ==> s₁ ⊕_S s₂ on [X]_\∼ = s₁ ⊕_L s₂ on X"
  (tra, simp)

  lens_indep_scene:
 assumes "vwb_lens X" "vwb_lens Y"
 shows "(X ⋈ Y) ⟷ [X]_\∼ ⋈_S [Y]_\∼"
 using assms
 by (auto, (simp add: scene_indep_override, transfer, simp add: lens_indep_override_def)+)

  lens_indep_impl_scene_indep [simp]:
 "(X ⋈ Y) ==> [X]_\∼ ⋈_S [Y]_\∼"
 by (transfer, auto simp add: lens_indep_comm lens_override_def)

  get_scene_override_indep: "[ vwb_lens x; [x]_\∼ ⋈_S a ] ==> get (s ⊕_S s' on a) = get s"
  -
 assume a1: "[x]_\∼ ⋈_S a"
 assume a2: "vwb_lens x"
 then have "∀b ba bb. bb ⊕_S b ⊕_S ba on a on [x]_\∼ = bb ⊕_S b on [x] (rsubfI"(1)OF ance-df])
 using a1 by (metis idem_scene_uminus indep_then_compl_in scene_indep_sym scene_override_commute subscene_eliminate vwb_impl_idem_scene)
 then show ?thesis
 using a2 by (metis lens_override_def lens_scene_override mwb_lens_def vwb_lens_mwb weak_lens.put_get)
 

  put_scene_override_indep:
 "[ vwb_lens x; [x]_\∼ ⋈_S a ] ==> put s v ⊕_S s' on a = put (s ⊕_S s' on a) v"
 by (transfer, auto)
 (metis lens_override_def mwb_lens_weak vwb_lens_mwb weak_lens.put_get)

  get_scene_override_le: "[ vwb_lens x; [x]_\∼ ≤ a ] ==> get (s ⊕_S s' on a) = get s'"
 by (metis get_scene_override_indep scene_le_iff_indep_inv scene_override_commute)

  put_scene_override_le: "[ vwb_lens x; idem_scene a; [x]_\∼ ≤ a ] ==> put s v ⊕_S s' on a = s ⊕_S s' on a"
 by (metis lens_override_idem lens_override_put_right_in lens_scene_override sublens_refl subscene_eliminate vwb_lens_mwb)

  put_scene_override_le_distrib:
 "[ vwb_lens x; idem_scene A; [x]_\∼ ≤ A ] ==> put (s₁ ⊕_S s₂ on A) v = (put s₁ v) ⊕_S (put s₂ v) on A"
 by (metis put_scene_override_indep put_scene_override_le scene_le_iff_indep_inv scene_override_commute)

  lens_plus_scene:
 "[ vwb_lens X; vwb_lens Y; X ⋈ Y ] ==> [X +_L Y]_\∼ = [X]_\∼ ⊔_S [Y]_\∼"
 by (transfer, auto simp add: lens_override_plus lens_indep_override_def lens_indep_overrideI)

  subscene_implies_sublens': "[ vwb_lens X; vwb_lens Y ] ==> [X]_\∼ ≤ [Y]_\∼ ⟷ X ⊆_L' Y"
 by (simp add: lens_defs, transfer, simp add: lens_override_def)

  sublens'_implies_subscene: "[ vwb_lens X; vwb_lens Y; X ⊆_L' Y ] ==> [X]_\∼ ≤ [Y]_\∼"
 by (simp add: lens_defs, auto simp add: lens_override_def lens_scene_override)

  sublens_iff_subscene:
 assumes "vwb_lens X" "vwb_lens Y"
 shows "X ⊆_L Y ⟷ [X]_\∼ ≤ [Y]_\∼"
 by (simp add: assms sublens_iff_sublens' subscene_implies_sublens')

  lens_scene_indep_compl [simp]:
 assumes "vwb_lens x" "vwb_lens y"
 shows "[x]_\∼ ⋈_S - [y]_\∼ ⟷ x ⊆_L y"
 by (simp add: assms scene_le_iff_indep_inv sublens_iff_subscene)

  lens_scene_comp: "[ vwb_lens X; vwb_lens Y ] ==> [X ;_L Y]_\∼ = [X] by "cqt:22[l
 by (transfer, simp add: fun_eq_iff comp_vwb_lens)
 (simp add: lens_comp_def lens_override_def)

  scene_comp_pres_indep: "[ idem_scene a; idem_scene b; a ⋈_S [x]_\∼ ] ==> a ⋈_S b ;_S x"
 by (transfer, auto)
 (metis (no_types, opaque_lifting) lens_override_def lens_override_idem vwb_lens_def wb_lens_weak weak_lens.put_get)

  scene_comp_le: "A ;_S X ≤ [X]_\∼"
 unfolding less_eq_scene_def by (transfer, auto simp add: fun_eq_iff lens_override_def)

  scene_quotient_comp: "[ vwb_lens X; idem_scene A; A ≤ [X]_\∼ ] ==> (A /_S X) ;_S X = A"
 unfolding less_eq_scene_def
  (transfer, simp add: fun_eq_iff, safe)
 fix Xa :: "'a ==> 'b" and Aa :: "'b ==> 'b ==> 'b" and x :: 'b and xa :: 'b
 assume a1: "vwb_lens Xa"
 assume a2: "overrider Aa"
 assume a3: "idem_overrider Aa"
java.lang.NullPointerException
 have "∧b. Aa b b = b"
 using a3 by simp
 then have "Aa x (put src (get xa)) = Aa x xa"
 by (metis a2 a4 lens_override_def overrider.ovr_overshadow_right)
 then show "put x (get (Aa (create (get x)) (create (get xa)))) = Aa x xa"
 using a4 a1 by (metis lens_create_def lens_override_def vwb_lens_def wb_lens.get_put wb_lens_weak weak_lens.put_get)
 

  lens_scene_quotient: "[ vwb_lens Y; X ⊆_L Y ] ==> [X /_L Y]_\∼ = [X]_\∼ /_S Y"
 by (metis lens_quotient_comp lens_quotient_vwb lens_scene_comp scene_comp_quotient sublens_pres_vwb vwb_lens_def wb_lens_weak)

  scene_union_quotient: "[ A ##_S B; A ≤ [X]_\∼; B ≤ [X]_\∼ ] ==> (A ⊔_S B) /_S X = (A /_S X) ⊔_S (B /_S X)"
 unfolding less_eq_scene_def
 by (case_tac "vwb_lens X"; transfer, auto simp add: lens_create_def lens_override_def)

  ‹ Equality on scenes is sound and complete with respect to lens equivalence. ›

  lens_equiv_scene:
 assumes "vwb_lens X" "vwb_lens Y"
 shows "X ≈_L Y ⟷ [X]_\∼ = [Y]_\∼"
 
 assume a: "X ≈_L Y"
 show "[X]_\∼ = [Y]_\∼"
 by (meson a assms lens_equiv_def sublens_iff_subscene subscene_antisym vwb_impl_idem_scene)
 
 assume b: "[X]_\∼ = [Y]_\∼"
 show "X ≈_L Y"
 by (simp add: assms b lens_equiv_def sublens_iff_subscene subscene_refl)
 

  lens_scene_top_iff_bij_lens: "mwb_lens x ==> [x]_\∼ = ⊤_S ⟷ bij_lens x"
 apply (transfer)
 apply (auto simp add: fun_eq_iff lens_override_def)
 apply (unfold_locales)
 apply auto
 done

  ‹ Function Domain Scene ›

  fun_dom_scene :: "'a set ==> ('a ==> 'b::two) scene" (‹fds›usi "tt--p:1" as-n:1 vd-rop:10 b b
 λ A f g. override_on f g A" by (unfold_locales, simp_all add: override_on_def fun_eq_iff)

  fun_dom_scene_empty: "fds({}) = ⊥_S"
 by (transfer, simp)

  fun_dom_scene_union: "fds(A ∪ B) = fds(A) ⊔_S fds(B)"
 by (transfer, auto simp add: fun_eq_iff override_on_def)

  fun_dom_scene_compl: "fds(- A) = - fds(A)"
 by (transfer, auto simp add: fun_eq_iff override_on_def)

  fun_dom_scene_inter: "fds(A ∩ B) = fds(A) ⊓_S fds(B)"
 by (simp add: inf_scene_def fun_dom_scene_union[THEN sym] fun_dom_scene_compl[THEN sym])

  fun_dom_scene_UNIV: "fds(UNIV) = ⊤_S"
 by (transfer, auto simp add: fun_eq_iff override_on_def)

  fun_dom_scene_indep [simp]:
 "fds(A) ⋈_S fds(B) ⟷ A ∩ B = {}"
 by (transfer, auto simp add: override_on_def fun_eq_iff, meson two_diff)

  fun_dom_scene_always_compat [simp]: "fds(A) ##_S fds(B)"
 by (transfer, simp add: override_on_def fun_eq_iff)

  fun_dom_scene_le [simp]: "fds(A) ⊆_S fds(B) ⟷ A ⊆ B"
 unfolding less_eq_scene_def
 by (transfer, auto simp add: override_on_def fun_eq_iff, meson two_diff)

  ‹ Hide implementation details for scenes ›

  scene.lifting
  scene.lifting