Nuprl Lemma : consensus-ts5-true-knowledge
[V:Type]
  
A:Id List. 
W:{a:Id| (a 
 A)}  List List. 
x:ts-reachable(consensus-ts5(V;A;W)).
    let x1,x2 = x 
    in 
a,b:{a:Id| (a 
 A)} .
         let I,z = Knowledge(x2;a)(b) 
         in (I 
 Inning(x1;b))
            
 case z
              of inl(p) =>
               let k,v = p 
               in (k < I)
                  
 (
k 
 dom(Estimate(x1;b)))
                  
 (Estimate(x1;b)(k) = v)
                  
 (
i:
. 
i 
 dom(Estimate(x1;b)) supposing (k < i) 
 (i < I))
               | inr(p) =>
               
i:
. 
i 
 dom(Estimate(x1;b)) supposing i < I 
         supposing 
b 
 dom(Knowledge(x2;a))
Proof not projected
Definitions occuring in Statement : 
consensus-ts5: consensus-ts5(V;A;W), 
cs-knowledge: Knowledge(x;a), 
cs-estimate: Estimate(s;a), 
cs-inning: Inning(s;a), 
fpf-ap: f(x), 
fpf-dom: x 
 dom(f), 
id-deq: IdDeq, 
Id: Id, 
assert:
b, 
uimplies: b supposing a, 
uall:
[x:A]. B[x], 
le: A 
 B, 
all:
x:A. B[x], 
not:
A, 
and: P 
 Q, 
less_than: a < b, 
set: {x:A| B[x]} , 
spread: spread def, 
decide: case b of inl(x) => s[x] | inr(y) => t[y], 
list: type List, 
int:
, 
universe: Type, 
equal: s = t, 
l_member: (x 
 l), 
int-deq: IntDeq, 
ts-reachable: ts-reachable(ts)
Definitions : 
true: True, 
cand: A c
 B, 
pi1: fst(t), 
ts-type: ts-type(ts), 
so_lambda: 
x.t[x], 
member: t 
 T, 
implies: P 
 Q, 
prop:
, 
and: P 
 Q, 
uimplies: b supposing a, 
consensus-ts5: consensus-ts5(V;A;W), 
all:
x:A. B[x], 
uall:
[x:A]. B[x], 
consensus-state4: ConsensusState, 
bfalse: ff, 
false: False, 
ifthenelse: if b then t else f fi , 
btrue: tt, 
assert:
b, 
not:
A, 
le: A 
 B, 
sq_stable: SqStable(P), 
reduce: reduce(f;k;as), 
deq-member: deq-member(eq;x;L), 
fpf-empty:
, 
pi2: snd(t), 
cs-estimate: Estimate(s;a), 
cs-inning: Inning(s;a), 
cs-knowledge: Knowledge(x;a), 
fpf-dom: x 
 dom(f), 
ts-init: ts-init(ts), 
infix_ap: x f y, 
Id: Id, 
squash:
T, 
guard: {T}, 
eqof: eqof(d), 
fpf-single: x : v, 
fpf-ap: f(x), 
top: Top, 
uiff: uiff(P;Q), 
so_apply: x[s], 
ts-reachable: ts-reachable(ts), 
iff: P 

 Q, 
unit: Unit, 
bool:
, 
consensus-rel-add-knowledge-step: consensus-rel-add-knowledge-step(V;A;W;x1;x2;y1;y2;a), 
consensus-rel-knowledge-archive-step: consensus-rel-knowledge-archive-step(V;A;W;x1;x2;y1;y2;a), 
consensus-rel-knowledge-inning-step: consensus-rel-knowledge-inning-step(V;A;W;x1;x2;y1;y2;a), 
or: P 
 Q, 
consensus-rel-knowledge-step: consensus-rel-knowledge-step(V;A;W;x1;x2;y1;y2;a), 
exists:
x:A. B[x], 
consensus-rel-knowledge: consensus-rel-knowledge(V;A;W;x;y), 
ts-rel: ts-rel(ts), 
decidable: Dec(P), 
sq_type: SQType(T), 
it:
, 
eq_id: a = b
Lemmas : 
ts-type_wf, 
ts-reachable_wf, 
not_wf, 
cs-estimate_wf, 
subtype-top, 
subtype-fpf2, 
int-deq_wf, 
cs-inning_wf, 
le_wf, 
fpf-ap_wf, 
fpf_wf, 
top_wf, 
fpf-trivial-subtype-top, 
cs-knowledge_wf, 
id-deq_wf, 
fpf-dom_wf, 
assert_wf, 
l_member_wf, 
Id_wf, 
all_wf, 
consensus-state5_wf, 
consensus-state4_wf, 
consensus-ts5_wf, 
ts-reachable-induction, 
subtype_rel_simple_product, 
subtype_rel_self, 
subtype_rel_function, 
sq_stable__all, 
false_wf, 
sq_stable__uall, 
assert_of_bnot, 
eqff_to_assert, 
bnot_wf, 
uiff_transitivity, 
eqtt_to_assert, 
iff_weakening_uiff, 
bool_wf, 
squash_wf, 
sq_stable__not, 
sq_stable__equal, 
decidable__lt, 
decidable__le, 
sq_stable_from_decidable, 
sq_stable__and, 
true_wf, 
list-subtype, 
mk_fpf_wf, 
strong-subtype-self, 
strong-subtype-set3, 
strong-subtype-deq-subtype, 
ts-rel_wf, 
assert_witness, 
decidable__equal_Id, 
atom2_subtype_base, 
subtype_base_sq, 
deq_wf, 
equal_wf, 
not_functionality_wrt_uiff, 
assert-eq-id, 
fpf-single-dom-sq, 
fpf-join-ap-sq, 
eq_id_wf, 
fpf-single_wf
\mforall{}[V:Type]
    \mforall{}A:Id  List.  \mforall{}W:\{a:Id|  (a  \mmember{}  A)\}    List  List.  \mforall{}x:ts-reachable(consensus-ts5(V;A;W)).
        let  x1,x2  =  x 
        in  \mforall{}a,b:\{a:Id|  (a  \mmember{}  A)\}  .
                  let  I,z  =  Knowledge(x2;a)(b) 
                  in  (I  \mleq{}  Inning(x1;b))
                        \mwedge{}  case  z
                            of  inl(p)  =>
                              let  k,v  =  p 
                              in  (k  <  I)
                                    \mwedge{}  (\muparrow{}k  \mmember{}  dom(Estimate(x1;b)))
                                    \mwedge{}  (Estimate(x1;b)(k)  =  v)
                                    \mwedge{}  (\mforall{}i:\mBbbZ{}.  \mneg{}\muparrow{}i  \mmember{}  dom(Estimate(x1;b))  supposing  (k  <  i)  \mwedge{}  (i  <  I))
                              |  inr(p)  =>
                              \mforall{}i:\mBbbZ{}.  \mneg{}\muparrow{}i  \mmember{}  dom(Estimate(x1;b))  supposing  i  <  I 
                  supposing  \muparrow{}b  \mmember{}  dom(Knowledge(x2;a))
Date html generated:
2012_01_23-PM-12_06_20
Last ObjectModification:
2011_12_14-PM-06_37_36
Home
Index