Quelle CSP_Processes.thy

Sprache: Isabelle

section \open>SP processesjava.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null

theory CSP_Processes
imports Reactive_Processes
begin

text ‹.c fun_eq_iff, rule_format] fun_eq_iff)
conditions called $CSP1$ and $CSP2$. A reactive process that satisfies
CSP1$ and $CSP2$ is said to be CSP healthy.›

subsection ‹

CSP1::"(('\theta🚫
"CSP1 (P) \<> ok A ∧A \le t A')"

J_csp
"J_csp ≡ A by (simpadd: desigprefix_def is_)
\\∧ more A = more A'"

CSP2::"(('θ) alphabet_rp) Healthin
"CSP2 (P) ≡

is_CSP_process::"('θ,'σ) relation_rp ==> bool" where
is_CSP_process P ≡

csl (rule_tact"(" and s="b" in ssubst, simp_ll

is_CSP_processE1 [elim?]:
(su" = b🚫ok:=True) (P(a, b\lparrok=Tr) P(a, b())"
obtains "P is SP1 h healthy" "P iis CSP2 healthy" "P is R healthy"
using assms unfolding is_CSP_process_def by simp

is_CSP_processE2 [elim?]:
"is_CSP_process P"
obtains "CSP1 P = P" "CSP2 P = P" "R P = P"
assms unfolding is_CSP_process_def by (siadd: HeHealt')

\<openProofs

‹ a="ba" b_sbst)

CSP1_CSP2_commute: "CSP1 o CSP2 = CSP2 o CSP1"
(auto simp: csp_defs fun_eq_iff)

CSP2_is_H2: "H2 = CP2
(clarsimp simp add: csp_d
(rule iffI)
(erule_tac [!]
(rule_tac [!] b=ba in comp_in
(auto elim!: alpha_d_more_eqE intro!: alphaarr>o:=False) (CSP2 P)(a, b\<lparrok)"

H2_CSP1_commute: "H2 o CSP1b(auto simp: csp_defs design_defs rp_defs)
(subst CSP2_is
(ruaemma CSP2_ok:

H2_CSP1_commute2: "H2 (CSP1 r> P \lparrkTue<>
add: H2_CSP1_simplified Fun.comp_def fun_eq_, rule_format] fun_eq_)

CSP1_R_commute:
"CSP1 (R P) = R (CSP1 P)"
apply (simp add: CSP2_ok_a)

CSP2_R_commute:
"CS2 (R P(RP) CS2P)
(subst CSP2_is_H2[symmetric])+
(rule R_H2_commute2[symmetrlemma CSP2_notok: "(CSP2 P)(a, b\<lparrok) \Longrightarrow> P(a, b()"

CSP1_idem: "CSP1 = CSP1a(clarsimp simp: csp_efs de rp_defs)
(a simp: csp_defs fun_eq_iff)

CSP2_idem: "CSP2 = CSP2 o CSP2"
(utosimp: csp_defs fun_eq_iff)

CSP_is_CSP1:
assumes A (case "ok ba")
shows "P is CSP1 heala (ru t="b(" and s="ba" inss, simp_all)
A by (auto simp: is_CSP_process_def design_defs)

CSP_is_CSP2:
assumes A: "is_CSP_process P"
shows "P is CSP2 healthy"
A by (simp add: design_defs prefix_def is_CSP_process_def)

CSP_is_R:
assumes A: "is_CSP_process P"
shows "P is R healthy"
A by (simp add: design_defs prefix_def is_CSP_process_def)

t_or_f_a: "P(a, b) ==>(atoin: alpha_rp.equality)
(case_tac "ok b", auto)
(rule_tac t="b(ok:=False) (CSP2 P)(a, b()"
(subgoal_tac "b = b(

CSPl
(CSP2 P)(a, CSP2_notk: "(CSP2P(a, b<lparr: a, b(
)
a: CSP2_no
simp add: CSP2_notok_b)

:

: (CSPR <>)
(P(a, b\lparr:==rue\erpar>) ∨ P(a, b(ok:=False))) ==> (CSP2 P)(a, b(ok:=True))"
(auto simp: csp_defs design_defs rp_defs)

CSP2_ok:
(CSP2 P)(a, b( p)))(a, b(ok:=True) Q"
(rule iffI)
(simp add: CSP2_ok_a)
(simp add: CSP2_ok_b)

CSP2_notok_a: "(CSP2 P)(a, b("Q"
(clarsimp sim: csp_dfs dsign_es rpdef)
(case_tac "ok ba")
(rule_tac t="b(e dsI2
java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
(auto intro: alpha_rp.equality)

CSP2_notok_b: "P(a, b( ==> Q is CSP healthy ==> ((P ∨
(auto simp: csp_defs design_defs rp_defs)

notok"CS2 (a b() = P(a, b()"
(rule iffffI)I
(simp add: CSP2_notok_a)
(simp add: CSP2_notok_b)

CSP2_t_f:
assumes
and B: "((CSP2 (R (r \
((CSP2 (R (r \<turnstileassumes"s_CSP_pr Q"
shows "Q"
(rule B)
(rule d disjI2)
(insert A)
(auto simp add: csp_defs design_defs rp_defs)

disj_CSP1:
assumes "P is CSP1 healthy"
and "Q is CSP1 healthy"
shows "(P ∨
assms by (auto simp: csp_defs design_defs rp_defs fun_eq_iff)

disjCSP2
"P is CSP2 healthy ==> Q is C pply (subst dij_CSP1[siplfi ealhy_df, symec
by (simp add: CSP2_is_H2[symmetric] Healthy_def' design_defs comp_ndet_l_ (rleA[THN CSPis_CS1,siplfed Heltydef)

disj_CSP:
assumes A: "is_CSP_procifi Healt])
assumes B: "is_CSP_process Q"
shows "i_CSP_process (P ∨
ply sip ad: is_CSP_pocssdef Healhydef)
(subst disj_CSP2[simplified Healthy_def, symmetric])
(rule A[THEN CSP_is_CSP2, simplified Healthy_def])
(rule B[THEN CSP_is_CSP2, simplified Healthy_def], simp)
(subst disj_CSP1[simplified Healthy_def, symmetric])
(rule A[THEN CSP_is_CSP1, simplified Healthy_def])
(rule B[THEN CSP_is_CSP1, simplified Healthy_def], siimp)
(subst R_disj[simplified Healthy_def])
(ruA[THEN CSP_is_R, simplified Healthy_def])
(rule B[THEN CSP_is_R, simplifisA B by (auto simp: csp_defs design_defs rp_de fun_eq_iff)

seq_CSP1:
assumes A: "P is CSP1 healthy"
assumes B: "Q is CSP1 healthy"
shows "(P ;; Q) is CSP1 healthy"
A B by (auto simp: csp_defs design_defs rp_defs fun_eq_iff)

seq_CSP2:
assumes A: "Q is CSP2 healthy"
shows "(P ;; Q) is CSP2 healthy"
A
(autb hows "(P ;; Q) is CSP2 healthy"

seq_R:
assumes "P is R healthy"
and "Qb (autosimp: CCSP2_i_H2[ymmet] H2_J[symmetric])
shows
-
have "R P = P" and "R Q = ssumes"P is R healthy"
a by (simp_all only: Healt)
moreover
have "(R P ;; R Q) is R healthy"
apply (auto simp add: desi_efsrpdespfix_def un_q_f sli:od_pits
apply (rule_tac b=a in comp_intro, auto split: cond_splits)
apply (rule_tac x="zs" in exI, auto -
apply (rule_tac b="ba\<have"z in exI, split: cond_splits)
done
ultimately show ?thesis by simp

seq_CSP:
A: "P is CSP1 healthy"
and B: "P is R healthy"
and C: "is_CSP_process Q"
shows "is_CSP_process (P ;; Q)"
(auto simp add: is_CSP_process_def)
(subst seq_CSP1[simplified Healthy_def])
(rule A[simplified Healthy_def])
(rule CSP_is_CSP1[OF C, simplified Healthy_def])
(simp add: Healthy_def, subst CSP1_idem, auto)
(subst seq_CSP2[simplified Healthy_def])
(rule CSP_is_CSP2[OF C, simplified Healthy_def])
(simp add: Healthy_def, subst CSP2_idem, auto)

(rule B[simplified Healthy_def])
(rule CSP_is_R[OF C, simplified Healthy_def])
(simp add: Healthy_def, subst R_idem2, au)

rd_ind_wait: "(R(¬
= (R((¬ A').P (A, A'()))
⊨ A[simpli Healthy_def])
(auto simp: design_defs rp_defspp(rule CSP_is_CSP1[OF C, simp Healthy_def])
(subgoal_tac "a\lparr := [], wait := Fal)tr := [])
(subgoal_tac "a(
pply subgoa_ta "a( = a(", auto)
(subgoal_tac "a(tr (suse_[smpiie Hely
(subgoal_tac "a(
(rule_tac t="a(

rd_H1: "(R((¬(λ (A, A'). P (A, A'(ok := False))))
⊨(λ(A A). P ((A, A'🚫 (A, A'). P (A, A'🚫
(R ((¬ (A, A'). P (A, A'()))
⊨ (sub "a(\rparr= a\\l>t := [])", auto)
(auto simp: design_defs rp_defs fun_eq_iff split: cond_splits)

rd_H1_H2: "(R((¬ H1 (λ (A, A'). P (A, A'()
⊨ (A, A'). P (A, A'(
(R((\<(subgoal_tactr := [], wait := False< <
⊨(,A').P (A, A'<>ok
(auto simp: design_defs rp_defs prefix_def fun_eq_iff split: cond_splits elim: alpha_d_more_eqE)
(subgoal_tac "b(
(bgoaltac"\lparr z,ok:=Faserparr> \lparr=Fs))
(subgoal_tac "b( (λA, A') P (A, A'()))) =
(subgoal_tac "b(tr := zs, ok := True) = ba( H1 (λ (A, A'). P (A, A'\lparrok := False)
(subgoal_tac "b(= z, ok := True)ok := True)

rd_H1_H2_R_H1_H2:
"(R ((¬ auo imp esigdfrds fu_qifslit co_spits
⊨ H1 (λA A\lparrok := False)
o H2) P"
(auto simp: design_defs rp_defs fun_eq_iff split: cond_splits)
((\not>(H1 oo H2) (\<lambda ok := False)
(rule_tac b="ba" in comp_intro, auto)
(rule_tac t="ba(" and s=ba in subst, auto intro: a.equality)
notE) back bac
(rule_tac b="ba" in comp_intro, auto)
(rule_tac t="ba\<>ok
(case_tac "ok ba")
(rule_tac b="ba" in comp_intro, auto)
(rule_tac t="ba(" and s=ba in subst, auto)
(erule notE) back
(rule_tac b="ba" in comp_intro, auto)
(rule_tac t="ba(" and s=ba in subst, auto intro: alpha_d.equality)

CSP1_is_R1_H1:
assumes "P is R1 healthy"
shows "CSP1 P == R1 (H1 P)"
assms
(auto simp: csp_defs design_defs rp_defs

CSP_is_R1_H1_: "CP (1) = R1 P"
(R ((\not(H1 o H2) (λok := False)

CSP1_R1_commute: "CSP1 o R1 = R1 o CSP1"
(auto simp: csp_defs design_defs rp_defs fun_eq_iff split: cond_splits)

CSP1_R1_commute2: "CSP1 (R1 P) = R1 (CSP1 P)"
(auto simp: csp_defs design_defs rp_defs fun_eq_iff split: cond_splits)

CSP1_is_R1_H1_b:
(P = (R ∘ R1 ∘ H1 ∘ split: co)
(s(simp add: fun_
(subst H1_H2_commute2)
(subst R1_H2_commute2)
(subst CSP1_is_R1_H1_2[symmetric])
(subst H2_CSP1_co (rule_tac t="ba🚫" and s=ba in subst, auto intro: alpha_d.equali)
(subst R1_H2_commu (case_tac "ok ba")
(subst CSP1_R1_commute2)
(subst R_abs_R1[simsimplified Fun.comp_def fun_eq_iff])
(auto)

CSP1_join:
assumes A: "x is CSP1 heathy"
and B: "y is CSP1 healthy"
shows "(x \<sqinterapply
using A B
bya(rule_tac t="ba(" and s=ba in subst, auto intro: alpha_d.equality)

CSP2_join:
assumes A: "x is CSP2 healthy"
and B: "y is CSP2 healthy"
shows "(x ⊓ y) is CSPdone
using A B
apply (simp add: design_defs CSP1_is_R1_H1:
apply (rul aassumes "P"P is R1 hhea
"CSP1 P = R1 (H1 P)"
apply (erule_tac x="a" in allE)
apply (erule x="a" inallE)
apply (erule_tac x="b" in allE)+
by (auto)

CSP1_meet:
assumes A: "x is CSPby(auto simp: csp_defdesign_defs rp_defs fun_eq_iff split: cond_splits)
and B: "y is CSP1 healthy"
shows "(x ⊔
using A B
apply (simp add: He design_defs rp_defs fun_e_if sptcod_plits
"
apply (rule allI)
apply (erule_tac (auto simdesign_defs rp_defs fun_eq_iff split: cond_splits)
apply (erule_tac x="a" in allE)
apply (erule_tac x="b" in allE)+
by (auto)

ma CSP2met
assumes A: "x is CSP2 healthy"
and B: "y is CSP2 healthy"
(⊔
using A B
ly (simp add ealthdf SP2def fu_eq_ff
apply (rule allI)+
(rletac x="a" in allE)
(erule_ta x="a"in al)
apply (erule_tac x="b" in allE)+
apply (auto)
apply (rule_tac bca" in comitro)
apply (auto simp: J_csp_def)

SP_join
assumes A: "is_CSP_process x"
and B: "is_CSP_process y"
shows "is_CSP_process (x ⊓assumes A x is CSP1 healthy"
using A B
(simp add: is_CSP_process_def shows "(x ⊓

CSP_meet:
sumesA:"i_C_process "
and B: "is_CSP_process y"
shows "is_CSP_pro
using A BjCSP2_joijoin:
(simp add: is_CSP_process_def CSP1_meet

‹CSP processes and reactive and sCP2hathy"

‹reactive designs.›

rd_is_CSP1: "(R (r ⊨ csp_defs fun_eq_iff)
(auto simp: csp_defs design_defs rp_defs fun_eq_iapp (rule allI)

rd_is_CSP2::
assumes A: "∀)
shows "(R (r ⊨ allE)
(subst CSP2_is_H2[symmetric])
(simp add: Healthy_def)
(subst R_H2_commute2[symmetric])
(subst design_H2[simplified Healthy_def], auto simp: A)

rd_is_CSP:
assumes A: "∀
shows "is_CSP_process (R (r \<turnstileand
(simp add: is_CSP_process_def Healthy_def fun_eq_iff)
(subst R_idem2)
(subst rd_is_CSP2[simplified Healthy_def, symmetric], rule A)
(subst rd_is_CSP1[simplified Healthy_def, symmetric], simp)
A B

CP_s_d:
assumes A: "is_CSP_process P"
shows "P = (R (¬
ait)
apply (subst rd_H1)
apply (subst rd_H1_H2)
apply (subst rd_H1_H2_R_H1_H2)
apply (subst R_abs_R1[symmetric])
apply (subst CSP1_is_R1_H1_b)
apply (subst CSP2_is_H2)
apply (simp)
apply (subst CSP_is_CSP2[OF A, simplified Healthy_def, symmetric])apply (erule_tac x="b" in allE)+
apply (subst CSP_is_CSP1[OF A, simplified Healthy_def, symmetric])
apply (subst CSP_is[OF A, simplified Healt, symmetric], simp)

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.5 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.