{ [V:Type]
    ((v1,v2:V.  Dec(v1 = v2))
     (A:Id List. W:{a:Id| (a  A)}  List List.
          (two-intersection(A;W)
           (f:ConsensusState  (consensus-state3(V) List)
                (cs-ref-map-constraints(V;A;W;f)
                 (x,y:ts-reachable(consensus-ts4(V;A;W)).
                      ((x ts-rel(consensus-ts4(V;A;W)) y)
                       (i:
                            ((v:V
                                (in state x, inning i could commit v 
                                 in state y, inning i could commit v ))
                                ((f y[i] = f x[i])
                                   (v:V
                                      ((f y[i] = COMMITED[v])
                                       (f x[i] = CONSIDERING[v]))))) supposing 
                               ((i < ||f y||) and 
                               (i < ||f x||)))))))))) }

{ Proof }



Definitions occuring in Statement :  cs-ref-map-constraints: cs-ref-map-constraints(V;A;W;f) two-intersection: two-intersection(A;W) cs-inning-committable: in state s, inning i could commit v  consensus-ts4: consensus-ts4(V;A;W) consensus-state4: ConsensusState cs-commited: COMMITED[v] cs-considering: CONSIDERING[v] consensus-state3: consensus-state3(T) Id: Id select: l[i] length: ||as|| nat: decidable: Dec(P) uimplies: b supposing a uall: [x:A]. B[x] infix_ap: x f y all: x:A. B[x] exists: x:A. B[x] implies: P  Q or: P  Q and: P  Q less_than: a < b set: {x:A| B[x]}  apply: f a function: x:A  B[x] list: type List universe: Type equal: s = t l_member: (x  l) ts-reachable: ts-reachable(ts) ts-rel: ts-rel(ts)
Definitions :  uall: [x:A]. B[x] implies: P  Q all: x:A. B[x] infix_ap: x f y uimplies: b supposing a and: P  Q member: t  T le: A  B not: A false: False prop: exists: x:A. B[x] cand: A c B or: P  Q guard: {T} cs-ref-map-constraints: cs-ref-map-constraints(V;A;W;f) ts-reachable: ts-reachable(ts) consensus-ts4: consensus-ts4(V;A;W) nat: ts-type: ts-type(ts) pi1: fst(t) iff: P  Q rev_implies: P  Q decidable: Dec(P) ts-stable: ts-stable(ts;x.P[x])
Lemmas :  consensus-state3-cases select_wf cs-inning-committable_wf length_wf1 consensus-state3_wf nat_wf ts-rel_wf ts-reachable_wf consensus-ts4_wf ts-type_wf cs-ref-map-constraints_wf consensus-state4_wf two-intersection_wf l_member_wf Id_wf decidable_wf not_wf cs-commited_wf cs-considering_wf cs-inning-committable-step decidable__cs-inning-committed cs-inning-committed_wf consensus-ts4-inning-committed-stable

\mforall{}[V:Type]
    ((\mforall{}v1,v2:V.    Dec(v1  =  v2))
    {}\mRightarrow{}  (\mforall{}A:Id  List.  \mforall{}W:\{a:Id|  (a  \mmember{}  A)\}    List  List.
                (two-intersection(A;W)
                {}\mRightarrow{}  (\mforall{}f:ConsensusState  {}\mrightarrow{}  (consensus-state3(V)  List)
                            (cs-ref-map-constraints(V;A;W;f)
                            {}\mRightarrow{}  (\mforall{}x,y:ts-reachable(consensus-ts4(V;A;W)).
                                        ((x  ts-rel(consensus-ts4(V;A;W))  y)
                                        {}\mRightarrow{}  (\mforall{}i:\mBbbN{}
                                                    ((\mforall{}v:V
                                                            (in  state  x,  inning  i  could  commit  v 
                                                            {}\mRightarrow{}  in  state  y,  inning  i  could  commit  v  ))
                                                          {}\mRightarrow{}  ((f  y[i]  =  f  x[i])
                                                                \mvee{}  (\mexists{}v:V
                                                                        ((f  y[i]  =  COMMITED[v])
                                                                        \mwedge{}  (f  x[i]  =  CONSIDERING[v])))))  supposing 
                                                          ((i  <  ||f  y||)  and 
                                                          (i  <  ||f  x||))))))))))


Date html generated: 2011_08_16-AM-10_04_52
Last ObjectModification: 2011_06_18-AM-09_01_03

Home Index