Added some brainstorming thoughts.

notes/notes.tex

@@ -2,6 +2,8 @@
 \usepackage[margin=1in]{geometry}
 \usepackage{pervasives}
 
+\newcommand{\dual}[1]{#1^d}
+
 \begin{document}
 \begin{center}
   {\Large Quorum Systems}
@@ -11,17 +13,7 @@
 
 {\input{sections/quorum_systems.tex}}
 {\input{sections/read_write_quorum_systems.tex}}
-{\input{sections/recursive_quorum_systems.tex}}
-
-\TODO[michael]{Prove that for every read-write quorum system, there exists a coterie with at least as good load.}
-\TODO[michael]{Prove that if P dominates Q, then P has equal or lower load.}
-\TODO[michael]{The above shows that the optimal load quorum system is a non-dominated coterie. Maybe this is useful? We can generate every NDC?}
-\TODO[michael]{Understand how domination relates to subsumption.}
-\TODO[michael]{Understand dual-major, dual-minor, and self-dual.}
-\TODO[michael]{Extend these notions to read-write quorums.}
-\TODO[michael]{Enumerate all read-write quorums on four nodes and see the ones we can and can't subsume.}
-\TODO[michael]{Prove that if I have the read quorums R, then the write quorums are bar(R).}
-
+{\input{sections/brainstorm.tex}}
 
 \bibliographystyle{plain}
 \bibliography{references}

notes/sections/brainstorm.tex

@@ -0,0 +1,61 @@
+\begin{itemize}
+  \item
+    Recursive quorum systems are all non-dominated bicoteries. We can view the
+    tree as a way to generate an arbitrary set of read quorums. Then we just
+    bubble down dual to compute write quorums.
+
+  \item
+    The theory of coteries and decomposition has been very well studied. The
+    one thing that seems a little less studied is the relationship between load
+    and bicoteries. Can we find a nice way to find an optimal load bicoterie?
+    This is probably hard, but maybe something about bicoteries makes this
+    easier than for coteries.
+
+  \item
+    If we wanted to develop a library for bicoteries, we would like to (a)
+    allow people to form arbitrary bicoteries, (b) compute an optimal strategy
+    for a bicotier, (c) efficiently pick quorums based on the strategy, and (d)
+    efficiently determine if something is a superset of a quorum. We can do (a)
+    with a library of dual-able operators like or and and along with some
+    builtins for things like grids. (b) we can use LP with specializations. We
+    might have to do something smart to get ``good' strategies (e.g.,
+    balanced). For (d), we can just evaluate the tree or its dual or maybe use
+    something more efficient like BDDs? For (c) I'm not completely sure. For
+    some quorum systems, the number of quorums is exponential, so we wouldn't
+    want to represent them explicitly. Ideally we could also find an optimal
+    load bicoterie, but that's probably not going to happen. The library can
+    also help compute fault tolerance and maybe load under failure and whatnot.
+    How to compute fault tolerance with duplicates?
+
+  \item
+    Maybe we can run some practical experiments to show how important a good
+    bicoterie is. Maybe we'll find it's not that important.
+
+  \item
+    Is there anything smart about reconfiguring or changing coteries on the
+    fly? For example, grids are not good to go from 6 to 7 nodes. With
+    bicoteries, we probably want to adjust on the fly as the read and write
+    ratios change.
+
+  \item
+    Maybe we can introduce the idea that not all nodes have the same capacity.
+    Some have higher load than others. We could bake that into the nodes like,
+    a = Node("a", cap=1000).
+
+  \item
+    Maybe some nodes are also co-located, so the fault tolerance is a little
+    different. How can we compute fault tolerance with duplicates anyway?
+
+  \item
+    Just for fun, we could probably cross compile to javascript and show how to
+    subsume other quorum systems with our library. We should be able to subsume
+    all if we use duplicates.
+\end{itemize}
+
+\TODO[michael]{Prove that for every read-write quorum system, there exists a coterie with at least as good load.}
+\TODO[michael]{The above shows that the optimal load quorum system is a non-dominated coterie. Maybe this is useful? We can generate every NDC?}
+\TODO[michael]{Understand how domination relates to subsumption.}
+\TODO[michael]{Understand dual-major, dual-minor, and self-dual.}
+\TODO[michael]{Extend these notions to read-write quorums.}
+\TODO[michael]{Enumerate all read-write quorums on four nodes and see the ones we can and can't subsume.}
+\TODO[michael]{Prove that if I have the read quorums R, then the write quorums are bar(R).}

notes/sections/quorum_systems.tex

@@ -23,7 +23,6 @@ g(\vec{x})$. In other words, $f \leq g$ if $\setst{\vec{x}}{g(\vec{x})}
 \subseteq \setst{\vec{x}}{f(\vec{x})}$. Consider two quorum systems $Q_1$ and
 $Q_2$, $Q_1$ dominates $Q_2$ if and only if $f_{Q_2} < f_{Q_1}$.
 
-\newcommand{\dual}[1]{#1^d}
 Let the dual $\dual{f}$ of $f$ be $\dual{f}(x) = \bar{f}(\bar{x})$. $\dual{f}$
 is the function we get if we swap and with or. Note that $\dual{f}$ corresponds
 to the sets that intersect every set in $f$. We say a monotone function $f$
@@ -68,10 +67,11 @@ higher the throughput it can support.
   which is optimal.
 \end{example}
 
-\cite{naor1998load} prove that if a quorum system dominates another, it has
-lower or equal load. This shows that there always is a non-dominated coterie
-that has the lowest possible load. If we're trying to optimize for load, this
-tells us that we limit ourselves to non-dominated coteries.
+\cite{naor1998load} shows how to use a linear program to compute load.
+\cite{naor1998load} also proves that if a quorum system dominates another, it
+has lower or equal load. This shows that there always is a non-dominated
+coterie that has the lowest possible load. If we're trying to optimize for
+load, this tells us that we limit ourselves to non-dominated coteries.
 
 The \defword{resilience} or \defword{fault tolerance} of a quorum system $Q$ is
 the largest number $f$ such that for every subset $F \subseteq X$ with $|F| =

notes/sections/read_write_quorum_systems.tex

@@ -1,25 +1,17 @@
 \section{Read-Write Quorum Systems}
-\NOTE[mwhittaker]{%
-  These definitions are adapted from the quorum system definitions. We should
-  double check that they all make sense or find the definitions in some paper.
-}
-
 Given a set $X = \set{x_1, \ldots, x_n}$, a \defword{read-write quorum system}
 over $X$ is a pair of sets $Q = (R, W)$ of subsets of $X$ such that every $r
 \in R$ intersects every $w \in W$. The elements $r \in R$ are called
 \defword{read quorums}, and the elements $w \in W$ are called \defword{write
-quorums}.
-
-\TODO[mwhittaker]{%
-  How do we define coteries for read-write quorums? Obviously, we don't want
-  one read quorum being a strict subset of another read quorum, and we don't
-  want a write quorum being a strict subset of another write quorum, but can a
-  read quorum be a strict subset of a write quorum and vice-versa?
-}
-
-\TODO[mwhittaker]{%
-  Once we define coteries, we can define domination.
-}
+quorums}. Read-write quorum systems are also called bicoteries.
+%
+$(R, W)$ is a coterie if both $R$ and $W$ are minimal. $(R_1, W_1)$ dominates
+$(R_2, W_2)$ if $R_1$ dominates $R_2$ and $W_1$ dominates $W_2$. Again, we can
+view a read-write quorum system $(R, W)$ as a pair of monotone functions $f_R$
+and $f_W$. $(f_R, f_W)$ is a read-write quorum sytem if $f_R \leq \dual{f_W}$.
+It is a non-dominated coterie if $f_R = \dual{f_W}$. Thus, to generate a
+non-dominated bicoterie, let $f_R$ be an arbitrary set of quorums and let $f_W$
+be $\dual{f_R}$.
 
 Let $\sigma_R: R \to [0, 1]$ and $\sigma_W: W \to [0, 1]$ be a discrete
 probability distribution over the read and write quorums of $Q$. We call