(*
    Author:      Norbert Schirmer
    Maintainer:  Norbert Schirmer, norbert.schirmer at web de

Copyright (C) 2007-2008 Norbert Schirmer
Copyright (c) 2022 Apple Inc. All rights reserved.

*)

section "Examples for Procedures as Parameters using Statespaces"
theory ProcParExSP imports "../Vcg" begin


lemma DynProcProcPar':
 assumes adapt: "P ⊆ {s. p s = q ∧
         (∃Z. init s ∈ P' Z ∧
              (∀t ∈ Q' Z. return s t ∈ R s t) ∧
              (∀t ∈ A' Z. return s t ∈ A))}"
 assumes result: "∀s t. Γ,Θ⊨_F (R s t) result s t Q,A"
 assumes q: "∀Z. Γ,Θ⊨_F (P' Z) Call q (Q' Z),(A' Z)"
 shows "Γ,Θ⊨_F P dynCall init p return result Q,A"
apply (rule HoarePartial.DynProcProcPar [OF _ result q])
apply (insert adapt)
apply fast
done




lemma conseq_exploit_pre':
             "[∀s ∈ S. Γ,Θ ⊨ ({s} ∩ P) c Q,A]
              ==>
              Γ,Θ⊨ (P ∩ S)c Q,A"
  apply (rule HoarePartialDef.Conseq)
  apply clarify
  by (metis IntI insertI1 subset_refl)

lemma conseq_exploit_pre'':
             "[∀Z. ∀s ∈ S Z. Γ,Θ ⊨ ({s} ∩ P Z) c (Q Z),(A Z)]
              ==>
              ∀Z. Γ,Θ⊨ (P Z ∩ S Z)c (Q Z),(A Z)"
  apply (rule allI)
  apply (rule conseq_exploit_pre')
  apply blast
  done

lemma conseq_exploit_pre''':
             "[∀s ∈ S. ∀Z. Γ,Θ ⊨ ({s} ∩ P Z) c (Q Z),(A Z)]
              ==>
              ∀Z. Γ,Θ⊨ (P Z ∩ S)c (Q Z),(A Z)"
  apply (rule allI)
  apply (rule conseq_exploit_pre')
  apply blast
  done


procedures compare(i::nat,j::nat|r::bool) "NoBody"


print_locale! compare_signature


context compare_impl
begin
declare [[hoare_use_call_tr' = false]]
term "🚫r :== CALL compare(🚫i,🚫j)"
declare [[hoare_use_call_tr' = true]]
end


(* fixme: typing issue with modifies locale*)
procedures
  LEQ (i::nat,j::nat | r::bool) "🚫r :== 🚫i ≤ 🚫j"
  LEQ_spec: "∀σ. Γ⊨ {σ} PROC LEQ(🚫i,🚫j,🚫r) {🚫r = (^<sigma>i ≤ ^<sigma>j)}"

  LEQ_modifies: "∀σ. Γ⊨ {σ} PROC LEQ(🚫i,🚫j,🚫r) {t. t may_only_modify_globals σ in []}"



definition mx:: "('a → 'a → bool) → 'a → 'a → 'a"
  where "mx leq a b = (if leq a b then a else b)"

procedures (imports compare_signature)
  Max (compare::string, n::nat, m::nat | k::nat)
  where b::bool
  in
  "🚫b :== DYNCALL 🚫compare(🚫n,🚫m);;
   IF 🚫b THEN 🚫k :== 🚫n ELSE 🚫k :== 🚫m FI"

  Max_spec: "∧leq. ∀σ. Γ⊨
  ({σ} ∩ {s. (∀τ. Γ⊨ {τ} 🚫r :== PROC compare(🚫i,🚫j) {🚫r = (leq ^<tau>i ^<tau>j)}) ∧
              (∀τ. Γ⊨ {τ} 🚫r :== PROC compare(🚫i,🚫j) {t. t may_only_modify_globals τ in []})})
    PROC Max(🚫compare,🚫n,🚫m,🚫k)
  {🚫k = mx leq ^<sigma>n ^<sigma>m}"

context Max_spec
begin
thm Max_spec
end
context Max_impl
begin
term "🚫 bool)"  where
[' ]
term "\b :== DYNCALL 🚫compare(🚫m)"
declare [[hoare_use_call_tr' = true]]
end



lemma (in Max_impl ) Max_spec1:
shows
"∀σ leq. Γ⊨
  ({σ} ∩ { (∀τ. Γ⊨{τ} 🚫compare(🚫j) {🚫
      (∀using 1 by blast
    \<acuten,🚫m)
  {🚫
aerl oareailPoNoec1
apply (intro allI)
apply (rule conseq_exploit_pre')
apply (rule)
apply clarify
proof -
  fix σ:: "('a( java.lang.StringIndexOutOfBoundsException: Index 118 out of bounds for length 118
  mae_pec:
 "∀τ. \ ac_on_e sm es esipl ntditic1 resq_e_ e_e_e

  opre_mdiis:
 "∀
 {t. t may_only_modify_globals τ

 point_closed
 🚫
java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 85
 {🚫
 apply vcg
 apply (clarsimp simp add: mx_def)
 done
 qed


  (in Max_impl) Max_spec2:
 
 ∀σ leq. Γ⊨
 ({σ} ∩ {(∀τ. Γ⊨ {τ} 🚫r :== PROC 🚫compare(🚫i,🚫j) {🚫r = (leq ^τi ^τj)}) ∧
 (∀τ. Γ⊨ {τ} 🚫r :== PROC 🚫compare(🚫i,🚫j) {t. t may_only_modify_globals τ in []})})
    \<acute>k :== PROC Max(\<acute>compare,\<acute>n,\<acute>m)
  \<lbrace>\<acute>k = mx leq \<^bsup>\<sigma>\<^esup>n \<^bsup>\<sigma>\<^esup>m\<rbrace>"
apply (hoare_rule HoarePartial.ProcNoRec1)
apply (intro allI)
apply (rule conseq_exploit_pre')
apply (rule)
apply clarify
apply vcg
apply (clarsimp simp add: mx_def)
done

lemma (in Max_impl) Max_spec3:
shows
"\<forall>n m leq. \<Gamma>\<turnstile>
  (\<lbrace>\<acute>n=n \<and> \<acute>m=m\<rbrace>  \<inter>
   \<lbrace>(\<forall>\<tau>. \<Gamma>\<turnstile> {\<tau>} \<acute>r :== PROC \<acute>compare(\<acute>i,\<acute>j) \<lbrace>\<acute>r = (leq \<^bsup>\<tau>\<^esup>i \<^bsup>\<tau>\<^esup>j)\<rbrace>) \<and>
     (\<forall>\<tau>. \<Gamma>\<turnstile> {\<tau>} \<acute>r :== PROC \<acute>compare(\<acute>i,\<acute>j) {t. t may_only_modify_globals \<tau> in []})\<rbrace>)
    \<acute>k :== PROC Max(\<acute>compare,\<acute>n,\<acute>m)
  \<lbrace>\<acute>k = mx leq n m\<rbrace>"
apply (hoare_rule HoarePartial.ProcNoRec1)
apply (intro allI)
apply (rule conseq_exploit_pre')
apply (rule)
apply clarify
apply vcg
apply (clarsimp simp add: mx_def)
done

lemma (in Max_impl) Max_spec4:
shows
"\<forall>n m leq. \<Gamma>\<turnstile>
  (\<lbrace>\<acute>n=n \<and> \<acute>m=m\<rbrace> \<inter> \<lbrace>\<forall>\<tau>. \<Gamma>\<turnstile> {\<tau>} \<acute>r :== PROC \<acute>compare(\<acute>i,\<acute>j) \<lbrace>\<acute>r = (leq \<^bsup>\<tau>\<^esup>i \<^bsup>\<tau>\<^esup>j)\<rbrace>\<rbrace>)
    \<acute>k :== PROC Max(\<acute>compare,\<acute>n,\<acute>m)
  \<lbrace>\<acute>k = mx leq n m\<rbrace>"
apply (hoare_rule HoarePartial.ProcNoRec1)
apply (intro allI)
apply (rule conseq_exploit_pre')
apply (rule)
apply clarify
apply vcg
apply (clarsimp simp add: mx_def)
done

print_locale Max_spec

(* We have to rename the parameters of the compare procedure to match the LEQ procedure *)
locale Max_test = Max_spec where
        i_'compare_' = i_'LEQ_' and
        j_'compare_' = j_'LEQ_' and
        r_'compare_' = r_'LEQ_'
       + LEQ_spec + LEQ_modifies

lemma (in Max_test)
  shows
  "\<Gamma>\<turnstile> {\<sigma>} \<acute>k :== CALL Max(LEQ_'proc,\<acute>n,\<acute>m) \<lbrace>\<acute>k = mx (\<le>) \<^bsup>\<sigma>\<^esup>n \<^bsup>\<sigma>\<^esup>m\<rbrace>"
proof -
  note Max_spec = Max_spec [where leq="(\<le>)"]
  show ?thesis
    apply vcg
    apply (clarsimp)
    apply (rule conjI)
    apply (rule LEQ_spec)
    apply (rule LEQ_modifies)
    done
qed






lemma (in Max_impl) Max_spec5:
shows
"\<forall>n m leq. \<Gamma>\<turnstile>
  (\<lbrace>\<acute>n=n \<and> \<acute>m=m\<rbrace> \<inter> \<lbrace>\<forall>n' m'. \<Gamma>\<turnstile> \<lbrace>\<acute>i=n' \<and> \<acute>j=m'\<rbrace> \<acute>r :== PROC \<acute>compare(\<acute>i,\<acute>j) \<lbrace>\<acute>r = (leq n' m')\<rbrace>\<rbrace>)
    \<acute>k :== PROC Max(\<acute>compare,\<acute>n,\<acute>m)
  \<lbrace>\<acute>k = mx leq n m\<rbrace>"
apply (hoare_rule HoarePartial.ProcNoRec1)
apply (intro allI)
apply (rule conseq_exploit_pre')
apply (rule)
apply clarify
apply vcg
apply clarsimp
apply (clarsimp simp add: mx_def)
done

lemma (in LEQ_impl)
 LEQ_spec: "\<forall>n m. \<Gamma>\<turnstile> \<lbrace>\<acute>i=n \<and> \<acute>j=m\<rbrace>  PROC LEQ(\<acute>i,\<acute>j,\<acute>r) \<lbrace>\<acute>r = (n \<le> m)\<rbrace>"
  apply vcg
  apply simp
  done


print_locale Max_impl
locale Max_test' = Max_impl where
        i_'compare_' = i_'LEQ_' and
        j_'compare_' = j_'LEQ_' and
        r_'compare_' = r_'LEQ_'
        + LEQ_impl
lemma (in Max_test')
  shows
  "\<forall>n m. \<Gamma>\<turnstile> \<lbrace>\<acute>n=n \<and> \<acute>m=m\<rbrace> \<acute>k :== CALL Max(LEQ_'proc,\<acute>n,\<acute>m) \<lbrace>\<acute>k = mx (\<le>) n m\<rbrace>"
proof -
  note Max_spec = Max_spec5
  show ?thesis
    apply vcg
    apply (rule_tac x="(\<le>)" in exI)
    apply clarsimp
    apply (rule LEQ_spec [rule_format])
    done
qed

end