refactoring

Recherche/BFT-ARBover/main.tex

@@ -44,54 +44,59 @@
 \newtheorem{remark}{Remark}
 
 \newcommand{\RB}{\textsf{RB}\xspace}
-\newcommand{\res}{\mathsf{res}}
 \newcommand{\ARB}{\textsf{ARB}\xspace}
 \newcommand{\DL}{\textsf{DL}}
-\newcommand{\APPEND}{\textsf{APPEND}}
-\newcommand{\PROVE}{\textsf{PROVE}}
-\newcommand{\PROVEtrace}{\textsf{prove}}
-\newcommand{\READ}{\textsf{READ}}
+\newcommand{\append}{\ensuremath{\mathsf{append}}}
+\newcommand{\prove}{\ensuremath{\mathsf{prove}}}
+\newcommand{\PROVEtrace}{\ensuremath{\mathsf{prove}}}
+\newcommand{\readop}{\ensuremath{\mathsf{read}}}
 
-\newcommand{\BFTAPPEND}{\textsf{BFT\text{-}APPEND}}
-\newcommand{\BFTPROVE}{\textsf{BFT\text{-}PROVE}}
-\newcommand{\BFTREAD}{\textsf{BFT\text{-}READ}}
+% Backward compatibility aliases
+\newcommand{\APPEND}{\append}
+\newcommand{\PROVE}{\prove}
+\newcommand{\READ}{\readop}
 
+\newcommand{\BFTAPPEND}{\textsc{bft-append}}
+\newcommand{\BFTPROVE}{\textsc{bft-prove}}
+\newcommand{\BFTREAD}{\textsc{bft-read}}
 
-\newcommand{\ABbroadcast}{\textsf{ABroadcast}}
-\newcommand{\ABdeliver}{\textsf{ADeliver}}
-\newcommand{\RBcast}{\textsf{RBroadcast}}
-\newcommand{\RBreceived}{\textsf{RReceived}}
-\newcommand{\ordered}{\textsf{order}}
+\newcommand{\ABbroadcast}{\textsc{abroadcast}}
+\newcommand{\ABdeliver}{\textsc{adeliver}}
+\newcommand{\validated}{\ensuremath{\textsc{validated}}}
+\newcommand{\rbcast}{\ensuremath{\mathsf{rbcast}}}
+\newcommand{\rbreceived}{\ensuremath{\mathsf{rreceived}}}
+% \newcommand{\ordered}{\ensuremath{\mathsf{order}}}
+
+% Backward compatibility aliases
+\newcommand{\RBcast}{\rbcast}
+
+\newcommand{\rdeliver}{\ensuremath{\mathsf{rdeliver}}}
+\newcommand{\send}{\ensuremath{\mathsf{send}}}
+\newcommand{\receive}{\ensuremath{\mathsf{receive}}}
+
+% Local variables
+\newcommand{\unordered}{\ensuremath{\mathit{unordered}}}
+\newcommand{\ordered}{\ensuremath{\mathit{ordered}}}
+\newcommand{\delivered}{\ensuremath{\mathit{delivered}}}
+\newcommand{\prop}{\ensuremath{\mathit{prop}}}
+\newcommand{\winners}{\ensuremath{\mathit{winners}}}
+\newcommand{\done}{\ensuremath{\mathit{done}}}
+\newcommand{\res}{\ensuremath{\mathit{res}}}
+\newcommand{\flag}{\ensuremath{\mathit{flag}}}
+
+%% Used in BFT-DL implementation
+\newcommand{\state}{\ensuremath{\mathit{state}}}
+\newcommand{\results}{\ensuremath{\mathit{results}}}
+
+% Invariant/concept names (used in proofs)
 \newcommand{\Winners}{\mathsf{Winners}}
 \newcommand{\Messages}{\mathsf{Messages}}
-\newcommand{\ABlisten}{\textsf{AB-listen}}
-
-\newcommand{\CANDIDATE}{\textsf{VOTE}}
-\newcommand{\CLOSE}{\textsf{COMMIT}}
-\newcommand{\READGE}{\textsf{RESULT}}
-
-\newcommand{\SHARE}{\mathsf{SHARE}}
-\newcommand{\COMBINE}{\mathsf{COMBINE}}
-\newcommand{\VERIFY}{\mathsf{VERIFY}}
-
-\newcommand{\RETRIEVE}{\mathsf{RETRIEVE}}
-\newcommand{\SUBMIT}{\mathsf{SUBMIT}}
-
-\newcommand{\delivered}{\mathsf{delivered}}
-\newcommand{\received}{\mathsf{received}}
-\newcommand{\prop}{\mathsf{prop}}
-\newcommand{\resolved}{\mathsf{resolved}}
-\newcommand{\current}{\mathsf{current}}
+\newcommand{\received}{\ensuremath{\mathsf{received}}}
+\newcommand{\current}{\ensuremath{\mathsf{current}}}
 
 \newcommand{\Seq}{\mathsf{Seq}}
-\newcommand{\GE}{\mathsf{GE}}
 \newcommand{\BFTDL}{\textsf{BFT\text{-}DL}}
 
-\newcommand{\BFTGE}{\textsf{BFT\text{-}GE}}
-\newcommand{\BFTVOTE}{\textsf{BFT\text{-}VOTE}}
-\newcommand{\BFTCOMMIT}{\textsf{BFT\text{-}COMMIT}}
-\newcommand{\BFTRESULT}{\textsf{BFT\text{-}RESULT}}
-
 
 \crefname{theorem}{Theorem}{Theorems}
 \crefname{lemma}{Lemma}{Lemmas}
@@ -112,7 +117,7 @@ We consider a static set $\Pi$ of $n$ processes with known identities, communica
 
 \paragraph{Synchrony.} The network is asynchronous.
 
-\paragraph{Communication.} Processes can exchange through a Reliable Broadcast ($\RB$) primitive (defined below) which is invoked with the functions $\RBcast(m)$ and $m = \RBreceived()$. There exists a shared object called DenyList ($\DL$) (defined below) that is interfaced with a set $O$ of operations. There exist three types of these operations: $\APPEND(x)$, $\PROVE(x)$ and $\READ()$.   
+\paragraph{Communication.} Processes can exchange through a Reliable Broadcast ($\RB$) primitive (defined below) which is invoked with the functions $\RBcast(m)$ and $m = \rbreceived()$. There exists a shared object called DenyList ($\DL$) (defined below) that is interfaced with a set $O$ of operations. There exist three types of these operations: $\APPEND(x)$, $\PROVE(x)$ and $\READ()$.   
 
 \paragraph{Notation.} For any indice $x$ we defined by $\Pi_x$ a subset of $\Pi$. We consider two subsets $\Pi_M$ and $\Pi_V$ two authorization subsets. Indices $i \in \Pi$ refer to processes, and $p_i$ denotes the process with identifier $i$. Let $\mathcal{M}$ denote the universe of uniquely identifiable messages, with $m \in \mathcal{M}$. Let $\mathcal{R} \subseteq \mathbb{N}$ be the set of round identifiers; we write $r \in \mathcal{R}$ for a round. We use the precedence relation $\prec$ for the \DL{} linearization: $x \prec y$ means that operation $x$ appears strictly before $y$ in the linearized history of \DL. For any finite set $A \subseteq \mathcal{M}$, \ordered$(A)$ returns a deterministic total order over $A$ (e.g., lexicographic order on $(\textit{senderId},\textit{messageId})$ or on message hashes).
 For any operation $F \in O$,$F_i(...)$ denotes that the operation $F$ is invoked by process $p_i$.
@@ -225,11 +230,11 @@ Such that :
 \begin{algorithm}[H]
   \caption{$\READ'() \rightarrow \mathcal{L}(\mathbb{R} \times \PROVEtrace(\mathbb{R}))$}
     $j \gets$ the process invoking $\READ'()$\;
-    $res \gets \emptyset$\;
+    $\res \gets \emptyset$\;
     \ForAll{$i \in \{1, \dots, k\}$}{
-      $res \gets res \cup DL_i.\READ()$\;
+      $\res \gets \res \cup DL_i.\READ()$\;
     }
-    \Return{$res$}\;
+    \Return{$\res$}\;
  \end{algorithm}
 
   \begin{algorithm}[H]
@@ -243,11 +248,11 @@ Such that :
   \begin{algorithm}[H]
     \caption{$\PROVE'(\sigma) \rightarrow \{0, 1\}$}
       $j \gets$ the process invoking $\PROVE'(\sigma)$\;
-      $flag \gets false$\;
+      $\flag \gets false$\;
       \ForAll{$i \in \{1, \dots, k\}$}{
-        $flag \gets flag$ OR $DL_i.\PROVE(\sigma)$\;
+        $\flag \gets \flag$ OR $DL_i.\PROVE(\sigma)$\;
       }
-      \Return{$flag$}\;
+      \Return{$\flag$}\;
   \end{algorithm}
 
 \subsection{Threshold Cryptography}