Liquid Democracy

Every election forces a choice: vote yourself on everything, or hand power to a representative who decides for you. Liquid democracy refuses that forced choice.

In a liquid system each voter may vote directly on any issue, or delegate their vote to a trusted person — who can in turn delegate further. Delegations chain transitively: if Alice delegates to Bob and Bob to Carol, then Carol casts three votes on their behalf. At any moment a voter can reclaim their vote and decide directly. No one is locked in.

The result is a spectrum. Passive voters whose expertise is thin find a trusted voice; engaged voters stay in direct control. Weight concentrates naturally on the most informed participants rather than on whoever won an election years ago.

The idea circulates under several names — proxy voting, delegative democracy, fluid democracy — and has been formally studied since at least the 1960s. Modern implementations include the German Pirate Party's LiquidFeedback platform (deployed 2010) and Google's internal experiment Liquid Democracy (circa 2012).

The graph below has eight voters (A–H). Each voter either votes Yes or No directly, or delegates to a neighbor. Click a voter node to cycle through their states. Watch vote weight flow through delegation chains to the final tally.

<!-- {{c_html_intro}} -->
<p class="hint">{{hint_para}}</p>
<div id="graph-area">
  <svg id="graph-svg" viewBox="0 0 340 280" aria-label="{{svg_aria}}"></svg>
</div>
<div class="tally-row">
  <span class="tally-label">{{tally_yes_label}}</span>
  <span id="tally-yes" class="tally-val yes-val">0</span>
  <span class="tally-sep">|</span>
  <span class="tally-label">{{tally_no_label}}</span>
  <span id="tally-no" class="tally-val no-val">0</span>
  <span class="tally-sep">|</span>
  <span class="tally-label">{{tally_abstain_label}}</span>
  <span id="tally-abstain" class="tally-val abs-val">0</span>
</div>
<div id="status" class="status"></div>
<div class="btns">
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
</div>

/* {{c_css_intro}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
#graph-area { width: 100%; overflow: hidden; border: 1px solid #cdd9e3; border-radius: 10px; background: #f7f9fb; }
#graph-svg { width: 100%; height: auto; display: block; }
.node circle { stroke-width: 2; cursor: pointer; transition: r .1s; }
.node circle:hover { r: 17; }
.node text { font: 700 13px system-ui, sans-serif; pointer-events: none; }
.node .weight-badge { font: 600 10px system-ui, sans-serif; fill: #fff; }
.node .weight-bg { opacity: .85; }
.edge { fill: none; stroke: #8899aa; stroke-width: 1.8; }
.edge.delegate-arrow { stroke: #1d3557; stroke-width: 2.2; marker-end: url(#arrow); }
.edge.cycle-edge { stroke: #e63946; stroke-width: 2.2; stroke-dasharray: 5 3; marker-end: url(#arrow-red); }
.tally-row { display: flex; align-items: center; gap: .5rem; margin: .55rem 0 .3rem; flex-wrap: wrap; font-size: .95rem; }
.tally-label { color: #555; }
.tally-val { font-weight: 700; font-size: 1.1rem; min-width: 1.6ch; text-align: center; }
.yes-val { color: #0a7d33; }
.no-val { color: #c92f3c; }
.abs-val { color: #888; }
.tally-sep { color: #ccc; padding: 0 .1rem; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.3em; color: #c92f3c; margin-bottom: .4rem; }
.btns { display: flex; gap: .5rem; }
button { font: 600 14px system-ui, sans-serif; padding: .42rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

// Code not found

Notice how a single expert delegate can accumulate the weight of many passive voters. Delegating is free — but if a delegation cycle forms (A→B→A), no one in the cycle can vote: the weight simply vanishes. The demo detects and highlights such guru cycles.

Liquid democracy looks elegant on paper, but its delegation graph raises genuine computational challenges.

• Cycle detection is easy: a standard depth-first search finds cycles in $O(V + E)$ time. Any voter inside a cycle cannot cast their weight — that weight is simply lost.
• Computing vote totals given a cycle-free graph is also linear: follow each delegation chain to its terminal voter and accumulate weight. The tally is a sum over terminal voters only.
• Optimal delegation is harder. If voters can rank multiple possible delegates, choosing assignments that maximize the total weight that reaches an expert is an assignment problem — tractable in polynomial time for bipartite cases, but NP-hard when arbitrary constraints are added.
• Manipulation — choosing whom to delegate to so that a specific outcome wins — can be NP-hard even with simple preference models (Brill et al., 2018).
• Guru concentration is a structural fragility, not a computational problem but a social one: a popular delegate accumulating thousands of votes becomes a single point of failure. One hacked or coerced guru can swing the entire outcome.

The system therefore sits at an interesting boundary: routine operations (tally, cycle check) are fast, but questions about strategic behavior and optimal design can be as hard as any problem in combinatorial optimization.

The core pattern — delegate when you lack expertise, vote directly when you care — is surprisingly general:

• Political parties: the German Pirate Party used LiquidFeedback for internal policy votes (2010–2013), allowing members to delegate on technical topics and vote directly on social ones.
• Corporate governance: shareholder platforms experiment with transitive proxy chains for issues like environmental policy, where small shareholders delegate to specialist activist funds.
• Decentralized autonomous organizations (DAOs): many blockchain governance systems (Compound, Tally) implement liquid-style delegation for protocol upgrade votes.
• Academic peer review: proposals exist to let reviewers delegate papers outside their specialty to a trusted colleague, keeping the review pool expert rather than random.
• Theoretical voting science: liquid democracy is a live research area connecting graph coloring (can we partition voters so no cycle can form?), max-flow (how much weight reaches each candidate?), and social-choice axioms.

Wherever knowledge is unevenly spread but participation should be universal, some form of transitive delegation naturally emerges.

Liquid democracy is a simple idea with a rich graph-theoretic core. Each voter either contributes a direct vote or routes their weight through a chain of trusted delegates. Tallying is linear; detecting dead cycles is linear. Yet the moment you ask who should I delegate to? or can an adversary tip the outcome?, you are back in the territory of hard combinatorial problems.

The system also carries a social warning: concentrating weight on gurus is not just computationally fragile — it reintroduces the very power asymmetries that direct democracy was meant to dissolve. The math of max-flow tells you how much weight flows; it cannot tell you whether that flow is just.