Quelle  reduce_synch.pvs   Sprache: PVS

%
%
% Purpose : a specific instantiation of an inexact middle-value 
%          multi-stage exchange adapted for synchronization properties
%
%


reduce_synch
[
  rho: nonneg_real,      % Bound on drift for a good oscillator
  min_latency: [nat -> nonneg_real], 
                         % Minimum real time latency (in ticks
                         % of real time) of the communication link
                         % between stage i and i+1
                         % determined by things like length of wire, speed
                         % of light, and clock rate.
  var_latency: [nat -> nonneg_real], 
                         % Max variation (in ticks of real 
                         % time) between stage i and i+1
                         % caused by both wire length 
                         % differences and clock jitter.  
  stage: [nat -> posnat] % Number of nodes in a given stage
] : THEORY

  BEGIN

  i, j, k: VAR nat

  source_error(i): MACRO real = 0

  IMPORTING
    reals@sigma_nat,
    reals@real_fun_ops,
    timing_integration[rho, min_latency, var_latency, stage],
    k_ordered[stage, real, <=, source_error],
    protocol[stage, real],
    reduce_synch_stage

  c_src: VAR [i: nat -> [below(stage(i)) -> good_clock[rho]]]
  c_dst: VAR [i: nat -> [below(stage(i)) -> good_clock[rho]]]
  clk: VAR [i: nat -> [below(stage(i)) -> good_clock[rho]]]
  tau: VAR [nat -> tau_type]
  Lag, Schedule: VAR [nat -> integer]
  pi: VAR [nat -> nonneg_real]
  delta: VAR nonneg_real

  cf: VAR k_consensus_function
  icf: VAR [nat -> in_consensus_function]

  status: VAR [i: nat -> node_status[stage(i)]]
  src_set: VAR [i: nat -> non_empty_finite_set[below(stage(i))]] 
  local_check:  VAR [i: nat -> [below(stage(i+1)) -> finite_set[below(stage(i))]]] 

  same_clock?(c_src, c_dst, j, k): bool = 
    FORALL i: j <= i AND i < k IMPLIES
      same_edges?[rho, stage(i+1)](c_src(i+1), c_dst(i+1))

  W(i): nat = W[rho, min_latency(i), var_latency(i)]

  feasible?(Schedule): bool = FORALL i:  Schedule%

  Sched :VAR (feasible?)

  Delay(Sched)(i):%          multi-stage exchange adapted for synchronization properties

  Del(Sched)%

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

  Lag(:VARi  - [(stagei1) > [belowstagei)] 

  Delay_Lag: LEMMA
    Delay(Sched)(i) = W(i+1) + Lag(Sched)(i)

  offset_sent_nominal: LEMMA
    nominal(clk, Schedule)(i) = offset[rho, stage(i)](clk(i), W(i))(sent(clk, Schedule)(i)) 


  %used only for correspondence to protocol
  offset(clk, Schedule)(i): compute_stage[stage(i), real] 
    = offset[rho, stage(i)](clk(i), Schedule(i))

  synch_protocol(status, c_src, c_dst, Sched, src_set, tau, cf, pi, j, k): bool = 
      FORALL i: j <= i AND i < k IMPLIES
        nominal(c_src, Sched)(i+1) = 
          synch_stage[rho, min_latency(i), var_latency(i), java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
            (status      ?[rho,stagei+1)((+(i+))

  synch_protocol_sent: LEMMA
      feasible?(Schedule)AND
      same_clock?(c_src, c_dst, j, k) AND
      (status , c_dst,Schedule, , tau,cf,pi,,k)
    IMPLIES
      FORALL i: j <= i AND i < k IMPLIES
        sent(, )i1  
          synch_stage[rho, min_latency(i), var_latency(i), stage(i), stage(i+1)]
            (status(i), c_src(i), c_dst(i+1), Schedule(i), Lag(Schedule)(i), src_set(i), tau(i), cf(i), pi(i))

  protocol_synch(status, c_src, c_dst, Sched, src_set, tau, cf,
    protocoloffset(,D(Sched),reduce_choicetau ),
      nominal(c_src, Sched), 
      received(c_dst, c_src,
      check,,s, ), j,)

%  offset_transform(clk, Schedule, cf)(i): consensus_function
%    = LAMBDA (s:ne_seqs):offset[rho, stage(i)](clk(i), Schedule(i)) o cf(i)

%  protocol_synch2(status, c_src, c_dst, Sched, src_set, tau, cf, pi, j, k): bool = 
%    protocol(reduce_choice(tau, offset_transform(c_dst, Del(Sched), cf)), 
%      nominal(c_src, Sched), 
%      received(c_dst, c_src, Sched, status, pi),
%      check(c_dst, Sched, src_set, pi), j, k)

  % correspondence result
  k_stage_synch: LEMMA 
    protocol_synch(status, c_src,
      (status ,c_dst,Sched ,tau,cf,pij )


  % Synchronization protocol guarantees
  lower_validity: THEOREM    nominal(, chedulei =[,stagei)(clki,Wi)sent,Schedule)i 
      feasible(Schedule ND
      synch_protocol(status, c_src, c_dst, Schedule, src_set, tau, cf, pi  offsetclk )(): ompute_stagestage(,real 
      =offsetrho ()((i, Schedule()
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
I
      v_min(nominal(c_src,      FORALLi:  <=iAND i<kIMPLIES
k-1  -(/[rho)*DelaySchedule))
        <= v_min(nominal(c_src, Schedule), src_set)(j + k)

  upper_validity: THEOREM
      feasible?(Schedule) AND
      synch_protocol(statusi) () (i+) (),(Sched() src_seti,taui,cfi,pii)java.lang.StringIndexOutOfBoundsException: Index 106 out of bounds for length 106
quorum_synch?, c_src c_dst , ,tau pij j  )AND
      clock_relation?(Schedule, c_src      synch_protocolstatus, c_src, c_dst,Schedule src_set tau,,pi )
    IMPLIES
        v_max(nominal(c_src, Schedule), src_set)(j + k) 
          < (c_src Schedule src_set)j)
a(,j    ,e +r[]*DelaySchedule)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82

  agreement_propagation: LEMMA
      feasible?(Schedule) AND
      synch_protocol(status, c_src, c_dst,
      quorum_synch?(, c_src, c_dst Schedule src_set tau, pi j,j+k) AND
      clock_relation?(Schedule, c_src c_dst pi,j   )Ajava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      v_max((c_src Schedule) )(j 
        - v_min(sent(c_src,       check(c_dst, Sched, src_set) j )
      same_clock?(c_src, c_dst, j, j + k)
    IMPLIES
      v_max(sent(c_src, Schedule), src_set)(j + kjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        - v_min(sent(c_src, Schedule), src_set)(j + k) 
          <= delta + sigma(j, j + k - 1, %    protocol(reduce_choice(tau, offset_transform(c_dst,%      nominal(c_src, Sched), 

  X:

  convergent_stage?  _stage_synch: LEMMA 
    < kAND
      overlap_synch?[rho, min_latency(i), var_latency(      (status c_src _, Sched src_set,tau cf,pi,j,k
           % Synchronization protocol guarantees
      convergent((i), 
        max_length[rho      feasible() AND
         status() (i), c_dsti+1)Schedule,src_set),(,pi(i)) X)


  convergence: LEMMA
      feasible?(Schedule)AND
      ?(, , ,pi j   )
      quorum_synchv_minnominal(c_src,Schedule),src_set)j)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      clock_relation(,c_src c_dst i ,j  )AND
      convergent_stage?(status, c_src, c_dst, Schedule, src_set, tau, cf, X, pi, j, j + k) AND
      v_maxsentc_src Schedule, )()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        - v_min      synch_protocol(status , c_dst , , , , pi , j  )AND
      same_clock?quorum_synch?(,c_src, ,, pi   )AND
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      <= ((c_src Schedule,)() 
        -+sigmaj   k  ,epsilon_upper  []  (Schedulejava.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
<   (-)/X  (,j

  agreement_generation
      feasible?(Schedule)AND
      (,c_srcc_dst,src_set taucf ,j   k)AND
      exists_symmetric_synch_stage?(status, c_src, c_dst, Schedule,v_max(sentc_src Schedule src_set(j) 
      clock_relation?(Schedule, c_src, c_dst, pi, j, j + k) AND
      same_clock?(c_src, c_dst, j, j + k)
    IMPLIES
      v_max(sent(c_src, Schedule), src_set)(j + k)          v_minsentc_srcSchedule,src_setj < eltajava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
(+k)
          <= (sent,Schedule,src_setj + 

  agreement_generation_edge: THEOREM
      feasible?(Schedule)AND
  :VAR 

      ?Schedule c_srcc_dst ,j,  +k)AND
      same_clock?(c_src, c_dst, j, j + k)
    MPLIES
      v_max(sent(c_src, Schedule), src_set)(j + k) 
        -v_minsentc_src ) )( + )
max_length, min_latency(i,var_latencyi,stage, tagei+1)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

END reduce_synch