Nuprl Lemma : ler_propose_all_max+2_sub
es:EO'. nodes:bag(Id). client:Id. uid:Id 
. L:Id List. succ:{i:Id| (i 
L)} {i:Id| (i L)} . epoch:.
(((ler_leader_ring_messages-delivered{i:l}(client;nodes;uid) es)
ler_consistent_configuration(es)
ler_non_dummy_configuration+(es;nodes)
Inj(Id;;uid)
sub-bag(Id;L;nodes)
no_repeats(Id;L)
ma-ring(L;succ)
(i:{i:Id| (i L)}
e':E
((e1,e2:E. u:.
((e' <loc e1)
(e1 <loc e2)
(<epoch, u> ler_Propose()(e2) 
epoch ler_Choose()(e2))
(
w: 
Id. w ler_Config()(e1))))
<epoch, succ i> ler_Config()(e')
(e'':{e'':E| (e'' <loc e')} . epoch':. j:Id. (<epoch', j> ler_Config()(e'') (epoch' 
epoch)))
(loc(e') = i)
(e:E. (epoch ler_Choose()(e) (e' < e)))))
(j:Id. e:E. (<epoch, j> ler_Config()(e) (loc(e) L))))
(e:E. i:{i:
||L||| (uid L[i]) = imax-list(map(uid;L))} .
(epoch ler_Choose()(e)
(loc(e) L)
(i:||L||. (L[i] = (succ^i loc(e))))
(e':E. <epoch, L[i]> ler_Leader()(e')))))
Proof not projected
Definitions occuring in Statement :
ler_consistent_configuration: ler_consistent_configuration(es),
ler_non_dummy_configuration+: ler_non_dummy_configuration+(es;nodes),
ler_Leader: ler_Leader(),
ler_leader_ring_messages-delivered: ler_leader_ring_messages-delivered{i:l}(client;nodes;uid),
ler_Propose: ler_Propose(),
ler_Choose: ler_Choose(),
ler_Config: ler_Config(),
ma-ring: ma-ring(R;s),
Message: Message,
classrel: v X(e),
event-ordering+: EO+(Info),
es-locl: (e <loc e'),
es-causl: (e < e'),
es-loc: loc(e),
es-E: E,
Id: Id,
select: l[i],
map: map(f;as),
length: ||as||,
inject: Inj(A;B;f),
int_seg: {i..j
},
le: A B,
all: x:A. B[x],
exists: x:A. B[x],
not: A,
squash: T,
implies: P Q,
or: P Q,
and: P Q,
set: {x:A| B[x]} ,
apply: f a,
function: x:A B[x],
pair: <a, b>,
product: x:A B[x],
list: type List,
natural_number: $n,
int: ,
equal: s = t,
no_repeats: no_repeats(T;l),
l_member: (x l),
fun_exp: f^n,
sub-bag: sub-bag(T;as;bs),
bag: bag(T),
imax-list: imax-list(L)
Definitions :
all: x:A. B[x],
implies: P Q,
and: P Q,
exists: x:A. B[x],
or: P Q,
not: A,
squash: T,
le: A B,
member: t T,
cand: A c B,
true: True,
gt: i > j,
false: False,
prop: 
,
nat: ,
subtype: S 
T,
top: Top,
suptype: suptype(S; T),
Id: Id,
int_seg: {i..j},
ler_send_leader: ler_send_leader(),
lelt: i j < k,
sq_or: a b,
es-locl: (e <loc e'),
es-p-local-pred: es-p-local-pred(es;P),
Message: Message,
pi1: fst(t),
pi2: snd(t),
ler_Leader: ler_Leader(),
name: Name,
es-header: es-header(es;e),
assert: 
b,
msg-type: msg-type(msg),
msg-body: msg-body(msg),
make-Msg: make-Msg(hdr;typ;val),
ifthenelse: if b then t else f fi ,
pMsg: pMsg(P.M[P]),
mData: mData,
msg-has-type: msg-has-type(m;T),
fun_exp: f^n,
primrec: primrec(n;b;c),
ycomb: Y,
eq_int: (i =
j),
btrue: tt,
ler_send_propose: ler_send_propose(),
l_exists: (xL. P[x]),
ler_Propose: ler_Propose(),
uall: [x:A]. B[x],
uimplies: b supposing a,
ler_leader_ring_messages-delivered: ler_leader_ring_messages-delivered{i:l}(client;nodes;uid),
sq_type: SQType(T),
guard: {T},
messages-delivered: messages-delivered{i:l}(es;X),
rev_implies: P 
Q,
iff: P Q,
sub-bag: sub-bag(T;as;bs),
rev_uimplies: rev_uimplies(P;Q),
uiff: uiff(P;Q),
ler_non_dummy_configuration+: ler_non_dummy_configuration+(es;nodes),
ler_Nbr: ler_Nbr(),
let: let,
no_repeats: no_repeats(T;l),
inject: Inj(A;B;f)
Lemmas :
ler_propose_all_max2_sub,
int_seg_properties,
length_wf,
Id_wf,
int_seg_wf,
select_wf,
fun_exp_wf,
l_member_wf,
le_wf,
es-loc_wf,
event-ordering+_inc,
Message_wf,
classrel_wf,
ler_Choose_wf,
imax-list_wf,
map_wf,
non_neg_length,
map_length,
length_wf_nat,
top_wf,
es-E_wf,
ler_leader_ring_messages-delivered_wf,
ler_consistent_configuration_wf,
ler_non_dummy_configuration+_wf,
inject_wf,
sub-bag_wf,
bag_qinc,
no_repeats_wf,
ma-ring_wf,
es-locl_wf,
ler_Propose_wf,
not_wf,
squash_wf,
ler_Config_wf,
es-causl_wf,
bag_wf,
event-ordering+_wf,
subtype_base_sq,
int_subtype_base,
atom2_subtype_base,
ler_send_leader_wf,
ler_Leader_ilf,
bag-member-append,
bag-member-list,
decidable__equal_Id,
bag-member_wf,
prior-classrel-p-local-pred,
ler_Nbr_wf,
es-causl_transitivity2,
es-causle_weakening,
primed-class_wf,
ler_Config_to_Nbr2,
rec-combined-loc-class-opt-1-classrel,
simple-loc-comb-2-concat-classrel,
ifthenelse_wf,
lt_int_wf,
single-bag_wf,
primed-class-opt_wf,
ler_dumEpoch_wf,
rec-combined-loc-class-opt-1_wf,
concat-lifting-loc-2_wf,
base-noloc-classrel,
name_wf,
assert_wf,
eq_term_wf,
type-valueall-type,
msg-body_wf2,
ler_Leader_wf,
es-causle_weakening_eq,
es-causle_wf,
ler_send_propose_wf,
ler_Propose_ilf,
select_member,
fun_exp_add1-sq,
list-subtype,
base-headers-msg-val_wf,
imax_wf,
nat_wf,
imax-left,
imax-list-ub,
member_map,
es-causl_transitivity1
\mforall{}es:EO'. \mforall{}nodes:bag(Id). \mforall{}client:Id. \mforall{}uid:Id {}\mrightarrow{} \mBbbZ{}. \mforall{}L:Id List. \mforall{}succ:\{i:Id| (i \mmember{} L)\} {}\mrightarrow{} \{i:Id|
(i \mmember{} L)\} .
\mforall{}epoch:\mBbbZ{}.
(((ler\_leader\_ring\_messages-delivered\{i:l\}(client;nodes;uid) es)
\mwedge{} ler\_consistent\_configuration(es)
\mwedge{} ler\_non\_dummy\_configuration+(es;nodes)
\mwedge{} Inj(Id;\mBbbZ{};uid)
\mwedge{} sub-bag(Id;L;nodes)
\mwedge{} no\_repeats(Id;L)
\mwedge{} ma-ring(L;succ)
\mwedge{} (\mforall{}i:\{i:Id| (i \mmember{} L)\}
\mexists{}e':E
((\mforall{}e1,e2:E. \mforall{}u:\mBbbZ{}.
((e' <loc e1)
{}\mRightarrow{} (e1 <loc e2)
{}\mRightarrow{} (<epoch, u> \mmember{} ler\_Propose()(e2) \mvee{} epoch \mmember{} ler\_Choose()(e2))
{}\mRightarrow{} (\mneg{}\mdownarrow{}\mexists{}w:\mBbbZ{} \mtimes{} Id. w \mmember{} ler\_Config()(e1))))
\mwedge{} <epoch, succ i> \mmember{} ler\_Config()(e')
\mwedge{} (\mforall{}e'':\{e'':E| (e'' <loc e')\} . \mforall{}epoch':\mBbbZ{}. \mforall{}j:Id.
(<epoch', j> \mmember{} ler\_Config()(e'') {}\mRightarrow{} (epoch' \mleq{} epoch)))
\mwedge{} (loc(e') = i)
\mwedge{} (\mforall{}e:E. (epoch \mmember{} ler\_Choose()(e) {}\mRightarrow{} (e' < e)))))
\mwedge{} (\mforall{}j:Id. \mforall{}e:E. (<epoch, j> \mmember{} ler\_Config()(e) {}\mRightarrow{} (loc(e) \mmember{} L))))
{}\mRightarrow{} (\mforall{}e:E. \mforall{}i:\{i:\mBbbN{}||L||| (uid L[i]) = imax-list(map(uid;L))\} .
(epoch \mmember{} ler\_Choose()(e)
{}\mRightarrow{} (loc(e) \mmember{} L)
{}\mRightarrow{} (\mforall{}i:\mBbbN{}||L||. (L[i] = (succ\^{}i loc(e))))
{}\mRightarrow{} (\mdownarrow{}\mexists{}e':E. <epoch, L[i]> \mmember{} ler\_Leader()(e')))))
Date html generated:
2012_02_20-PM-06_10_47
Last ObjectModification:
2012_02_02-PM-02_40_56
Home
Index