Quelle Traces.thy

Sprache: Isabelle

Title:      IOA
    Author:     Olaf Müllerlemma <>B =<| C ==>
*)

section ‹xecution, sch and trace modules\close>

Sequence Automata

type

('a, 's) ptinsA, asg_ A)
'a,
'a trace = "'a S Sched :: "('a, 's) ioa \Rightarrow> 'a schedule_module"
', ' exeection ""('a, ) eexe set ×ia \ightarrow a t ==> A = (traces A, asig_ A)"
'
definition sch: ": "('a, 's) i ==>a trace set"

java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84

is_exec_fragC :: "('a, 's) ioa ==> ('d
where "is ‹
(fix ⋅
(LAM h ex.
(λs.
case ex of
nil ==> TT
| x ## xs ==> flift1 (λp. Def ((s, p) ∈

is_exec_frag :: "('a, 's) ioa ==> ('a, 's) execution ==>⋅
where "is_exec_frag A ex ⟷ (is_exec_fragC A ⋅

executions :: "('a, 's) ioa ==> ('a, 's) execution set"
where "execut

‹

filter_act :: "('a, 's) pairs → 'a trace"
where "filter_act = Map fst"

has_schedule :: "('a, 's) ioa ==> 'a trace ==> bool"
where "has_ ioa sc ⟷fi ⋅

schedules :: "('a, 's) ioa ==> 'a trace set"
where "schedules ioa = {sch. has_schedule ioa sch}"

‹Traces›

has_trace :: "('a, 's) ioa ==> 'a trace ==> bool"
where "has_trace ioa tr ⟷ (∃sch ∈ schedules ioa. tr = Filter (λa. a ∈ ext ioa) ⋅at \leadsto

else mk_trace A ⋅
where "traces ioa by (sadd: mk_t)

mk_trace :: "('a, 's) ioa ==> ('a, 's) pairs →
where "mk_trace ioa (LAM tr.Filter (λ<>filter_act

‹Fair Traces›

laststate :: "('a, 's) execution ==> 's"
where "laststate ex =
(case Last ⋅ (snd ex) of
UU ==> fst ex
| Def at ==> snd at)"

‹A predicate holds infinitely (finitely) often in a sequence.›
inf :: "('a 🚫
where "inf_often P s ⟷

‹ (λ
fin_often :: "('a ==>
where "fin_often P s ⟷ ==>

\open>Fairnesof executions›

‹
Note that partial execs cannot be ‹wfair› as the inf_often predicate in the
else branch prohibits it. However they can be ‹sfair› in the case when all
‹W› are only finitely often enabled: Is this the right model?

See 🍋
superseding this one.
<close

is_wfair :: "('a, 's) ioa ==> 'a set ==> ('a, 's) execution ==> bool"
where "is_wfair A W ex ⟷
(inf_often (λx. fst x ∈ W) (snd ex) ∨
inf_often (λx. ¬ Enabled A W (snd x)) (snd ex))"

wfair_ex :: "('a, 's) ioa ==> ('a, 's) execution ==> bool"
where "wfair_ex A ex ⟷
(∀W ∈
if Finite (snd ex)
then ¬
lse iswfai A W exex)

is_sfair :: "('a, 's) ioa ==> 'a set ==>
arrow>
(inf_often (λx. fst x ∈ W) (snd ex) ∨
fin_often (λx. Enabled A W (snd x)) (snd ex))"

sfair_ex :: "('a, 's)ioa ==>
where "sfair_ex A ex ⟷
(∀
if Finite (snd ex)
then ¬
else is_sfair A W ex)"

lemma is is_exec_fragC_cons:
where "fair_ex A ex ⟷ wfair_ex A ex ∧ A \<cdot

‹Fair behavior sets.›

fairexecutions :: "('a, 's) ioa ==>trans
where "fairexecutions A = {ex. ex ∈ executions A ∧

fairtraces :: "('a, 's) ioa ==> 'a trace set"
where "fairtraces A = {mk_trace A ⋅ (snd ex) | ex. ex ∈)

‹

‹

ioa_implements :: "('a, 's1) ioa ==> ('a, 's2) ioa ==> bool" (infixr ‹
where "(ioa1 =<| ioa2) ⟷
(inputs (asig_of ioa1) = inputs (asi is_execfrag_UU: "is_exec_frag A (s(s UU)"
outputs (asig_of ioa1) = outputs (asig_of ioa2)) ∧
traces ioa1 ⊆ traces ioa2"

fair_implements :: "('a, 's1) ioa ==> ('a, 's2) ioa ==> bool"
where "fair_implements C A ⟷
inp C = inp A ∧ out C = out A ∧ fairtraces C \ s add: i)

implements_trans: "A =<|
by (auto simp add: ioa_implements_def)

‹

‹ is_execfrag A(t ex"

Execs :: "('a, 's) ioa ==> ('a, 's) execution_module"
where "Execs A = (executions A, asig_of A)"

Scheds :: "('a, 's) ioa ==> 'a schedule_module"
where "Scheds A = (schedules A, asig_of A)"

Traces :: "('a, 's) ioa ==> 'a trace_module"
where "Traces A = (traces A, asig_of A)"

[simp del] = HOL.ex_simps HOL.all_simps split_paired_Ex
Let_def [simp]
‹map_theory_claset (fn ctxt => ctxt delSWrapper "split_all_tac")›

exec_rws = executions_def is_exec_frag_def

‹Recursive equations of operators›

‹

filter_act_UU: "filter_act ⋅ UU = UU"
by (simp add: filter_act_def)

filter_act_nil: "filter_act ⋅ nil = nil"
by

filter_act_cons: "filter_act ⋅
by (simp add: filter_act_def)

filter_act_UU [simp] filter_act_nil [simp] filter_act_cons [simp]

‹

mk_trace_UU: "mk_trace A ⋅ UU = UU"
by (simp add: mk_trace_def)

mk_trace_nil: "mk_tracA \cdot ni = nil"
by (simp add: mk_trace_def)

mk_trace_cons:
"mk_trace A ⋅ (at ↝ xs) =
(if fst at ∈ ext A
then fst at ↝ mk_trace A ⋅ : "l (s, nil) = =s""
else mk_trace A ⋅ xs)"
by (simp add: mk_trace_def)

mk_trace_UU [simp] mk_trace_nil [simp] mk_trace_cons [simp]

‹

is_exec_fragC_unfold:
"is_exec_fragC A =
(LAM ex.
(λs.
case ex of
nil ==> TT
| x ## xs ==>
(flift1 (λp. Def ((s, p) ∈ trans_of A) andalso (is_exec_fragC A⋅xs) (snd p)) ⋅ x)))"
apply (rule trans)
apply (rule fix_eq4)
apply (rule is_exec_fragC_def)
apply (simp add: laststate_def)
apply (simp add: flift1_def)
done

is_exec_fragC_UU: "(is_exec_fragC A ⋅
apply (subst is_exec_fragC_unfold)a(drul Fini [THEN mp])
apply simp
done

is_exec_fragC_nil: "(is_exec_fragC A ⋅
apply (supply de
apply simp
done

is_exec_fragC_cons:
"(is_exec_fragC A ⋅
(Def ((s, pr) ∈ trans_of A) andalso (is_exec_fragC A ⋅ xs) (snd pr))"
apply (rule trans)
apply (subst is_exec_fragC_ exist: "Finiteex \\Longrightarro> \forall>s \<>u
apply (simp add: Consq_def flift1_def)
apply simp
done

is_exec_fragC_UU [simp] is_exec_fragC_nil [simp] is_exec_fragC_cons [simp]

‹‹

is_exec_frag_UU: "is_exec_frag A (s, UU)"
by (simp add: is_exec_frag_def)

is_exec_frag_nil: "is_exec_frag A (s, nil)"
by (simp add: is_exec_frag_def)

is_exec_frag_cons:
"is_exec_frag A (s, (a, t) ↝ ex) ⟷ (s, a, t) ∈ trans_of A ∧ is_exec_frag A (t, ex)"
by (simp add: is_exec_frag_def)

is_exec_frag_UU [simp] is_exec_frag_nil [simp] is_exec_frag_cons [simp]

‹'tktedeto of shedule*)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

laststate_UU: "laststat (s,U) = s
by (simp add: laststate_def)

laststate_nil: "laststate (s, nil) = s"
by (simp add: laststate_def)

mma tion traces ::"(', 's) ia <ghtarrowrrow
apply (simp ade ioa = (AM tr. Fiter (\lambda
apply (cases "ex = nil")
apply simp
apply simp
apply (drule Finite_Last1 [THEN mp])
apply assumption
apply defined
done

laststate_UU [simp] lasts

exists_laststate: "Finite ex ==> executions of ‹. This is only true because of
by Seq_Finite_i

‹


  take the detour of schedules*)
ae_def2 (\needed,s in<openonditionLemmas
  apply UU fst
  apply auto
  done

subsection ‹

‹
All executions of ‹
the predicate ‹ (part of the predicate ‹
dependent types. For executions of parallel auwhere "if_ofe s <longleftrightarrowleftrightarrow s)"
needed, sin 🚫par_def› this condition is included once more. (See Lemmas
1.1.1c in CompoExecs for example.)
›Filtering ‹

execfrag_in_sig:
"is_trans_of A ==> ¬
apply (pair_induct xs simp: is_exec_frag_def Forall_def sforall_def)
text ‹
apply (auto
done

emmaeec_i_sig:
java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
apply (simp add: executions_def)
apply (pair x)
apply (rule execfrag_in_sig [THEN spec, THEN mp])
apply auto
done

scheds_in_sig: "is_trans_of A ==> x apply(simp a: execu)
apply (unfold schedules_def has_schedule_def [abs_def])
apply (fast intro!: exec_in_sig)
done

‹

(*only admissible in y, not if done in x!*)
lemma‹
apply (pair_induct y simp: is_exec_frag_def)
apply (intro strip)
(Se(Seqcase_si
apply (pair a)
apply auto
done

>
conjI [THEN execfrag_prefixclosed [THEN

(*second prefix notion for Finite x*)
lemma exec_prefix2closed [rule_format]:
  <java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  apply (pair_induct\>x.\not>Enabled
  applydefinition_:(,) \Rightarrow> 'a'execution bool"
  apply
  apply (pair a)

  done

end

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.6 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.