{ 
[M:Type 
Type]
n2m:
pMsg(P.M[P]). l2m:Id pMsg(P.M[P]). S0:System(P.M[P]).
env:pEnvType(P.M[P]).
let r = pRun(S0;env;n2m;l2m) in
e1,e2:runEvents(r).
(P:Process(P.M[P])
((P 
run-event-state-when(r;e1))
(iterate-Process(P;map(
e.run-event-msg(r;e);
run-event-interval(r;e1;e2)))
run-event-state(r;e2)))) supposing
((run-event-step(e1) 
run-event-step(e2)) and
(run-event-loc(e1) = run-event-loc(e2)))
supposing Continuous+(P.M[P]) }
{ Proof }
Definitions occuring in Statement :
run-event-interval: run-event-interval(r;e1;e2),
run-event-step: run-event-step(e),
run-event-loc: run-event-loc(e),
run-event-state-when: run-event-state-when(r;e),
run-event-state: run-event-state(r;e),
run-event-msg: run-event-msg(r;e),
runEvents: runEvents(r),
pRun: pRun(S0;env;nat2msg;loc2msg),
pEnvType: pEnvType(T.M[T]),
System: System(P.M[P]),
iterate-Process: iterate-Process(P;msgs),
pMsg: pMsg(P.M[P]),
Process: Process(P.M[P]),
Id: Id,
strong-type-continuous: Continuous+(T.F[T]),
map: map(f;as),
nat: ,
let: let,
uimplies: b supposing a,
uall: [x:A]. B[x],
so_apply: x[s],
le: A B,
all: x:A. B[x],
implies: P Q,
lambda: x.A[x],
function: x:A B[x],
universe: Type,
equal: s = t,
l_member: (x l)
Definitions :
uall: [x:A]. B[x],
uimplies: b supposing a,
strong-type-continuous: Continuous+(T.F[T]),
so_apply: x[s],
all: x:A. B[x],
let: let,
implies: P Q,
member: t T,
ext-eq: A 
B,
and: P 
Q,
fulpRunType: fulpRunType(T.M[T]),
so_lambda: 
x.t[x],
pRunType: pRunType(T.M[T]),
top: Top,
prop: 
,
subtype: S 
T,
nat_plus: 
,
le: A B,
not: 
A,
false: False,
ge: i 
j ,
squash: 
T,
true: True,
exists: 
x:A. B[x],
cand: A c B,
nat: ,
Id: Id,
runEvents: runEvents(r),
map: map(f;as),
iterate-Process: iterate-Process(P;msgs),
ycomb: Y,
dataflow-ap: df(a),
System: System(P.M[P]),
pi1: fst(t),
run-event-step: run-event-step(e),
or: P 
Q,
rev_implies: P 
Q,
iff: P Q,
sq_type: SQType(T),
guard: {T},
l_contains: A B,
l_all: (xL.P[x]),
Process-apply: Process-apply(P;m)
Lemmas :
run-event-state-next,
nat_wf,
pRun_wf,
fulpRunType_wf,
subtype_rel_function,
Id_wf,
pMsg_wf,
unit_wf,
System_wf,
top_wf,
ldag_wf,
pInTransit_wf,
subtype_rel_self,
subtype_rel_simple_product,
pRunType_wf,
runEvents_wf,
sub-mset_wf,
Process_wf,
map_wf,
run-prior-state_wf,
pi1_wf_top,
Process-apply_wf,
run-event-msg_wf,
pExt_wf,
run-event-state_wf,
pEnvType_wf,
strong-type-continuous_wf,
l_member_wf,
run-event-state-when_wf,
run-event-step_wf,
le_wf,
run-event-loc_wf,
run-event-interval-cases,
nat_properties,
ge_wf,
squash_wf,
true_wf,
run-event-interval_wf,
run-event-state-next2,
iterate-Process_wf,
pRun_wf2,
iff_transitivity,
member-reverse,
member_map,
subtype_base_sq,
set_subtype_base,
assert_wf,
is-run-event_wf,
pi2_wf,
product_subtype_base,
int_subtype_base,
atom2_subtype_base,
member-run-event-interval,
list_subtype_base,
member_singleton,
sub-mset-contains,
map_append_sq,
iterate-dataflow-append,
run-event-step-positive
\mforall{}[M:Type {}\mrightarrow{} Type]
\mforall{}n2m:\mBbbN{} {}\mrightarrow{} pMsg(P.M[P]). \mforall{}l2m:Id {}\mrightarrow{} pMsg(P.M[P]). \mforall{}S0:System(P.M[P]). \mforall{}env:pEnvType(P.M[P]).
let r = pRun(S0;env;n2m;l2m) in
\mforall{}e1,e2:runEvents(r).
(\mforall{}P:Process(P.M[P])
((P \mmember{} run-event-state-when(r;e1))
{}\mRightarrow{} (iterate-Process(P;map(\mlambda{}e.run-event-msg(r;e);run-event-interval(r;e1;e2)))
\mmember{} run-event-state(r;e2)))) supposing
((run-event-step(e1) \mleq{} run-event-step(e2)) and
(run-event-loc(e1) = run-event-loc(e2)))
supposing Continuous+(P.M[P])
Date html generated:
2011_08_16-PM-07_04_25
Last ObjectModification:
2011_06_18-AM-11_17_45
Home
Index