Liquid quadratic voting

How Nicolas Works

Nicolas implements liquid quadratic voting for collective decisions with multiple alternatives, finite voice credits, and transparent quadratic cost accounting.

Vote Intensity

Participants can support or oppose every alternative with a finite real-valued vote intensity.

Quadratic Cost

A vote vector spends the sum of squared intensities, so stronger preferences become progressively more expensive.

Softmax Outcome

Nicolas aggregates support and maps it to winning probabilities with a numerically stable shifted softmax.

The Mechanism

For participant $i$ , vote vector $a_i$ , voice budget $B$ , and aggregate support $V$ .

Each participant's direct vote vector is bounded by their available voice credits:

a_i = (a_{i1}, \ldots, a_{im}), \qquad \sum_{j=1}^{m} a_{ij}^{2} \le B

Here $i$ indexes the participant, $j$ indexes an alternative, $m$ is the number of alternatives, $a_{ij}$ is participant $i$ 's signed vote intensity on alternative $j$ , and $B$ is the participant's available voice-credit budget.

The app displays gross cost as the quadratic spend:

g_i = \sum_{j=1}^{m} a_{ij}^{2}

Here $g_i$ is participant $i$ 's gross quadratic cost, computed by summing the squared signed intensities across all $m$ alternatives.

With liquid delegation, a voter may control their own credits plus delegated credits. Nicolas prices the controller's whole submitted vector once against the controlled credit bundle.

C_i = B_i + \sum_{s=1}^{q_i} b_s, \qquad g_i = \sum_{j=1}^{m} a_{ij}^{2} \le C_i

Here $C_i$ is controller $i$ 's total controlled credit budget, $B_i$ is their own direct budget, $s$ indexes delegated credit sources, $q_i$ is the number of delegated sources controlled by participant $i$ , and $b_s$ is the credit amount contributed by delegated source $s$ .

Nicolas aggregates signed vote intensity by alternative:

V_j = \sum_{i=1}^{n} a_{ij}

Here $V_j$ is the aggregate signed support for alternative $j$ , $n$ is the number of participants whose submitted vectors are included, and $a_{ij}$ is participant $i$ 's signed vote intensity on that alternative.

Outcome probabilities use the shifted softmax implemented in the results code:

Q_j = \frac{\exp(V_j - M)}{\sum_{k=1}^{m} \exp(V_k - M)}, \qquad M = \max_k V_k

Here $Q_j$ is the outcome probability assigned to alternative $j$ , $k$ indexes alternatives in the denominator, $V_k$ is the aggregate support for alternative $k$ , and $M$ is the largest aggregate support value across all alternatives.

What Delegation Changes

Delegation changes who controls credits for a decision.

If a member delegates credits and does not vote directly, the delegate can spend those credits as part of one controlled bundle. If the member votes directly, their active delegation is excluded for that decision.

If controller $i$ receives credit sources with amounts $b_1, \ldots, b_q$ , their controlled credit budget is:

C_i = \sum_{s=1}^{q} b_s

Here $C_i$ is controller $i$ 's controlled credit budget, $s$ indexes credit sources, $q$ is the number of credit sources, and $b_s$ is the amount from source $s$ .

Nicolas prices the controller's submitted vector once against that combined budget:

g_i = \sum_{j=1}^{m} a_{ij}^{2} \le C_i

Here $g_i$ is controller $i$ 's gross quadratic cost, $j$ indexes alternatives, $m$ is the number of alternatives, and $a_{ij}$ is the controller's signed vote intensity on alternative $j$ .

That means delegation is degressive. If $q$ members vote independently on the same alternative with equal budgets $B$ , their maximum combined intensity is:

q\sqrt{B}

Here $q$ is the number of independent members and $B$ is each member's equal voice-credit budget.

If those same credits are delegated into one bundle, the delegate's maximum intensity from the combined budget is only:

\sqrt{qB}

Here $qB$ is the total delegated budget controlled as one bundle.

Since $\sqrt{qB} \le q\sqrt{B}$ for $q \ge 1$ , independent aligned votes can produce more aggregate intensity than the same credits delegated to one controller. Equivalently, splitting a target intensity $x$ across $q$ independent voters is cheaper:

q\left(\frac{x}{q}\right)^2 = \frac{x^2}{q} \le x^2

Here $x$ is the target aggregate intensity, and each of the $q$ independent voters contributes $x/q$ intensity.

Unused delegated credits stay idle. Delegation can reduce total possible intensity because several independent voters can split the same target intensity more cheaply than one controller can spend it as a single bundle.

Open dashboard