\section{Ranking phase}

We run the following algorithm:
\begin{enumerate}
\item Set $\allpatches = \{ \}$.
\item Repeatedly:
\begin{enumerate}
\item Clear out the graph $\hasdirdep$ so it has no edges.
\item Execute $\alg{Rank-Recurse}(\pc_0)$
\item Until $\allpatches$ remains unchanged.
\end{enumerate}
\end{enumerate}

$\alg{Rank-Recurse}(\pc)$ is:
\begin{enumerate}

\item If we have already done $\alg{Rank-Recurse}(\pc)$ in this
ranking iteration, do nothing.  Otherwise:

\item Add $\pc$ to $\allpatches$ if it is not there already.

\item Set
$$
  \set S \iassign h(\pcn)
     \cup 
        \bigcup_{\p \in \allpatches}
        \bigcup_{H \in h(\pn) \lor H \in h(\py)}
         \{ \baseof{E} \; | \; E \in \pendsof{H}{\pcy} \}
$$

and $W \iassign w(h(\pcn))$

\item While $\exists_{S \in \set S} S \ge W$,
update $W \assign S$ and $\set S \assign \set S \, \backslash \{ S \}$

(This will often remove $W$ from $\set S$.  Afterwards, $\set S$
is a collection of heads to be merged into $W$.)

\item Choose an ordering of $\set S$, $S_i$ for $i=1 \ldots n$.

\item For each $S_i$ in turn, choose a corresponding $M_i$
such that $$
   M_i \le S_i \land \left[
   M_i \le W \lor \bigexists_{j<i} M_i \le S_j
   \right]
$$

\item Set $\Gamma \iassign \depsreqof{W}$.

If there are multiple candidates we prefer $M_i \in \pcn$
if available.

\item For each $i \ldots 1..n$, update our putative direct
dependencies:
$$
\Gamma \assign \setmergeof{
    \Gamma
  }{
    \begin{cases}
     M_i \in \pcn :     & \depsreqof{M_i} \\
     M_i \not\in \pcn : & \{ \}
    \end{cases}
  }{
    \depsreqof{S_i}
  }
$$

TODO define $\setmerge$

\item Finalise our putative direct dependencies
$
\Gamma \assign g(\pc, \Gamma)
$

\item For each direct dependency $\pd \in \Gamma$,

\begin{enumerate}
\item Add an edge $\pc \hasdirdep \pd$ to the digraph (adding nodes
as necessary).
If this results in a cycle, abort entirely (as the function $g$ is
inappropriate; a different $g$ could work).
\item Run $\alg{Rank-Recurse}(\pd)$.
\end{enumerate}

\end{enumerate}

\subsection{Results of the ranking phase}

By the end of the ranking phase, we have recorded the following
information:

\begin{itemize}
\item
$ \allpatches, \hasdirdep $ and hence the completion of $\hasdirdep$
into the partial order $\hasdep$.

\item
For each $\pc \in \allpatches$,
the base branch starting point commit $W^{\pcn} = W$.

\item
For each $\pc$,
the direct dependencies $\Gamma^{\pc} = \Gamma$.

\item
For each $\pc$,
the ordered set of base branch sources $\set S^{\pcn} = \set S,
S^{\pcn}_i = S_i$
and corresponding merge bases $M^{\pcn}_i = M_i$.

\end{itemize}

\subsection{Proof of termination}

$\alg{Rank-Recurse}(\pc)$ recurses but only downwards through the
finite graph $\hasdirdep$, so it must terminate.  

The whole ranking algorithm iterates but each iteration involves
adding one or more patches to $\allpatches$.  Since there are
finitely many patches and we never remove anything from $\allpatches$
this must complete eventually.

$\qed$

