Kronosapiens Labs

Implementing Active Ranking

Sun, 29 Mar 2026 00:00:00 +0000

A core task in social choice is the allocation of fixed resources among a set of items: funding across projects, budget across priorities, prize money across submissions. The output are weights – percentages out of 100 which say how valuable each item is relative to the others.

A common approach – asking people to score items on a scale, and then taking some sort of average – is fast but unreliable. Scores are subjective and uncalibrated: one person’s 7 is another person’s 4. Legitimacy suffers.

Pairwise comparison sidesteps this by asking a simpler question: “Which of these two do you prefer, and (optionally) by how much?” The cognitive load per judgment is lower, the signal is cleaner, and the results can be converted into weights that reflect genuine collective preference – from which rankings, allocations, and funding decisions all follow.

The problem is cost. Pairwise comparison scales quadratically: $k$ items means $k(k-1)/2$ possible pairs which need deciding. Active ranking – choosing which pairs to show based on what the system already knows, significantly reducing the number of pairs you most observe – is key to making pairwise methods practical.

This essay will explore how active ranking worked in practice – over three weeks in February and March 2026, during a live game jam – as part of PowerRanker, a spectral ranking engine that turns pairwise preferences into distributions of weights over items.

This essay was drafted by Claude using git commit logs and edited for style and flow.

I. Background

Since joining the Cartridge Gaming Company a little less than a year ago, one of my responsibilities has been running their quarterly hackathons. In preparation for their eighth jam, I saw an opportunity to put the ideas from The Pairwise Paradigm into practice – not just active ranking, but the full end-to-end pipeline: interface design, data encoding, and algorithmic pair selection. By bringing pairwise judging into the game jam process, we could distribute the judging burden across the ecosystem, producing more legitimate results with less per-juror effort.

The result was a homespun judging tool called Daimyo. Judges would see two submissions side by side – each with an AI-generated summary, playable links, and structured metrics – and were asked a single question: “Which is the stronger game jam entry?”

Responses used a five-point Likert scale (Much / Slightly / Even / Slightly / Much), which we encoded as values from 0 to 1 in increments of 0.25. Each judgment was designed to take about 30 seconds, and judges were asked for 10 comparisons per session, keeping the total time commitment at about five minutes. PowerRanker then aggregated these comparisons into a collective weighting, used to decide winners and give out prizes.

The initiative was successful – judges enjoyed encountering the projects in this way, the process made the game jam more visible to the larger ecosystem, and we were able to produce good results with a relatively small voter lift.

Of the ideas from The Pairwise Paradigm, active ranking was the one that advanced the most during this process. The original proposal was simple: for every pair $(a, b)$, construct a Beta distribution from the vote counts and sample pairs proportional to $\text{Var}(p_{ab})$. An optional extension would weight by $\text{Var}(p_{ab}) \cdot w_a \cdot w_b$, upsampling uncertain pairs between high-value items. In theory, this would reduce the data requirement from $O(k^2)$ to some multiple of $k$, a fundamental change in complexity.

This was the plan. It did not work as intended.

II. Variance-Based Selection

The initial implementation followed the original proposal: Beta-variance-weighted sampling without replacement, with an optional impact flag that multiplied variance by the product of both items’ current weights.

Watching it run against real data, however, two problems became clear.

Variance sampling did explore the pair space – unobserved pairs have a higher variance under a Beta prior, so the system naturally surfaced unseen comparisons. But it explored indiscriminately, without regard to relative ordering. The system would spend votes resolving the bear-vs-rabbit comparison with the same urgency as bear-vs-lion, even though these comparisons are not equally important for discovering the final ordering. Variance told us what we hadn’t seen, but not what we needed to see.

The weight-scaling extension – multiplying variance by $w_a \cdot w_b$ – introduced a different problem: path dependence. With sparse early data, the ranking engine produces extreme weights – an item that wins its first two comparisons can briefly appear to dominate the entire set. Sampling based on these volatile early weights meant that early winners were shown more often, producing more data about them and reinforcing their high weights – a classic “rich get richer” problem.

Clearly, variance wasn’t it.

III. Composable Transforms

Before abandoning variance, we tried to save it. The first iteration added a coverage term alongside variance. Coverage tracked how many times each item had been observed in any comparison, and penalized well-observed items: $\frac{1}{1 + n/N}$ initially, then $\frac{1}{\sqrt{1 + n}}$ for faster drop-off.

The idea was to balance exploitation (compare uncertain pairs) with exploration (compare unseen items). We also modified the weight term, compressing it via sqrt to keep it in range with the other factors ($\sqrt(w_a \cdot w_b)$). The goal was to observe all items a few times, and then concentrate observations on similarly-ranked items, as well as the top-weighted items, directing attention to where it had the highest impact.

The selection function was multiplicitive, with each term contributing proportionally and toggled individually: sampleWeight = variance * weight * coverage.

This was better. Items that had been ignored were surfaced, and attention was distributed more evenly and efficiently across the set. But the weight component still created path dependence, and the interaction between three multiplicative terms (variance, coverage, weight) was hard to reason about.

We were making progress, but the deeper problem remained: variance is fundamentally order-agnostic. The early intuition – that variance-based sampling could reduce the data requirement by an entire complexity class – was wrong.

IV. The Pivot

We eventually abandoned variance and weight-based selection entirely. In order to reduce ranking to $O(n)$ comparisons, the selection signal needed to be grounded in concrete ordinal positions instead of global statistical notions of confidence. The earlier intuition – selecting pairs based on some notion of uncertainty-reduction – was right, but the approach had been wrong.

The replacement was activeSelect(), built on three multiplicative terms, which as before could be toggled on and off individually. pos is determined from current data – weights are produced internally and used to create an ordering, from which further statistics were derived:

Coverage: $\frac{1}{\sqrt{1 + n_a}} \cdot \frac{1}{\sqrt{1 + n_b}}$ – favors items with fewer observations
Proximity: $\frac{1}{1 + \lvert pos_a - pos_b \rvert}$ – favors items close together in the current ranking
Position: $\frac{1}{\sqrt{pos_a \cdot pos_b}}$ – favors items near the top

Coverage was kept from the earlier iteration. Proximity and position were new – ordinal variants of the earlier variance and weight terms.

The proximity term became the main engine of active selection. Consider: a weighting of $n$ items has $n-1$ degrees of freedom – the ratios between consecutive items. The goal of the pairwise process, then, should be to achieve high confidence on the relationship between each item and its neighbors.

“Neighbor” should be understood probabilistically – two or three comparisons with items one or two positions away, one or two comparisons with items three or four positions away, etc.

Early on, the graph is sparse and the ranking is fuzzy, so coverage dominates: every item needs a few comparisons to anchor its position. As data accumulates, proximity dominates, concentrating attention on the boundaries where precision is useful. Position adds an optional bias toward observing pairs towards the top of the ranking, where larger weights call for higher precision.

This new approach was coherent and intuitive in a way that the previous one was not.

V. Tuning

The new design required its own round of tuning, but the iterations were faster and more principled because the terms were independently interpretable. Claude could perform fast simulations, letting us explore the behavior of different parameterizations interactively.

Range matching. A subtlety of multiplicative composition is that all terms need to operate on similar scales. If one term ranges from 0.00001 to 0.99999 while the others range from 0.2 to 0.6, the wide-range term dominates the outcome. Getting the terms into comparable ranges was a recurring concern throughout tuning, leading to several backs-and-forth around squaring and rooting.

Regularization. The first version had no way to soften the weighting. In production, under-observed entries were getting starved while already-ranked items dominated. We added a regularization parameter r (0 = uniform, 1 = full weighting), which let us mitigate path-dependent effects.

The initial implementation was a linear blend: $r \cdot w + (1 - r)$. This didn’t work: the blend collapsed signal, producing useless values like 0.500001. We replaced the linear blend with a power transform: $w^r$, spanning the same range while preserving signal.

Coverage formula. The coverage term oscillated between $\frac{1}{1+n}$ and $\frac{1}{\sqrt{1+n}}$ as we ran simulations and explored alternative paramaterizations. The sqrt form was chosen for its gentler drop-off, allowing items with 3-4 observations to continue to appear while still favoring items with zero observations.

Term composition. Initially, we chose pairs using all three terms, but decided mid-judging to drop the position term and use coverage and proximity only with r=0.9. This made helped distribute voter attention across the entire set of items, increasing legitimacy.

This decision reveals an important subtlety in social choice: perceived legitimacy of a process just is as important as how close the final weights may come to an abstract ideal.

VI. Validation

After the design stabilized, we ran simulations to validate the approach. We generated items with known power-law weights, simulated judges making noisy Bradley-Terry comparisons, and measured how well the ranking engine recovered the true ordering.

The simulation also clarified a foundational question about the ranking engine itself: whether preferences should be encoded as unidirectional (0.75 to A) or bidirectional (0.75 to A, 0.25 to B). With Likert-binned vote strengths, unidirectional preferences produce unbounded weight ratios – the top item’s weight grows limitlessly relative to the bottom, as preference “mass” accumulated unevenly.

Bidirectional preferences, by contrast, cause weights to converge, as every comparison contributes balanced information. This insight was helpful for understanding “convergence” in this context – and is a jumping off point for future research.

Our independent variable was votes per item (vpi): the total number of votes divided by the total number of items. Simulation results showed that with active selection, Spearman rank correlation reaches 0.95+ at around 10-12 vpi for most distributions.

The simulation helped balance the relative weighting of the three terms, confirming that the range-matching intuition from manual tuning was correct. It also gave us confidence in the votes-per-item target, by showing that an accurate ordering can be reliably recovered within our vote budget, and let us publicize the results with confidence.

For a set of 30 items, 10 vpi means 300 total votes, or 15 judges each making 20 comparisons. At 30 seconds per comparison, that’s 10 minutes per judge. This is identical to The Pairwise Paradigm’s $10k$ estimate, although achieved through a different mechanism than originally proposed.

In the case of the game jam, we received 360 votes from 16 judges. This was enough to produce rankings that were seen as legitimate and reflective of actual submission quality.

VII. Reflections

Theory vs practice.

The variance-based approach made sense on paper. It was information-theoretically motivated, computationally efficient, and had a clear connection to the existing literature. But it failed in practice because it treated pairs as isolated statistical objects rather than as part of a unified ranking structure. The position-aware model succeeded because it grounded the selection process in the ranking it was trying to refine.

Composability matters.

The ability to drop or add terms based on context proved valuable in both development and production. A single monolithic scoring function would have been harder to adapt.

The weights weren’t ready for prime time.

We had initially hoped to distribute prize money directly using the output weights – the highest-leverage use of the PowerRanker technique. In the end, however, we didn’t feel confident enough in the weight precision to tie dollars to them, especially as the selection process itself evolved over the course of vote-gathering. The ranking was reliable, but the weights need more work before they could be financially load-bearing.

Open questions remain.

The first iteration of Daimyo validated many of the ideas put forward in The Pairwise Paradigm, specifically around the design of the UI and the ability of active ranking to reduce the voting requirement. Future research should push the simulations further, showing specifically under what circumstances different paramaterizations can achieve desired outcomes.

This research, like the earlier work on pseudocounts, was conducted in collaboration with Claude – both the R&D itself and the writing of this essay. The pattern was similar: rapid iteration through a search space, punctuated by moments where stepping back and questioning assumptions.

Reinventing the Wheel

Sat, 07 Feb 2026 00:00:00 +0000

This essay describes a research process culminating in a significant overhaul of Chore Wheel’s internals. The research itself – analysis, dead ends, and eventual solution – was a collaboration between myself and Anthropic’s Claude taking place over the course of about four nighttime sessions. Afterwards, we wrote up this report based on our notes – Claude drafted, I edited.

From my ChatGPT year-in-review, seemed fitting.

I. Introduction
II. Background
III. Explorations
IV. Breakthrough
V. Reflections

I. Introduction

Chore Wheel is a cooperative household management system, deployed as a suite of Slack apps since September 2022. Its origins trace back to my research on pairwise preference voting, begun as a master’s student at Columbia in 2016, further developed at Colony in 2018, and culminating in Chore Wheel in 2020.

The core concept is straightforward: residents express priorities as pairwise comparisons (“dishes are more important than sweeping”), and a PageRank-style algorithm aggregates these into a collective prioritization that determines how many points each chore accumulates. Points are fixed at 100 per resident per month and distributed continuously over time. A chore prioritized twice as highly accumulates twice as many points, so the collective preferences directly shape how chores are incentivized and performed. The emphasis on emergent, intuitive, and asynchronous decision-making – in lieu of long meetings or top-down manager control – was meant to ensure communal resilience in the face of turnover and fluctuating resident capacity.

After 3+ years of continuous production use at the 9-person Sage House – with over 2,500 claimed chores across 24 lifetime residents – the system had proven the concept. The prioritization mechanism, the system’s most innovative component, worked. But consistent patterns of user frustration pointed to problems beneath the surface. This essay traces the research process that led to a key redesign of the ranking engine – not as a straight line, but as the winding path it actually was.

II. Background

The Problem

Chore Wheel’s goal is to make cooperative governance simple, intuitive, and effective. The core promise is that proportional changes in preferences will produce proportional changes in rankings. Two persistent complaints suggested the goal was not yet fully achieved.

The first was compressed distributions. Residents struggled to get the most important chores to high enough values. No one ever complained that the top chores were worth “too much” – but people regularly felt unable to push them high enough, no matter how many preferences they submitted. Deep-cleaning a bathroom and watering the plants would sit closer together in the rankings than anyone felt they should, and no amount of voting seemed to fix it. The result was that the most important chores still felt undervalued, and that people who did them still felt as though they were “sacrificing” on behalf of the group – exactly what we wanted to avoid.

The second was opaque causality. Priority changes sometimes felt “random.” A resident would submit a clear preference – “kitchen deep clean matters more than yard cleanup and trash takeout” – and see unrelated chores shift in unexpected directions. The effect wasn’t enormous, but it was noticeable. When inputs don’t produce legible outputs, governance stops feeling democratic and starts feeling arbitrary – and residents disengage. For a system built on the premise that people should feel agency over their shared environment, this was not a minor complaint.

The Ranking Engine

To understand the source of these problems – and why they resisted easy fixes – requires some background on how the ranking engine works and the design decisions it inherited.

PowerRanker (our internal name for the ranking engine) takes in pairwise preferences from residents (“I prefer dishes to sweeping with a strength of 0.7”), aggregates them into a “matrix” of relationships, and turns this matrix into a set of weights (“priorities”) which we use to assign points to chores. The underlying math is well-established and is often used to calculate rankings based on tournaments and competitions; our innovation was applying it to problems of social choice.

One of the challenges of the social choice setting is achieving the twin – and contradictory – goals of enabling groups to reach good outcomes in the face of low engagement, while also preventing minority factions from unfairly dominating the results. Achieving these goals requires balancing trade-offs – encouraging coalition-building for extreme outcomes, while allowing individuals to make meaningful contributions.

This balancing, which can be seen as a type of “regularization,” was previously done in two ways. First, through an “implicit preference” of 0.5 in every off-diagonal cell of the preference matrix, which was removed proportionally (0.5/numResidents) as real preferences came in. Second, through a “damping factor” – taken directly from PageRank – in which the observed preferences are scaled down and combined with a uniform prior (PageRank’s “random surfer”), which compresses results and ensures that even low-priority chores receive at least some value.

Note: The original PageRank paper counterintuitively dampens less when $d$ is large. In this discussion, we will refer to “high damping” as creating more uniform outcomes, and “low damping” enabling more extreme outcomes.

Prior Investigations

This project occurred in the context of a larger sweep of improvements brought about by the addition of a new house (see here, here, and here). This 5-person house, Solegria, had a different set of needs than Sage, and attempting to accommodate them within the existing framework spurred a series of investigations which led to significant improvements in the system.

Before this project, we undertook an investigation into some confusing behavior which surfaced in the course of implementing a “bulk import” feature in which CSVs of chores with “scores” could be uploaded en-masse instead of created and prioritized individually. During the development of this functionality, we noticed that equal scores led to skewed outputs, which turned out to be an unintended consequence of an earlier investigation into why de-prioritizing a chore could in some cases increase its priority.

Initially, preferences had been encoded bidirectionally – in which a preference of 0.7 in one direction was encoded as two preferences, with 0.3 flowing in the other direction so that each preference added a full 1.0 to the matrix. This approach was appealing, as it kept things continuous, symmetric, and proportional, but it had a problem – due to the underlying mathematics, adding a 0.3 (or similar) flow to the less-preferred chore would sometimes cause it to increase in value – a clear semantics violation.

Our initial solution – to remove the counter-weight – created an abrupt discontinuity at 0.5 and led to more volatile rankings. Once we identified the problem, the solution was clear – center and scale preferences smoothly around 0.5, so a preference of 0.7 would be encoded as 0.4, etc.

We were making progress, but things had begun to feel like a game of whack-a-mole – every solution seemed to introduce another problem. The preferences themselves were not changing, nor was the final step of producing weights, but the intermediate pipeline of scaling and adding and removing preferences was creating complex interactions that were difficult to reason about.

Fortunately, we had an instinct for where to look next. Software engineers have a concept of “code smell” – patterns that, based purely on appearance, suggest poor design. It was certainly smelly that a general-purpose ranking engine depended so directly on a domain-specific value like the number of residents, and that “implicit preferences” were explicitly subtracted as real data came in. What if we removed or reworked that functionality?

Exploring alternative approaches to damping and regularization set us down a road which led to a significant breakthrough.

III. Explorations

Dynamic Damping

The first attempt simplified the pipeline by removing implicit preferences, reinstituting bidirectional preferences, and replacing a fixed damping factor with a dynamic one that increases as a function of the number of explicit preferences – data the ranking engine already had.

By making the damping factor dynamic instead of fixed, it could ideally replace the regularizing function of implicit preferences, ensuring that a small number of preferences could not dominate the results while creating a cleaner architecture. Further, our hope was that a dynamic damping factor could mitigate the unexpected effects of bidirectional preferences, giving us the upside of per-pair stability without the downside of unpredictable interactions with the rest of the graph.

The initial damping formula was a hyperbolic curve, where $P$ is the number of preferences submitted and $\text{maxPairs}$ is the total number of possible chore pairs:

\[d = \frac{P}{P + \alpha \cdot \text{maxPairs}}\]

This curve begins at 0 and approaches 1 as the number of preferences grows, with $\alpha$ controlling the steepness of the curve. With few preferences, damping stays high and rankings hew close to uniform. As preferences accumulate, damping decreases and the rankings increasingly reflect people’s stated preferences.

We tested this against anonymized Sage House preferences and found that with the right $\alpha$ we could reproduce the existing priorities almost exactly.

Key learning: a data-driven damping curve can replace both fixed damping and implicit preferences – but matching one dataset doesn’t guarantee generality.

This was promising. It removed implicit preferences, replaced the fixed damping factor with something principled, and produced nearly identical rankings on real data. The next step was to validate on a second dataset.

Cross-Dataset Validation

The second dataset, from the 5-person Solegria, told a different story. Where Sage residents had submitted preferences organically – mostly maximal values of 1 or 0, spread across several active participants – Solegria had a different participation structure. One person had submitted the vast majority of all preferences through the bulk-upload feature, and those preferences were much more moderate, having been derived from ratios of intended point values.

The $\alpha$ that had worked well for Sage produced compressed values for Solegria.

We briefly explored an “adaptive” alpha based on a measure of preference intensity – higher if preferences are more extreme, lower if they are more uniform:

\[\alpha = \frac{\text{mean}(|2(p - 0.5)|)}{2}\]

However, regularizing based on explicit preferences would have introduced a new reflexivity: if strong preferences regularize themselves, preference-setting becomes less about expressing true beliefs and more an exercise in anticipating how the algorithm will react. This was a complexity we were unwilling to introduce.

More wrinkles emerged when we tested round-trip fidelity: since Solegria’s preferences were generated from known target scores, we could check whether the ranking algorithm recovered the intended distribution. It didn’t. The best-fit Sage value significantly compressed Solegria’s rankings relative to intended values.

Our takeaway was that for hyperbolic damping, the model’s core parameter was sensitive not just to the amount of data, but to its distribution. There was not a universal constant we could apply without significantly distorting either group’s current, in-production priorities – something we were not willing to do as part of an internal research project. Our goal was to make fundamental improvements either transparently or not at all.

Key learning: a model whose core parameter is sensitive to how preferences are generated – not just how many exist – cannot be trusted across heterogeneous groups.

It is worth noting that these data are slightly reflexive – Sage residents produced extreme values in part because the overly-strong compression was not responsive enough to moderate values.

Handling Coalitions

Before abandoning the hyperbolic approach entirely, a different concern surfaced. The damping formula counted total preferences without regard to who submitted them. One active resident submitting hundreds of preferences could achieve the same damping as several people submitting handfuls of preferences each. This defeated the coalition-building property that $\text{numResidents}$ had – however crudely – provided originally.

A possible solution was inspired by Quadratic Voting: compute an effective participation score as the sum of square roots of each resident’s preference count:

\[\text{effectiveP} = \sum_i \sqrt{\text{prefs}_i}\]

This creates diminishing returns per person – one person submitting 100 preferences contributes $\sqrt{100} = 10$, while four people submitting 25 each contribute $4\sqrt{25} = 20$. More participants means higher effective participation, mathematically enforcing the normative value of coalition-building.

The implementation could be kept architecturally clean – the application would compute $\text{effectiveP}$ from its knowledge of who submitted what, derive the damping factor, and pass it in. PowerRanker would become a generic library that accepts damping as a parameter, knowing nothing about residents or participation – separation of concerns between the ranking engine and the application.

But this approach would penalize Solegria’s legitimate use case – a single person doing a bulk import on behalf of the group – and more generally, any house where one or two engaged members did most of the administrative work. The instinct about coalition-building was right; the implementation was simply too aggressive – and too normative – for the messy reality of shared living, where participation is never evenly distributed.

Key learning: penalizing concentrated participation sounds principled, but punishes legitimate cases where engagement is naturally uneven.

Returning to Unidirectional Preferences

Alongside these damping experiments, the semantic violation that had originally motivated the move away from bidirectional preferences (see Prior Investigations) resurfaced. We had reinstituted bidirectional encoding in the hope that dynamic damping would contain the problem, but it didn’t – deprioritizing a chore still added weight to it, inflating its ranking relative to chores with no preferences at all.

Bidirectional encoding turned out to be a non-starter, and our only option was a return to scaled unidirectional preferences, where only the preferred chore gains value. However, since unidirectional preferences add less total weight to the matrix, the results become more volatile – and the choice of damping curve matters even more.

Key learning: bidirectional encoding’s semantic violation – deprioritizing a chore inflates it – persisted regardless of damping strategy, confirming it as a dead end.

The Search for a Universal Curve

We have so far failed to find a general solution, and the return to unidirectional preferences meant that prior parameter fits needed to be revisited. Stepping back, we asked a different question: is there another curve that works consistently across different houses and coverage levels?

We liked the idea of using $P/maxPairs$ as the input for the damping curve. This value, the ratio of the number of observed preferences across all residents to the number of possible preferences per resident, could range from 0 up to the number of residents. What curve would cleanly map this number to the range (0, 1)? The answer was the sigmoid:

\[d = \frac{1}{1 + e^{-a \cdot P / \text{maxPairs}}}\]

Both formulas normalize by problem size, but they differ in shape. The hyperbolic curve produces $d=0$ with no data, meaning new houses get near-total damping, while the sigmoid starts at $d=0.5$ – an intuitive “50/50 blend with uniform” – giving early residents more agency. Further, the sigmoid’s steeper curve meant a single parameter could work across both datasets.

We swept the steepness parameter $\alpha$ across both datasets, looking for a value that best matched current production. The result was encouraging: we found a single $\alpha$ that worked well for both houses. Rankings shifted modestly, with a slightly larger spread at Sage than at Solegria. This seemed like the answer.

But looking back at the full trajectory of the research, something nagged. Four different damping formulas had now been explored – hyperbolic, QV-weighted hyperbolic, sigmoid, and adaptive variants of each – always asking “what’s the right damping curve?” without questioning whether functional damping was the right tool at all. The concept had been inherited from PageRank and never seriously challenged.

Every iteration refined the curve; none questioned the frame.

Key learning: finding the “right” damping curve was the wrong question – four iterations of refinement revealed that the entire frame of functional damping needed to be reconsidered.

IV. Breakthrough

Damp-Before-Normalize

Standard PageRank normalizes each row of the transition matrix (so rows sum to 1), then applies damping (blending with the uniform distribution). But normalization erases the magnitude of the raw preference data: an item with 10 strong preferences and an item with 1 weak preference look identical after normalization. In PageRank this doesn’t matter – the link matrix is binary, so pre-normalization row sums just count outgoing links, which carry no information about page authority. In a continuous preference matrix, the pre-normalization row sums encode something meaningful: how much total evidence the system has about each item.

By adopting PageRank’s approach uncritically, we were inadvertently throwing away information – information which doesn’t exist for links but does exist for preferences.

With implicit preferences, this effect was obfuscated, as normalization was constrained by these extra values. Without implicit preferences – and with the sparser matrices that unidirectional encoding produced – the problem with normalize-before-damp became plain as day:

Fancy models and AI agents are no match for a good notebook at your side.

This was the conceptual breakthrough of the research – the first moment where the PageRank architecture itself, not just its parameters, was questioned. By reversing the order – damping first, then normalizing – we can regularize outputs without washing out valuable preference information. The principle is simple: regularize before you normalize, so that cells with more real data are proportionally less affected by the prior.

Key mathematical properties were preserved: the final matrix remains row-stochastic, irreducible, and aperiodic, guaranteeing a unique stationary distribution via Perron-Frobenius. Only the clean markov-plus-uniform decomposition of the classic Google matrix was lost – but that decomposition, and its “random surfer” interpretation, was arguably never the right model for social choice anyway.

The damp-before-normalize approach addressed the magnitude-erasure problem that unidirectional preferences had made acute, but it still relied on a functional damping curve, which meant it inherited the parameterization problems from the earlier sections. What we needed was a way to regularize before normalization without relying on a curve at all.

Bayesian Pseudocounts

The damp-before-normalize insight meant that all regularization now logically occurred in the same place: in the matrix, before normalization. The original pipeline had split regularization across two mechanisms – implicit preferences (added and subtracted to the matrix before normalization) and damping (applied after normalization). With damping moved before normalization, regularization could be performed in a single, theoretically clean step.

The implementation of this insight turned out to be almost embarrassingly simple: add a small constant to every off-diagonal cell in the matrix before loading the data:

\[k = c \times \text{numResidents}\]

Each chore pair starts with $k$ units of “virtual preference” in both directions, representing a uniform prior belief before any data arrives, scaled by the number of residents. As real preferences accumulate, they dominate the pseudocounts naturally – no deleting implicit preferences, no coverage-dependent formula, no coalition checks, no steepness parameter.

There is an irony here. Pseudocounts do what implicit preferences were trying to do all along: provide a uniform baseline that washes out as real data arrives. But where implicit preferences were a hack – entangled with damping, lacking a clean mathematical interpretation, creating indirect effects through bidirectional subtraction – pseudocounts have a principled statistical identity as a Dirichlet prior. The original system had the right instinct; it just expressed it through the wrong formalism.

The pseudocount approach has key properties that none of the damping-based models achieved. First, it scales naturally with house size: more residents means a stronger prior, which means more preference data is needed to move rankings – preserving the coalition-building boost for larger houses without handicapping smaller houses. Second, it requires a single parameter $c$ with clear semantics, representing the strength of the uniform prior per resident, which can be set either analytically or through governance.

We tested pseudocounts against both datasets, and the results were encouraging. At Sage (9 residents), individual chore values shifted by an average of 0.08% – nearly invisible. At Solegria (5 residents), values shifted an average of 0.55%, with the spread between highest- and lowest-priority chores nearly doubling. The difference is explained by the new prior – with only 5 residents, Solegria’s prior was about half that of Sage’s, meaning that Solegria’s preferences could be expressed more fully. This change – increased spread across the board, with Sage seeing virtually no change and Solegria seeing meaningful change – was exactly what we wanted.

Most strikingly, the implementation was a net deletion of code. The old matrix initialization populated every off-diagonal cell with implicit preferences scaled by the number of participants. The new version initializes with pseudocounts – a uniform prior that knows nothing about participants:

// Before: implicit preferences
_prepareMatrix () {
  let matrix = linAlg.Matrix.zero(n, n);
  if (this.options.numParticipants) {
    matrix = matrix
      .plusEach(1).minus(linAlg.Matrix.identity(n))
      .mulEach(numParticipants).mulEach(implicitPref);
  }
  return matrix;
}

// After: pseudocounts
_prepareMatrix () {
  let matrix = linAlg.Matrix.zero(n, n);
  if (this.options.k) {
    matrix = matrix
      .plusEach(1).minus(linAlg.Matrix.identity(n))
      .mulEach(this.options.k);
  }
  return matrix;
}

Adding preferences went from a multi-step dance – subtract implicit preferences, then add the scaled explicit preference in the dominant direction – to simple addition:

// Before: subtract implicit, then add explicit
preferences.forEach((p) => {
  const scaled = (p.value - 0.5) * 2;
  if (scaled !== 0) {
    matrix.data[sourceIx][targetIx] -= implicitPref;
    matrix.data[targetIx][sourceIx] -= implicitPref;
    if (scaled > 0) {
      matrix.data[sourceIx][targetIx] += scaled;
    } else {
      matrix.data[targetIx][sourceIx] += -scaled;
    }
  }
});

// After: just add
preferences.forEach((p) => {
  const scaled = (p.value - 0.5) * 2;
  if (scaled > 0) {
    matrix.data[sourceIx][targetIx] += scaled;
  } else {
    matrix.data[targetIx][sourceIx] += -scaled;
  }
});

And the power method dropped its damping step entirely – regularization now lives in the data, before normalization, not after:

// Before: normalize, then damp
_powerMethod (matrix, d, epsilon, nIter) {
  matrix.data = matrix.data.map((row) => {
    const rowSum = this.#sum(row);
    return row.map(x => x / rowSum);
  });
  matrix.mulEach_(d);
  matrix.plusEach_((1 - d) / n);
  // ... power iteration
}

// After: just normalize
_powerMethod (matrix, epsilon, nIter) {
  matrix.data = matrix.data.map((row) => {
    const rowSum = this.#sum(row);
    return row.map(x => x / rowSum);
  });
  // ... power iteration
}

V. Reflections

The research began with user complaints – compressed distributions and opaque causality – and every candidate model was evaluated against those experiences. “Spread” was never an abstract metric; it was a proxy for whether residents felt their preferences actually mattered. The final model increased spread where it was over-compressed while preserving rank-order stability where preferences had matured – delivering the experience the system always promised: submit a preference, see a legible change, trust the output.

The winding path was necessary.

Each intermediate model revealed a dimension of the problem that had been previously overlooked. The hyperbolic approach revealed that the damping parameter wasn’t universal; cross-dataset validation revealed sensitivity to preference generation method; the QV model revealed the tension between coalition-building norms and real-world participation patterns. The attempt to revive bidirectional encoding confirmed its fundamental limits, and the sigmoid revealed that even the best curve couldn’t work across all regimes. The damp-before-normalize investigation revealed that regularization must happen before normalization – the key conceptual insight – and the reconfigured pipeline allowed us to see how implicit preferences and damping could be combined into a single, clean concept. Each failure narrowed the space of possible solutions, until what remained was obvious.

Every idea was tested against real data.

The research used two production datasets with different participation structures and preference distributions. Theoretical elegance was never sufficient; the datasets always had the final word. This also reveals the importance of persistence – it took several years to get enough data for this research.

Separation of concerns clarified everything.

The original PowerRanker knew about $\text{numResidents}$ and $\text{implicitPref}$ – application-layer concepts that don’t belong in a generic ranking library. In the final design, PowerRanker accepts a pseudocount $k$ as a constructor option and knows nothing about residents, participation, or houses. The application layer computes $k = c \times \text{numResidents}$ from its domain knowledge and passes it in. The library became more general while the application remained domain-aware – and beginning with this separation as a design constraint shaped the research process throughout.

AI as a research partner accelerated exploration – but speed has its own risks.

This research was conducted in collaboration with Claude, which made it possible to move through the problem at a rapid pace. Formulating hypotheses, writing scripts, running them against data, and interpreting results could happen in a single sitting rather than over days or weeks. But the speed of the process created its own challenge: it became easy to explore faster than we could think. The damp-before-normalize breakthrough – the most important insight of the entire project – came not from another round of analysis, but from stepping away from the screen and working through matrix algebra with pen and paper. The AI was indispensable for traversing the search space; the human judgment about when to stop searching and start questioning was equally essential.

Question inherited assumptions.

PageRank’s normalize-then-damp pipeline was cargo-culted in without questioning whether its order of operations made sense in a different domain. We spent six iterations optimizing the damping curve before questioning where regularization belonged in the pipeline at all. Adapting an algorithm means inheriting its structure – and inherited structure can be the hardest kind to see, precisely because it came with the territory. The same lesson applied to implicit preferences: a pragmatic hack that worked well enough to obscure its own conceptual problems for years.

Legibility as professional obligation, not UX preference.

The commitment to make improvements “transparently or not at all” was a constraint the research imposed on itself: because ranking systems shape collective outcomes in ways not always obvious from individual inputs, the people who live with those outcomes are owed a legible account of how they are produced. Building new institutions means respecting the people who already inhabit them – honoring existing preferences while expanding future expressivity – and each model should be judged accordingly.

The Pairwise Paradigm

Sun, 14 Dec 2025 00:00:00 +0000

The Pairwise Paradigm

Abstract: Pairwise methods are best thought of as composing a paradigm for turning scarce attention into robust allocation signals. With the right algorithms, interface, and audience, they can support the continuous funding of ecosystems at surprisingly low attention cost.

Thanks to Carl Cervone, David Gasquez, Ori Shimony, and Dandelion Mané for feedback on earlier versions of this essay.

I. Motivations
II. Why Pairwise
III. The Pairwise Paradigm
IV. Continuous Funding
V. Evaluation and Legitimacy
VI. Putting It All Together
Appendix: Other Considerations

I. Motivations

There is no perfect voting system. The truth and tragedy of this statement have been understood for decades, beginning with Kenneth Arrow’s “impossibility theorem” showing the fundamental limits of ranked-choice voting systems.

At its core, the problem stems from attempting to measure complex social reality under conditions of high stakes. In attempting to distill subjective reality into objective votes, information is lost, and the measurement process itself becomes an arena for power contestation. In the end, the best we can do is design task-specific systems in which the gap between subjective experience and objective input is as small as possible, decreasing the scope of conflict and increasing both the utility and legitimacy of these systems.

In mid-2019 I speculated that, within the web3 governance community, the limitations of pass-fail voting would shift interest away from proposal-based decision-making towards distributed capital allocation. Over the last six years, that prediction has largely been borne out: instead of voting on policy, governance innovation has increasingly come to revolve around giving out money. The shift from discrete policy outcomes (you win, I lose) to continuous financial outcomes ($10 to you, $5 to me) opens a rich design space for social choice.

Within this domain, several classes of techniques have been explored:

Quadratic Funding, in which direct donations double as “votes” dividing a matching pool, subject to square-root constraints.
Pairwise Methods, in which inputs are framed as “A vs B” and converted into numeric allocations via an algorithm.
Metrics-Based, in which votes are made on high-level metrics, and allocations are made indirectly based on these metrics.
AI-Augmented, in which AI agents analyze projects and recommend allocations based on various internal processes.

Each of these approaches, on some level, seeks to convert scarce attention into useful signal. Each has its own strengths and weaknesses:

Quadratic Funding advantages smaller groups, but struggles to allocate attention, leading to “beauty contests.”
Pairwise Methods offer a simple and intuitive framing, but struggle to get sufficient coverage to produce good results.
Metrics-Based reduce scope for politics, but struggle with “Goodhart’s Law” failures and incentivize misrepresentation.
AI-Augmented sidestep issues of voter apathy, but struggle with issues of alignment, legitimacy, and interpretability.

I have been researching and working with decision-making systems since 2016, with a focus on pairwise methods. I believe that we should continue exploring all of these techniques, and develop a culture of practice able to select from among them based on the characteristics of the problem, and audience, at hand.

The rest of this essay will discuss pairwise preferences specifically, and describe the design space in which they operate. We will argue that pairwise methods should not be understood as isolated mechanisms, but as part of a larger paradigm of decision-making incorporating multiple complementary techniques. By approaching pairwise methods as a paradigm, it becomes easier to see how the various elements combine into a high-performance system for allocating shared resources.

We will focus on the use-case of “public goods funding,” in which communities come together to fund critical infrastructure, as this is the domain with the most activity and richest basis for analysis. The scope of these methods, however, is broader: instead of funding public goods, we could apply these methods to problems as grand as the setting of federal budgets, or as mundane as judging hackathons or prioritizing chores in a coliving house. Given the range of possible applications, getting pairwise right would be a major unlock in our ability to coordinate at scale.

II. Why Pairwise

A pairwise preference is a relative choice between two options, A or B. Pairwise preferences are the atoms of human subjectivity: the simplest distinction a person can make, running on the “phenomenological bare metal” of perception. This simplicity makes them robust (they mean what they say they mean), accessible (anybody can make a relative distinction), general (many decisions can be framed in relative terms), and flexible (pairwise preferences can be aggregated in many different ways).

Note: contrary to some depictions, Tinder-style swipes are not pairwise judgments, but pass/fail decisions.

Pairwise preferences have been studied for decades, going back to the work of American psychometrician L. L. Thurstone in 1927 and his research into subjective responses to stimuli. Pairwise preferences would find many applications in the ranking and ordering of items: from ranking chess players with Elo, to weighting web pages with Google’s PageRank, to assessing the reliability of nodes in a peer-to-peer file-sharing network with EigenTrust, to allocating credit for open-source contributions with SourceCred.

This dual heritage, as a technique for subjective measurement and allocating weights among items, suggests these methods have much to offer to the practice of distributed capital allocation, which faces exactly these problems.

USV’s Albert Wenger recently argued that “capital allocation is often downstream from attention allocation.” As society increasingly comes to view attention as its scarcest resource, evaluating social choice schemes through the lens of attention becomes increasingly critical. When compared to other voting systems, pairwise methods are arguably more “attention-native” – stimulating, game-like, and inherently rewarding to engage with.

Unlike non-attention-native methods like quadratic funding, which often lead to “beauty contests” favoring projects with marketing muscle, pairwise methods more naturally distribute attention by presenting items in random pairs. This approach elevates item discovery into a first-class construct, as voters are frequently exposed to items with which they are unfamiliar. This reduces the need (and benefit) for projects to market themselves, freeing resources for driving engagement with the system as a whole.

Further, distributing voter attention makes strategic voting more costly. Unlike, for instance, a Borda Count, in which one can trivially “bury” a rival by listing them last, voter evaluations will involve many pairs of items in which they have no strategic interest.

Seen through this lens, pairwise methods appear as a natural basis for social choice in an environment of scarce attention. Rather than take voting methods designed for pen and paper and try to adapt them to fast-paced, digital decision environments, we can take decision primitives designed for attention and make them the core of an entirely new regime.

Despite these attractive qualities, pairwise methods remain niche. They have seen some use in public goods funding, such as in Optimism’s RetroPGF (helping to allocate $100mm+ in funding) as well as in this year’s Deep Funding initiative, but have yet to capture the enthusiasm of other techniques.

This is in part due to gaps in pairwise practice, as well as the lack of an overarching vision – making the technique difficult to use and to communicate. By clearly articulating pairwise as a paradigm of interrelated techniques, we can better communicate the scope of these methods, build momentum around their use, and advance the art and practice of public goods funding overall.

III. The Pairwise Paradigm

The word “paradigm” comes from the Greek word for “pattern,” and in scientific contexts refers to “a distinct set of concepts or thought patterns, including theories, research methods, postulates, and standards for what constitutes legitimate contributions to a field.” By framing pairwise as a “paradigm” instead of a single tool or mechanism, we emphasize that it is not any one technique, but rather the synergies between techniques that produce desirable outcomes.

These techniques fall into multiple buckets: audience and problem development, interface design and data collection, and algorithmic data analysis. As an end-to-end pipeline, audiences feed into a voting interface, which feeds data to algorithms that guide both ongoing data collection and final analysis:

Individual techniques can be added, altered, or removed within this pairwise paradigm, allowing for parallel explorations within a coherent design space.

We will now explore these topics, starting with algorithms (what we’re trying to compute), then work backward through pair selection, interfaces, and audience – the layers that shape the data those algorithms receive.

1. Algorithm Selection

Note: this section is more technically dense than the rest of the essay. Feel free to skim if the details are not relevant to you.

Pairwise preferences themselves do not determine rankings or weights. Rather, they must be converted into weights using an algorithmic process, a “machine for converting subjectivity into objectivity.” The choice of algorithm has far-reaching implications for what kind of output gets created, and how it should be interpreted.

This section will discuss several options and their properties, with a focus on the ontology and complexity of each algorithm – how each algorithm models reality, and how it processes information relative to that model.

In all cases, we begin with a sequence of pairwise observations $[(a, b, x), ...]$ with $x$ representing the pairwise judgment, and want to produce a set of weights $w = [w_a, w_b, ...]$ summing to 1 telling us how to divide a fixed pool of capital among the items.

Note: Throughout this section, we will use the standard “Big-O” notation for evaluating the complexity, in terms of both computation and data, of these techniques.

Elo

The Elo rating system, developed by Hungarian chess master Arpad Elo, is most well-known as the basis for professional chess rankings, but has found use in determining rankings across a variety of domains.

In the Elo system, every participant has a rating $R$ determined by their prior matchups, used to predict the score $S$ of an upcoming match between $a$ and $b$:

\[E[S_{ab}] = \frac{f(R_a)}{f(R_a) + f(R_b)}\]

After a match, the players’ Elo ratings are updated as a function of the actual outcome vs the predicted outcome against an opponent:

\[R'_a \leftarrow R_a + g(S_{ab} - E[S_{ab}])\]

Ontologically, Elo models interactions as occurring in a sequence between the entities themselves, with the entities changing as a result of these encounters.

Computationally, Elo is $O(n)$ in the number of matchups $n$, with every matchup resulting in one constant-time update, with no minimum number of observations.

Unlike the other algorithms discussed, which generate weights in a single batch using all of the observed preference data, Elo is an online algorithm, meaning that the rankings are updated after every matchup – and are thus dependent on the specific sequence of the matches. Data are understood as the result of a matchup between two items, not as a vote on a pair of items by an independent observer.

While often proposed as a candidate algorithm for capital allocation, Elo’s ontology of a sequence of matchups between items makes it a bad fit for the use-case, in which data takes the form of a set of votes by third-party observers.

Bradley-Terry

The Bradley-Terry model is a popular model for generating weights based on pairwise preferences.

Bradley-Terry models every item as having a latent strength $p$, and models the probability of item $a$ being preferred to item $b$ as follows:

\[P(a > b) = \frac{p_a}{p_a + p_b}\]

Ontologically, Bradley-Terry is essentially Platonic: pairwise observations are understood as random fluctuations revealing a hidden capital-T Truth.

Computationally, fitting a Bradley-Terry model is $O(nm)$ in the number of matchups $n$ and number of iterations $m$ needed to converge, requiring observations $O(k^2)$ in the number of items $k$.

Note the similarity to Elo, which also models results as a ratio of latent scores. However, unlike Elo, Bradley-Terry produces weights in a batch based on a set of unordered preferences, making it a more natural choice in the setting where the inputs have no inherent ordering. In terms of computational complexity, Bradley-Terry models are typically fit using a statistical technique of Maximum-Likelihood Estimation, in which the underlying probabilities are iteratively updated to improve their fit to the observed data, requiring several passes, or iterations, over the training data.

Bradley-Terry methods are popular in the academic literature, as they lend themselves well to evaluation and simulation – one can begin with a fictional “ground truth,” run a simulated voting process, and then evaluate how well the recovered weights align with the initial ground truth. These types of simulations, while rigorous in the statistical sense, tell us less than we might like about how these models perform under real-world conditions.

Spectral Methods

Spectral methods, the most famous of which is Google’s PageRank, aggregate pairwise inputs into a “graph” of interactions, and then take the weights from the graph’s principal eigenvector.

In linear algebra, the eigenvector (“self-vector”) of a graph or matrix $X$ is the vector $v$ such that:

\[Xv = \lambda v\]

We can interpret this vector as representing the “direction” to which the graph “points,” which we can interpret as a type of “center” or “steady state” of the data (see visualization). Techniques for decomposing a graph into these components are known as “spectral methods” after the “spectrum” of latent values they reveal (just as white light is divided into a “spectrum” of constituent colors).

Ontologically, spectral methods invert the Bradley-Terry model by taking interactions as the only knowable reality; weights are understood as summary statistics, not hidden truths.

Computationally, spectral methods are $O(k^3 + n)$ in the number of items $k$ and the number of matchups $n$, requiring $O(k^2)$ observations. That the computation grows with the number of items, not the number of votes, makes this technique shine in settings where many votes are cast on a small number of items.

Note: spectral methods naively require $O(k^2)$ observations, but smart pair selection can reduce this to $O(k)$ (see “active ranking” below).

Spectral methods have a history dating back to German mathematician Edmund Landau, who in 1915 described how they could be used to judge the outcomes of competitions. In this setting, “votes” emerge endogenously from interactions among the items themselves (i.e. two teams competing with each other, two websites linking to each other). In 2018, inspired by projects like Pol.is and All Our Ideas, my colleagues at Colony and I extended these techniques to the domain of social choice, modeling votes emerging exogenously as voter judgments. This work led to the development of pairwise.vote, the preferred pairwise interface for web3 public goods funding, used in both Optimism’s RetroPGF and the first iteration of this year’s Deep Funding initiative.

Among researchers, spectral methods were historically neglected relative to Bradley-Terry until the 2015 Rank Centrality paper demonstrated both their statistical equivalence and computational advantages. The key theoretical difference between the models is that spectral methods evaluate relationships globally and leverage transitive relationships not explicitly observed: if A beats B, and B beats C, then a spectral method can infer that A likely beats C. This propagation of signal creates more complex interactions, but also allows these methods to produce better results with the same information. Spectral methods are also robust against cycles and other intransitive relationships, for which they produce ties, not contradictions (see “intransitivity of preferences” below)

For these reasons, we believe spectral methods are a strong choice for capital allocation, which cares about modeling relationships across an entire ecosystem.

Deep Funding

Both Bradley-Terry and spectral methods have a major drawback: they are data-hungry, requiring votes on the order of $O(k^2)$, the square of the number of items $k$. These large data requirements make pairwise methods difficult to use in practice, as they make gathering sufficient data challenging.

Deep Funding is an alternative technique proposed by Vitalik Buterin in late 2024, in which pairwise judgments are not used to generate weights directly, but rather to score competing weight proposals, which are produced externally.

Note: this initiative is unrelated to SingularityNET’s Deep Funding program.

Under the slogan of “AI as the engine, humans as the steering wheel,” Buterin introduces a model of social choice in which the weight proposals are produced at scale by machines, with a relatively small amount of human input being used to score proposals. This reframing of the problem – and of the role of voters – aims to produce better results with less human input, and can be seen as an alternative response to the attention problem we introduced earlier.

Ontologically, Deep Funding treats weights as untrusted proposals and treats juror inputs as samples of reality used to score and select the best proposals.

Computationally, Deep Funding is $O(nw)$ in the number of votes $n$ and the number of proposals $w$, requiring data on the order of $O(k)$ in the number of items.

Given that weights are not derived from votes directly, Deep Funding may be better understood as a meta-algorithm than as a pairwise algorithm proper.

Unlike the $O(k^2)$ vote requirement of Bradley-Terry and the spectral methods, Deep Funding aims to produce results with only $O(k)$ votes and a small constant factor, on the order of $k/10$, or one vote for every ten items. This reduction in complexity from quadratic to linear means that Deep Funding methods can be applied to problems with many items, for which it would not be feasible to gather a large number of pairwise judgments.

Note that this smaller data requirement does not take into account the computation needed to create the weight proposals themselves.

Deep Funding’s central drawback is that the $O(k)$ votes are only enough to score proposals, not to produce them. Ultimately, the method can only produce results as good as the proposals it receives, introducing new vectors of complexity, risk, and disruption.

2. Pair Selection

As mentioned earlier, a challenge of using Bradley-Terry and spectral methods is that they require a quadratic number of votes for a given number of items. As a result of this explosion of interactions, producing weights for even 50 items might call for 2,000 votes – a big ask, especially for communities already struggling with voter apathy.

Developing techniques for managing this scale will be key to bringing pairwise methods into the mainstream.

Fortunately, two practical approaches already exist: star grouping and active ranking.

Star Grouping

This approach, developed by the team at General Magic, introduces a pre-filtering step in which voters score each project on a scale of one to five stars. These scores then bucket projects into one of five tiers, with pairwise comparisons being made only between projects of the same tier. This reduces the number of votes required by 80%, by ensuring that the quadratic creation of pairs occurs in smaller sets.

Star grouping can also be adapted to settings where the categorization is not of quality, but of type. In cases where the items being considered are not all of the same type, star grouping can cluster like items together, clarifying downstream voting.

Active Ranking

Another approach for reducing the number of votes needed is through a technique called “active ranking,” an adaptation of the “dueling bandits” algorithm from machine learning.

Active ranking works by surfacing pairs not at random, but based on the uncertainty of that pair. The intuition is that among the entire set of items, some pairwise judgments are more “obvious” than others, and so don’t need to be voted on (e.g. bear vs rabbit). Active ranking directs scarce voter attention to the pairs which are the most ambiguous, and thus provide the most information (e.g. bear vs lion).

In theory, we can imagine needing as few as $O(k)$ votes, albeit with a large constant factor – an entirely different complexity class from $O(k^2)$.

To give intuition for why this should be possible, observe that any weighting of $k$ items can be expressed as a set of $k-1$ scalars (up to an overall scaling factor), representing the pairwise ratio of two adjacent items:

\[[.1, .2, .3, .4] \rightarrow [2, 3/2, 4/3]\]

This generalizes to an arbitrary number of weights and suggests to us that we can in principle construct $k$ weights with only $k-1$ human inputs. While this limit is not achievable in practice, we can attempt to approach it, reducing the data requirement to some multiple of the number of items, i.e. $k \cdot 10$ by directing attention towards the subset pairs which are most competitive with each other.

Note: the estimate of 10 votes per item is speculative and depends on the specific structure of the graph; real-world performance will need to be evaluated in future research.

Implementing active ranking is surprisingly straightforward. For every pair of items $a, b$ we construct a Beta distribution $p_{ab} \sim Beta(votes[a,b], votes[b,a])$ representing the ambiguity of the pair, and then sample based on $Var(p_{ab})$. This variance will be high for pairs with few or mixed observations, and low for pairs in which one item is repeatedly preferred – directing voter attention to where it is most valuable. Calculating these distributions can be done iteratively, with the relevant distribution being updated in constant-time after each vote.

An optional extension to active ranking would be to sample not only by $Var(p_{ab})$, but by $Var(p_{ab}) \cdot w_a w_b$, effectively upsampling the higher-weighted items. The idea here is that not only do we want to direct voter attention to the most ambiguous pairs, but to the most ambiguous pairs that are also the highest-value, as this is where the attention will have the greatest marginal impact on allocations. Extending active ranking in this way requires more computation, as weights will need updating after each vote, but in practice weights can almost certainly be cached and updated periodically, amortizing computation without significantly degrading performance.

Compared to star grouping, active ranking has several advantages. First, active ranking permits $O(k)$ comparisons total, while star grouping implies $O(k^2)$ votes per tier. Second, active ranking can be run transparently in the background, while star grouping requires an explicit voting step. Third, active ranking allows for all projects to be compared, whereas star grouping precludes comparison between groups.

Note that active ranking is an online process – the order of votes does matter for determining which pairs are more likely to be shown, although the final weight production remains a batch process using all available data. This online nature of active ranking creates a new attack vector, as prior votes now influence the likelihood of future items being shown. Mitigating this risk will be an important part of bringing active ranking into production.

Update: For an account of implementing active ranking in practice, see “Implementing Active Ranking”.

3. Interface Design

Another key consideration is the design of the voting interface. A data analysis pipeline is only as good as the quality of the data it analyzes. More so than with other methods, the interface of a pairwise process has significant impact on the quality of the data collected.

To illustrate this, imagine a hypothetical “bad” interface, showing only the names of the items being compared. With this interface, participants must make decisions based only on their pre-existing associations, resulting in noisy and unreliable data. In an even more extreme example, imagine a user deciding between two random strings – a process which produces pure noise.

Taking it in the other direction, can you imagine an interface profoundly better than any you’ve seen before? Why or why not?

Ultimately, the performance of a pairwise voting system is downstream of the interface.

Voting and Session Times

Before getting into the specifics of UI elements, we should ask ourselves a basic “product” question: how long should voters spend evaluating a given pair? With a target time in mind, we can work backwards to make decisions about visual design.

In discussion, practitioners have proposed target decision times of as short as 5 seconds to as long as 5 minutes. Analysis of deep funding voting data suggests that the “sweet spot” is about 30 seconds. More time does not result in meaningfully better judgments, and reduces the total number of pairs submitted. Less time increases the likelihood of a random choice, and thus of measurement error.

Working backwards from this 30-second target, we can design an interface to provide as much information as can be processed in that time frame.

Beyond individual votes, we can also think about the voting “session” as another type of product. If we see voting on a single pair as the atom of a pairwise process, a 30-second decision bundles naturally into the 5-minute voting sessions, yielding 10 new votes. The 5-minute session becomes the unit of engagement – light enough to be completed on the train or over coffee, yet substantial enough to move the process forward.

Input Format

Another key question is whether voters will be asked to make ordinal judgments (A better than B) or cardinal judgments (A 3x better than B). While cardinal judgments are appealing at first glance, offering the promise of more signal, that promise is often unfulfilled. It is typically the case that in untrained audiences, measurements of psychic intensity are more likely than not to be measurements of individual mood or personality, yielding mostly noise and little signal.

An analysis of Deep Funding’s initial juror data showed that while the perceived numeric ratio of two projects’ impact varied widely, the perceived direction of the impact (whether A or B overall was more important) was remarkably consistent – between 63% and 89% agreement, depending on the set of items being evaluated. This implies that while voters struggled to provide consistent numeric evaluations of the relative impact between pairs of projects, they could more consistently determine which of two projects was more impactful overall.

It is, of course, not so simple, and questions of cardinality and ordinality continue to be explored by the academic community. One recent paper on LLM evaluation found that models which presented results with “distractions” like excess enthusiasm were more likely to be chosen in ordinal matchups, while both neutral and “distracting” responses received similar cardinal ratings, suggesting that, at least in the case of LLM judgment, cardinal methods may be robust in ways that ordinal methods are not. Another recent study found that over long periods of time, cardinal measures of personal wellbeing were correlated with objective outcomes (such as moving to a new neighborhood if unhappy where you live), suggesting that cardinal judgments are not always noisy or idiosyncratic, but consistently capture sentiment at scale.

The question of cardinal vs ordinal judgments is far from settled, and much depends on the specifics of the problem and the audience. However, it does seem that in our setting of decentralized capital allocation by large heterogeneous groups of voters, that ordinal judgments should be, at the very least, the default.

Visual Elements

When it comes to visual design, the Pairwise team has arguably gone the furthest. Consider the interface they developed for the Deep Funding pilot:

Here we see a number of design elements:

Each item clearly indicated by name and logo
A set of curated and domain-specific metrics
An AI-based textual summary of the project
The ability to choose either item, or to skip

These elements form the foundation of an effective decision process. The metrics enable immediate, quantitative contrast between the two items, while the text summary gives the voter deeper context on individual items. Letting the voter skip pairs reduces the incidence of bad data, in cases where a voter genuinely cannot differentiate between two items.

Further, this approach leverages both metrics and AI judgment, while leaving the final decision in the hands of human voters. The key insight is that while the metrics and summaries may be the same for every project, individual voters qualitatively integrate the information differently, yielding richer results than would be possible by allocating funds by metric or AI judgment directly. Pairwise methods are more robust to Goodhart’s Law-style failures, common among metric and AI-based approaches, in which projects learn to “game the system” by tailoring their self-representation to more narrow and mechanical decision criteria.

Here is another interface example, Verdict, recently developed by the Deep Funding team:

This interface is organized around the idea of “high quality bits” and reflects the team’s priors around data quality and their desire for fewer, highly selected votes. This interface asks voters to make cardinal assessments of relative value, and asks for written explanations for their decisions. In addition, the interface states that all votes will be reviewed by “meta-jurors” and potentially rejected if deemed unjustified.

This interface was developed following the initial pilot, which used the Pairwise.vote interface presented previously. When analyzing the data from that pilot, the Deep Funding team found that their cardinal rankings varied significantly in scale and range per-voter. Rather than adopt ordinal inputs, which are more robust to voter idiosyncrasies, they chose to increase gatekeeping as a way of maintaining data quality. It retains the use of AI summaries, but omits the metrics featured in the earlier iteration, pushing voters to rely more heavily on textual summaries.

Finally, here is a mockup of an interface I would consider close to ideal, focusing on simplicity and comprehensibility:

This interface leans into ordinal inputs and prioritizes speed and access over gatekeeping, while leveraging AI summarization and metrics to standardize decision framing.

4. Audience Development

The next key consideration when running a pairwise voting process is audience development.

Audience Selection

Pairwise methods are well-suited to the setting of distributed capital allocation by a heterogeneous audience, with many different people coming together to distribute shared resources. They succeed by directing participant attention efficiently over a range of items, without requiring deep prior knowledge of the items in question.

Pairwise methods are less effective when used by a small group of experts, who are more likely to have strong prior knowledge of the items in question. For this audience, who has already performed the cognitive labor of developing opinion, assigning weights directly might be more efficient and more natural.

To give a concrete example, during the Deep Funding pilot a senior Ethereum community member criticized the process on the grounds that they had already formed clear opinions about the right weights for individual projects, and that the pairwise process made it harder to express those opinions.

It is also possible to have an audience which lacks a minimum baseline of context, such that even with a quality interface, they are unable to meaningfully distinguish between items.

The ideal audience, then, is a large and diverse group of people with at least some domain knowledge, able to make judgments on never-before-seen pairs after about 30 seconds of absorbing information. This group will be able to provide the most net information, in terms of both quantity and quality of inputs.

Audience Expectations

Relatedly, it is important that participant expectations be set appropriately.

Pairwise methods don’t ask participants for weights directly, but infer them indirectly using an algorithmic process. For audiences used to assigning values directly, “giving up control” of the weights can be disorienting. After Optimism’s RetroPGF 3, General Magic interviewed participants and found that while participants found the system engaging and an aid in discovery, they also struggled with the shift in expectations of not setting weights directly.

Communicating the behavior of the system, and making the end-to-end process legible for participants, is key to building trust in these methods.

Audience Segmentation

Every voting process needs some way of segmenting and evaluating its participants to prevent vote manipulation. At minimum, this means some form of sybil resistance, whether tokens, identity “passports,” or webs-of-trust built off of pairwise attestation. Choosing the right solution will again be a function of problem and audience.

The dual of sybil resistance is making better use of expert attention through reputation systems. Just as much as we discard fraudulent votes, we can give leverage to experts by assigning their inputs a higher weight. One might imagine a process in which the majority of the community engages early, making a “first pass” over the items, to be followed by expert assessment of only the most ambiguous pairs.

Reputation and identity is a deep field and beyond the scope of this essay, but it is worth gesturing towards how these ideas might be combined.

Audience Compensation

While pairwise voting processes are often seen as more inherently engaging than other forms of voting, it would be naive to expect ongoing voter participation without some external incentive or motivation – financial, relational (status), or both.

Financial rewards are straightforward, but can incentivize mercenary behavior and, being zero-sum, create a drag on resources. Non-financial rewards, such as digital collectibles which double as attestations for a public goods funding reputation system, represent an underexplored and positive-sum alternative.

IV. Continuous Funding

Possibly the most significant application of pairwise methods is the idea of “continuous funding.”

Conventionally, most public goods funding takes place via “rounds.” Each round is a distinct event, featuring a slightly different set of projects and requiring an entirely new set of votes. Putting on a grants round is a large lift, consuming many hours of administrative time on the part of both the sponsoring organization and the projects being considered, and of voting time on the part of participants.

Much of this labor is redundant, as both projects and voters tend to be similar round-over-round. Looking at data from Gitcoin Grant rounds 20 and 22, which took place six months apart in April and November 2024 (disclosure: I participated in both rounds), we see that 52% of the top 25 projects in their “dApps and Apps” category carried over between rounds. If an ecosystem is evolving only 50% between rounds, then the round-based approach is wasting half of both its administrative input and voter attention.

Instead of discrete rounds, which make inefficient use of both administrative and voter inputs, public goods funding should move towards long-lived continuous processes, in which valuable administrative and voter inputs are leveraged over longer periods of time.

Continuous funding processes also allow for a more relaxed attitude towards “correctness,” as the opportunity to course-correct is built in from the get-go. Rather than feel pressured to “get it right” the first time, it becomes possible to “throw something out there” with the confidence that allocations will be updated in response to new information, and that over time the resources will flow towards the point of greatest impact. This “cybernetic” or evolutionary approach to capital allocation – focusing less on static point solutions and more on self-correcting processes – promises to be more robust and resilient than the high-cost, round-based approaches dominant today.

This idea of continuous funding has been explored before, with pilots like GeoWeb’s Streaming Quadratic Funding, and more recently Octant’s StreamVote, combining quadratic voting with Superfluid’s continuous payments infrastructure to distribute funds in real-time.

However, apart from one notable multi-year real-world example, to date no continuous public goods funding process has been built on top of pairwise inputs. For reasons explored below, we believe that pairwise inputs offer a stronger basis for continuous funding, converting scarce attention into actionable allocations at high efficiency.

Permissionless Entry

Most public goods funding rounds have high overheads, with staff needed to screen projects, run comms, and audit performance. This high overhead ultimately consumes funds which could otherwise be directed to projects directly, creating inefficiencies which threaten to undermine the legitimacy of the process entirely. A fully permissionless continuous funding process would enable capital allocation at lower cost by reducing or eliminating this overhead.

In a permissionless process, projects add themselves to the pool by putting up a stake. Once in the pool, the active ranking process would surface high-variance new projects, allowing them to quickly “find their level” of funding. Projects that perform poorly – say, more than three standard deviations below the mean – would be evicted from the pool and lose their stake.

See below for a visual intuition for this process:

Pairwise methods are well-suited for this type of permissionless, self-correcting process, due to the logically “self-contained” nature of the pairwise judgment (i.e. a choice of A vs B does not depend on C). In contrast, quadratic “votes” are logically conditioned on the entire set of items (i.e. I might give $10 to A on its own, but only $5 in the presence of B, which gets the other $5), making quadratic methods less naturally adapted to a continuous setting in which items are frequently being added and removed. This limitation creates frictions which must be overcome.

To give a concrete example, StreamVote performed AI screening of projects before allowing them to claim funding, winnowing the final set of projects from 3,980 down to 17 – a 99.6% rejection rate, and large use of administrative power.

In contrast, an always-on pairwise process with active ranking can itself serve to screen and filter a dynamic pool of candidates, eliminating a costly administrative task.

Stale Voting Data

As discussed previously, one of the advantages of pairwise judgments is that they can be meaningfully re-used over time. However, while in theory a vote on a given pair is valid in perpetuity, in practice we should be cautious of relying on stale data. In reality, projects are always evolving, and a preference for A over B may become increasingly inaccurate if A stagnates while B thrives.

One approach to balancing this trade-off is through a decay process in which votes lose their impact over time, perhaps decaying to zero over a two-year period. There are many possible decay curves, all reflecting different assessments of how fast this particular reality changes.

Funding Rates

The complementary question to vote decay is that of “how fast should we distribute the money?” Unlike rounds-based approaches, in which the entire pot is given out at the end of the round, continuous processes must make choices about the speed with which they distribute their funds.

One approach would be to distribute funds at a constant rate over some period of time. A four-year target would see 50% given out after two years, and 100% after four years, at which point the process would end (assuming no new funds).

Another approach, proposed by the Colony team in their 2018 whitepaper, would be to distribute funds at an exponentially decaying rate, such that funds are distributed according to a “half-life.”

A one-year half-life would give out half the funds in the first year, a quarter in the second year, an eighth in the third, and so on (assuming no new funds). Compared to the constant rate, this approach extends the life of the process indefinitely, at the cost of a decreasing funding rate.

Process Tempo

Throughout this section, we have emphasized the value of reducing the administrative overhead involved in running grant rounds. However, we acknowledge that even a continuous process might benefit from a periodic “tempo” of participation. An always-on process is hard to keep top-of-mind, and might see particiption lapse over time.

To counteract this, one could imagine running “campaigns” to periodically refresh voting data at scale, leveraging leaderboards and other incentives to stimulate data-collection. In the best case, resources which would otherwise have gone to administrative tasks can be redirected towards other purposes, such as commissioning compelling digital collectibles to give as rewards to participants.

On the payouts side, one could imagine making payouts on a monthly or quarterly basis, or conditioning payouts on milestones determined by a separate governance process.

The key idea is that user and project experience could be made qualitatively similar to that of a round-based process where it counts, while retaining the benefits of a continuous substrate in which allocations update and distribute in real-time.

V. Evaluation and Legitimacy

At the start of this essay, we argued that the limitations of pass/fail voting led to a shift in interest towards capital allocation. Capital allocation, however, has its own challenges: in particular, evaluation.

As has been well-documented by Metagov’s Grant Innovation Lab, difficulties in evaluating the effectiveness of grant programs are leading to an erosion of trust in public goods funding overall, and a slow reduction in funding for such programs. As a result, over the past year the public goods funding community has increasingly begun prioritizing evaluation over experimentation.

On some level, evaluation is an impossible and fundamentally speculative task. If someone wanted to support public goods and could accurately evaluate the future impact of a present investment (or even the present impact of a past investment), they would be better off making billions on Wall Street and starting a foundation.

Given that nobody is doing that, and that evaluation is on some level made-up, it’s fair to ask what “evaluation” actually achieves. We suggest that evaluation produces legitimacy, which translates concretely into higher future funding inflows. As Vitalik Buterin famously said, “legitimacy is the scarcest resource.”

To adopt ideas from institutional economics, we can imagine evaluation as filling out a currently-barren “policy” layer in the three-layer model of constitution, policy, and operations. In this frame, the “constitutional” layer represents the code, norms, etc., of the grants ecosystem itself, the “policy” layer represents the process by which specific parameters (mechanisms, etc.) are chosen, while the “operational” layer represents the grants rounds themselves: applications, voting, etc. Seen in this way, evaluation is the missing political process needed to bring web3’s public goods funding ecosystem from experiment into maturity.

How might these evaluations be done?

One possibility, adapting techniques used to evaluate large-language models, is to subject allocations themselves to pairwise judgments. In addition to pairwise judgments between projects, the community can make pairwise judgments between allocations produced by competing mechanisms. By comparing the outputs of different allocation processes, a community can set policies for how resources are distributed: this algorithm vs that, this parameterization vs that.

Another possibility, popular in the web3 community, is to lean into “info-finance” as a tool for producing high-quality predictions about the future. Unlike votes, which reflect subjective opinions, financially incentivized predictions can in theory be treated as objectively reliable sources of information. Info-finance is not my area, so I cannot comment deeply on the strengths and weaknesses of this design, but these approaches have always struck me as a touch reflexive, with predictions and allocations influencing each other in complex and hard-to-model ways.

This is not idle speculation. The proliferation of sports betting apps has begun affecting player behavior, who exploit privileged positions to resolve markets in their favor.

Yet another possibility would be to develop new metrics for evaluating the “health” of a funding process. By tracking metrics such as the degree to which a funding distribution follows a power-law, or the churn of projects over time, one can assess how a funding process is performing relative to an idealized baseline.

Whatever approach is used, it is virtually certain that evaluation will become table stakes for those looking to implement capital-allocation schemes.

VI. Putting It All Together

As argued in the introduction, pairwise methods should be understood not as a single technique or mechanism, but as a paradigm of social choice. Having introduced the various pieces of this paradigm, we can begin putting them together, and offer concrete estimates of the actual attention requirements for public goods funding.

Assuming 30 seconds per vote and 10 votes per item with active ranking, pairwise methods can produce allocations at an attentional cost of 5 minutes per item. For a set of 600 items, this calls for 50 hours of total voter attention. If we assume each voter contributes four five-minute sessions (20 minutes), then we need only 150 voters to produce legitimate results – a relatively easy lift.

As a continuous process, things get even better. If we assume that only ~25% of the items undergo meaningful change in a given quarter, we can sustain a continuous funding process indefinitely with an attention cost of 5 minutes per item per year.

Further, given a sufficiently robust reputation system, we could imagine running seasonal “campaigns” in which the community contributes en masse to project filtering, followed by experts who resolve the highest-ambiguity pairs or adjudicate between the outputs of funding mechanisms themselves. Participants could be rewarded with sought-after digital collectibles, serving as reputation attestations and cultivating a public-spirited group identity.

The net effect is that of an always-on social choice “sensor” – a solar panel for governance – collecting ambient preference information and converting it into actionable outputs in real-time.

The idea of sustaining a complex public goods funding ecosystem with so little effort might seem implausible, and the continued development of these techniques will certainly surface new challenges and limitations. And yet, the arguments have been laid out, and these are the conclusions we’ve drawn.

Final Thoughts

The task of helping groups of people effectively manage shared resources is one of the most pressing problems of our day. We have argued that pairwise methods, seen not as isolated techniques but as part of a paradigm of social choice, offer a compelling toolkit for solving exactly this problem.

Relative to other techniques and to their underlying potential, pairwise methods remain underexplored. By articulating a “pairwise paradigm,” we hope to help chart the way.

Appendix: Other Considerations

The Independence of Irrelevant Alternatives

The “independence of irrelevant alternatives” (IIA) is a key concept in social choice. The principle of IIA says that the relative ranking of two options must never depend on a third (the “irrelevant alternative”). In practice, almost every voting system violates this ideal in some way; the question becomes why and to what degree.

Some pairwise algorithms, such as spectral ranking, intentionally draw in third options to produce richer comparisons with less data. This produces results which reflect a global perspective, incorporating more data but increasing the likelihood of unexpected interactions. This unapologetic rejection of IIA is arguably an advantage in the setting of capital allocation, where the goal is to distribute resources across an entire ecosystem.

However, in high-stakes, single-winner settings like elections, these complex and non-linear interactions can undermine the perceived legitimacy of the process. In those settings, a Condorcet method with stronger guarantees would almost certainly be preferable.

Note: as discussed earlier, individual pairwise judgments are in fact independent of alternatives; it is only the final result which is not.

Intransitivity of Preferences

Closely related to IIA is the idea of cycles and the transitivity of preference – the idea that if you prefer A to B, and B to C, then it is logically consistent that you would prefer A to C. To prefer otherwise creates what is known as a “cycle” of intransitive preferences. For many voting methods, cycles represent contradictions and are seen as inherent flaws.

Spectral methods, on the other hand, handle intransitive preferences naturally – they are not contradictions, but information. Cycles are interpreted naturally as ties, which pose problems for single-winner elections, but not for capital allocation in which funds are simply given out equally.

Further, pairwise spectral methods allow for a different interpretation of intransitivity. Unlike Bradley-Terry, which models every item as having a latent value, and interprets intransitivity as measurement error, spectral methods model intransitivity as a normal part of reality.

To give an example, imagine items A and B, each having qualities X and Y. If we conceptualize voters as making pairwise decisions based on subjective integrations of the data, one voter might integrate X and Y and choose A, while another, filtering through the lens of their own personal beliefs and lived experience, chooses B.

Over hundreds or thousands of voters, the pairwise graph becomes a rich field of relationships with frequent cyclical and intransitive behaviors, reflecting a deep and socially-embedded understanding of the ecosystem in question. Taking this graph as the only knowable ground truth, we then produce weights as a useful synthesis of that data.

One might imagine going even further, devising new metrics for community dynamism based on the degree of intransitivity in a given preference graph – or of treating the preference graph as a type of “constitution” for AI governance. This view of pairwise data – not as messy and needing of discipline – but as rich and nuanced truth, invites bold new visions.

Dealing with Heterogeneity

One of the few prerequisites to using pairwise techniques is making sure that the items being compared are meaningfully comparable. This may sound tautological – but it is by no means guaranteed. To give an example, one can meaningfully prefer an apple or an orange; one cannot meaningfully prefer an apple to the color orange.

Part of the practitioner’s skill is ensuring that the items being considered are part of a semantically coherent set. This meaning can come from either grouping like items together, or framing the comparison in a way which makes sense for the given set.

To give a concrete example, this year’s Deep Funding initiative framed the decision in terms of the relative impact of two software dependencies on a given software project; the same dependency might be assessed very differently depending on which project’s context was being considered.

This idea can be extended to the case when projects are of the same type, but have different funding needs – by framing the question in terms of “where should we direct the next marginal dollar,” projects of different scales can be meaningfully considered as part of the same set.

In permissionless settings where it may be difficult to ensure homogeneity in advance, techniques like star grouping can be used to segment items into coherent sets on-the-fly.

AI and Verifiability

Astute readers may have detected a certain coolness towards artificial intelligence throughout this essay. You’re not imagining it – let’s address it plainly.

Large language models are among the most transformative information-processing inventions since the development of writing, fundamentally changing how people participate in shared society. Many in the public goods funding and digital governance ecosystems are excited at the prospect of using AI to automate human judgment at scale. The potential benefits are real: Deep Funding, with its ~$k/10$ data requirement, outperforms both Bradley-Terry and spectral methods by two orders of magnitude, even with active ranking. With benefits, however come risks: of opacity, loss of agency, and the accumulation of unmodeled risk. Balancing reliance on AI while preserving our capacity for verifiability lets us navigate the design space more safely.

We can draw an analogy to the 2008 global financial crisis, in which years of cavalier underwriting led to a sudden collapse of asset prices, as trust fled from systems which could not be independently verified. It is uncomfortably easy to imagine an analogous “legitimacy crisis” occurring in 2028, in which years of deference to AI judgment leads to a sudden collapse of legitimacy, and the wholesale abandonment of digital institutions.

We can draw a second analogy to the design of “optimistic rollups,” a popular Ethereum L2 architecture in which transactions are “optimistically” assumed valid, subject to a dispute window. A key aspect of their design is the idea that any transaction can be disputed and independently verified. An optimistic rollup in which transactions were spot-checked randomly, on the order of one in every thousand transactions, and could not be individually disputed, would offer terrible security and be easily abused.

The answer is not to avoid AI, but to leverage it cautiously. As Archimedes famously said, “Give me a lever and a place to stand, and I will move the earth.” AI is our lever, but without firm footing, we may lose more than we gain.

This essay has tried to show how a public goods funding system could be constructed end-to-end using only human judgment, with AI playing a non-critical support role. With this foundation in place, it becomes possible to safely transition to higher levels of AI judgment, without taking on large and unmodeled risk. What we would advocate, in the closing months of 2025, is a two-pronged approach in which AI tools are used to leverage human judgment, but only to the extent that the entire flow can in principle be performed – and contested – by humans.

Exploring Deep Funding's Jury Data

Sun, 03 Aug 2025 00:00:00 +0000

This analysis explores 611 pairwise judgments from 51 jurors evaluating Ethereum dependencies through the Deep Funding experiment.

Key findings:

Pairwise evaluations show 89% agreement when comparing diverse projects, and 63% for similar.
Contrary to intuition, longer thinking times did not improve decision quality.
Results suggest pairwise methods are ready for greater deployment in public goods funding.

I. Introduction

Last winter, an exciting experiment emerged from the Ethereum public-goods-funding ecosystem. With a $200k prize pool put up by Vitalik himself, a group of enthusiasts began working on a novel method for supporting public goods: using AI agents to generate funding proposals, and using human inputs to adjudicate between them. “AI as the engine, humans as the steering wheel” became the initiative’s rallying cry.

The project, known as Deep Funding, aimed to develop “impact weights” for ~30 first-order Ethereum dependencies (clients, languages, developer tools), and ~5,000 of their child dependencies. With these weights in hand, funding could be “flowed” through the Ethereum ecosystem, supporting dependencies which might otherwise have gone under-funded.

A key part of the design involved collecting jury data – the critical inputs used to decide which AI proposals were most accurate and how to combine them. Rather than asking jurors to rank entire lists of dependencies, the design called for pairwise comparisons: assessing the relative impact of just two dependencies at a time. This pairwise format would simplify the human judgment task – instead of having to determine a full set of (meaningful) weights across dozens dependencies, they could focus their valuable attention on just one pair at a time.

A friend brought the project to my attention in December, and – having done a fair amount of work with pairwise methods – I was intrigued. I began volunteering, helping to refine the project design and the pairwise juror flow.

Over the course of this past winter and spring, Deep Funding gathered jury data using Pairwise, the voting tool developed by General Magic partially based on my own past work with Colony. Over this time period, 51 jurors provided 611 votes on project pairs across both the primary and secondary dependencies.

This analysis will explore these data, with the aim of better understanding both the dependency relationships, and the performance of the underlying pairwise process itself. On a personal note, I have been enthusiastic about these methods for years, and am happy to see them increasingly embraced by the Ethereum public-goods community.

II. Data Analysis

Our analysis will proceed in three steps:

First, we will discuss the basics of the data set and our metrics of interest.
Second, we will explore the judgments overall, looking at the degree to which jurors could distinguish between projects as well as the agreement among jurors.
Third, we will look at the specific relationship between thinking times and juror judgments, looking to understand whether more time spent per-pair produced better results.

Analysis code can be found here. The data itself are not yet public.

Preliminaries

The data includes 611 pairwise juror judgments gathered between December 24, 2024 and March 31, 2025. Participating jurors were presented with pairs of projects through the Pairwise interface:

The projects were organized into two data sets. The first, “Level 1,” consists of Ethereum’s direct dependencies – representing critical Ethereum-specific infrastructure. For L1, 30 jurors provided 402 votes over 35 unique projects, with an average of 13 votes per juror.

The second, “Level 3,” consists of the child dependencies of the L1 projects – representing general software development dependencies. For L3, 21 jurors provided 209 votes over 144 unique projects, with an average of 9 votes per juror.

These twin datasets permit a unique exploration: by performing the same analysis on both sets, we can learn not only what the data tell us about the Ethereum ecosystem, but better understand the pairwise method itself by seeing how the results differ between sets. A pairwise meta-analysis, if you will.

As part of the data processing, we introduce a few additional fields. The first is the log multiplier – the log2 of the multiplier (given between 1 and 1024), used to simplify data visualization. The second is the choice multiplier – the same multiplier but made positive or negative based on which project was chosen, enabling direct comparison between jurors. The third is the thinking time – the difference in timestamps between sequential votes by the same juror.

Methodological note: thinking time is inferred from the time elapsed between votes and should be considered a noisy signal. Further, some of the duration is explained by typing time, correlating with the length of the rationale string by .41 in L1 and .19 in L3.

Overall Juror Assessments

The first thing we look at is the distribution of multipliers given by the jurors. These histograms count the individual juror votes, grouped by the strength of the given multipliers. We see that for L1, the multipliers cluster more closely around 0, likely reflecting the consistent quality of all projects in the set. Given that L1 consists of Ethereum’s primary dependencies, it is unlikely that one would be significantly more important than another, and the data reflect this.

For L3, we see a skew towards higher multipliers, reflecting the greater variance in dependency impact and relevance. Given that L3 projects can run the gamut from critical dependencies to shell scripting utilities, it is unsurprising that the relative impact would be larger.

Overall, these data align with our intuition that the delta between L1 dependencies should generally be smaller than that between L3 dependencies.

Let’s look at the mean and standard deviation of the multipliers given by jurors for project pairs. These scatter plots show individual project pairs, presenting the mean and standard deviation of all juror votes on that particular pair.

We see that for L1, the standard deviation is relatively constant, indicating that the level of agreement among jurors was similar across the entire data set. Looking at L3, we see a very different effect: the standard deviation decreases at the extremes and increases towards the center, suggesting that larger differences in impact were easier to distinguish – an intuitive result.

It is worth noting that the average standard deviation for L1 is higher than that of the obvious cases in L3, suggesting that while L1 comparisons were more uniform in difficulty, they were on the whole more difficult than the simplest cases in L3.

If we ignore the multipliers and limit our sense of “agreement” to project choice, then jurors in L1 agreed with each other 63% of the time (based on 60 pairs receiving exactly two votes), while in L3 they agreed with each other 89% of the time (based on 28 pairs receiving exactly two votes). This suggests that the pairwise process captured meaningful signal, and that the signal was more clear in L3 than L1.

Juror Thinking Times

A major debate during the Deep Funding design process concerned the length of time jurors should spend thinking about each pair. Opinions ranged from as little as five or ten seconds per pair, all the way to five or even ten minutes. This 60-fold gap in expectations is striking, and suggests a practice guided more by intuition than empirical analysis. What do the data show?

Among L1 jurors, the median thinking time was 2.8 minutes, and among L3 jurors, 1.3 minutes. This makes sense, as L3 projects have greater variety, and so should be generally easier to distinguish.

One might wonder whether jurors who spent more time thinking would be more discerning; perhaps longer thinking times correlated with higher (or lower) multipliers. Looking at the L1 plot of thinking times vs. final judgments, we see no correlation. Looking at the same plot for L3, we see a small but weak positive correlation.

This next plot (my personal favorite) shows both votes for every project pair which received exactly two votes and where both votes had valid thinking times. We draw every project pair’s votes in the same color, and connect them with a dotted line. The slope of the line tells us how the longer-thinking juror’s vote differed from their shorter-thinking counterpart.

While dense with information, this chart offers a fine-grained view of voting behavior and suggests an interesting dynamic. Overall, in L1 it seems that more thinking time rarely resulted in a very different assessment of impact, and when it did, the effect seemed random. In contrast, in L3 it seems as though more time thinking typically resulted in a smaller multiplier – and only rarely in a choice change.

III. Conclusion

Overall, the data suggest that the pairwise process is useful for gathering subjective assessments of relative impact at scale.

The data on overall assessments confirms our intuition that it is easier to distinguish between things that are different than things which are similar. Not only was the perceived relative impact higher in L3, where projects vary more in quality, but the level of agreement was higher – suggesting that the decision problem was easier overall. The 89% agreement among jurors in L3 is striking and seems to pave the way for deployments at greater scale.

The data on thinking times challenges our intuition that more time spent thinking would produce better results. With the caveat that our thinking times are a noisy signal, we see little evidence that longer thinking times result in meaningfully better decisions. If anything, the data suggest the opposite – that we should be encouraging jurors to make more, faster decisions rather than fewer, slow ones.

Despite their promise, pairwise methods are relatively underdeveloped. There is ample room for research into improved UI, more efficient pair selection, and continuous funding paradigms in which juror votes are required only marginally instead of en masse. Through these continued investigations, pairwise methods have the potential to become critical infrastructure for Ethereum public goods funding – proving that sometimes the best way to understand a system is by building tools to evaluate it.

Tech in the Age of AI

Sun, 17 Nov 2024 00:00:00 +0000

I. Technology

At some point in the last few months, I saw a tweet from a software engineer who had just started using Cursor, one of the new AI-powered code editors. His hot take went something along the lines of:

I realized that 80% of my engineering skills have become obsolete.
My leverage on the remaining 20% went up 10x.

I was intrigued, so I downloaded the app. I was impressed. Cursor was well-done, with 95% of the product being a clone of VS Code, a popular mainstream code editor, with the other 5% being a few thoughtfully-designed commands for integrating AI into a development workflow. I had been using Github’s Copilot for a few months at that point, and found Cursor’s product to be more useful in practice.

Curious about who had made this tool, I found their “About” page. It looked as though Cursor was made by a half-dozen MIT alumni, just a few years out of undergrad. The next generation has come to turn me to glue, I thought to myself.

Within a matter of days, I found myself using Cursor’s features regularly, to handle tasks like writing tests and implementing new functionality. Cursor’s AI functionality is exposed more or less through three tools:

Generative auto-complete, in which the code editor will directly suggest text while you type.
A shortcut for inline edits. Useful for writing tests, e.g. “Write a test showing that function X obtains behavior Y.”
A shortcut for interactive chat. Useful for pasting in error messages or having more discursive conversations.

The auto-complete in particular is quite helpful, not necessarily because the suggestions are always correct, but because it is easy to accept them when they are, and ignore them when they are not; you don’t feel like you are constantly fighting with the tool. Having used Cursor for a few months now, I have developed an intuitive feel for the probabilistic nature of the suggestions: the earlier you are in implementing a piece of functionality, the more random the suggestions will be (less data means wider variance), while the later you are in implementing, the more accurate the remaining suggestions will be (as Cursor has more context to draw on). The best way to describe Cursor would be as an eager intern – often wrong and needing guidance, but enthusiastic and indefatigable.

Another example of Cursor’s utility is in facilitating front-end development. I am not a front-end developer, but I have enough of a foundation that I’m able to meet my basic needs. My experience of front-end is that of having to comprehend the myriad interactions involved with HTML and CSS, and to stay on top of the ever-evolving abstraction layers related to them. Cursor allows me to develop bespoke styles interactively, leveraging the latest techniques:

Me: Can you help me embed this YouTube video?

Cursor: Of course, here is a sample iframe configuration

Me: It isn't rendering properly, what's wrong?

Cursor: Sorry, the settings need to updated to include the new `aspect-ratio` property

Me: Awesome, thanks. Can some of this code be removed?

Cursor: Yes, some of my suggestions are now redundant, let me remove them

Leaving me with a clean YouTube embedding and a minimum of black-magic styling, in all of ten minutes. In another example, I was able to develop an entire React SPA for a scavenger hunt I helped organize in less than an hour. Obviously, there is material risk in using code you don’t understand, but I’m not sure if this risk is different in kind or merely in degree when compared to “copy and pasting from Stack Overflow,” which developers have been doing (albeit furtively) for years.

As I my workflow evolved in conversation with this tool, I found myself returning to that tweet. There is truth to it. Cursor makes development much less error-prone. The auto-complete is excellent at catching syntax and formatting errors as you work. When writing a piece of functionality, once you have demonstrated sufficient intent, the editor can often finish the rest. From an information-theory perspective, software engineers no longer need to write “informationless” code – if a diff of code provides “no new information” beyond what has already been written, the editor can usually infer it. In the ideal case, the most tedious half of the engineer’s job has been removed, allowing the more high-impact and creative parts of the role to take up more space.

II. Labor

What will this mean for the workforce? Are we a few years away from massive unemployment among software developers? It’s a valid concern.

I think it’s fair to say that software engineers, especially in the US, have enjoyed a cush existence this past decade or two. A relatively low bar to entry (relative to other professions), combined with strong demand driven by rapid industry growth, meant that software engineering was, for better or worse, about as close as you could get to free money.

How will AI change this?

In the late Obama years, I attended the Personal Democracy Forum, a technology-and-society conference held at NYU’s campus. One of the talks featured a young policy wonk, sharply dressed and not much older than me, talking about technology’s impact on the labor market. I was impressed by this man, who would confidently use terms like “labor categories” and reassured the audience that new types of work always emerge in the wake of technological change.

I suspect the same will be true today. I don’t think software engineers will be obsolete, but I do think that the skills in demand in five years will look very different from those of five years ago. Nor will software engineering departments in larger organizations be structured the way they are today.

Specifically, I suspect that teams will be smaller as a rule, across the board. At every level of scale and complexity, it will take fewer people to develop and maintain a given amount of software.

Further, the software engineering role will broadly have “moved up” the abstraction stack. Much like newer programming languages meant that average programmers needed to know less about kernel memory management, so will more advanced editors mean that average programmers will need to know less about language syntax, library APIs, and the like. The relative premium on an encyclopedic knowledge of languages and libraries will decline. As a corrolarly, there will be a relative premium placed on product sensibility, user sensitivity, and design fluency. New workflows will be more iterative and high-level.

If we wanted to be alarmist, we could read this as “job loss.” But I disagree. I don’t think this logic clearly leads to fewer people working in software; it might even lead to more. But what we likely will see is more, smaller, and specialized teams, iteratively developing custom solutions for specific niches. The “junior dev” role will increasingly disappear, and seniority will increasingly include aspects of product management. The wider diversity of teams and products will make it easier to find work that is more personally fulfilling.

Compensation ranges will likely widen, much as it did for lawyers in the 2010’s, as weaker engineers will find themselves struggling to demonstrate value, while stronger engineers will be able to leverage their abilities even further. On the flip side, it will become easier for less naturally technical people to find their way into the profession, broadening its accessibility at the entry levels.

The result is better and more finely-tailored software serving a wider variety of niches, made by people more deeply connected to their work, and with a more accessible profession overall. That does not seem particularly bad to me.

III. Distribution

Around the same time as the first tweet, I saw a second tweet on the broader effect of AI on the tech industry. The take was something to the effect of:

As the marginal cost of software declines, distribution matters more.

This is something I have been thinking about a lot, and I’m not the only one.

Broadly, the argument goes something like this: ten years ago, it was difficult to develop software. If you could build a team that could successfully deliver software, you had a business. Demand would be strong enough that anyone could be taught to sell it. The competitive advantage was technical superiority.

Now, however, the market logic has reversed. Anyone can develop software, and there is too much of it. People don’t know what software to use, or how to choose. What really matters is having the marketing and media savvy to cut through the noise and actually reach people. The competitive advantage will be communication and distribution.

This is something I’m taking seriously. After spending 4+ years (largely single-handedly) developing Chore Wheel as a software product, I am now investing in capacity for content and distribution. I have taken a Twitter class, and am trying to develop greater fluency with X, which is its own world and language. I have started a Substack, and have committed to publishing monthly long-form writing. I have been spending significant mounts of time developing marketing materials and iterating on messages.

Distribution is unfamiliar territory for me. For years, I focused on developing my technical capacities. I am now learning that distribution, sales, marketing are deep disciplines unto themselves, and that fluency will come only with time and effort.

In my first steps on this journey, I read Seth Godin’s This is Marketing. He wrote one thing which really struck me: “The amateur does what they like. The professional does what other people like.”

In some ways, engineering and distribution are highly complementary, the yin and yang of technology business. Both are deeply creative, involving the iterative definition and solution of problems. The engineer might ask: how can I develop software to achieve my objective? The marketer might ask: how can I develop a message to reach my audience? In both fields, your intuition might be right. But it just as often might not be. Where intuition ends, disciplined discovery begins.

IV. Vision

Unflagging optimisim my most obnoxious feature. I can find a silver lining in any circumstance.

It will be important to tread carefully over the next few years. As Karl Polanyi wrote in his seminal The Great Transformation, it is not the change itself that causes harm, but the rate of change. The speed with which AI is poised to reorganize labor markets has potential for real harm.

That said, if we can squint our eyes and gaze far into the future, there is much to look forward to. The promise of smaller, more tight-knit engineering teams embedded more closely with the communities they serve. The potential of more “whole people” – a more humanist kind of tech worker, less instrumental and more curious. The hope of technology being something that people can increasingly create for themselves, realizing the science-fiction settings of some of the best graphic novels.

There is much to look forward too, and perhaps not much to fear.

Understanding Generative Art

Sat, 18 Nov 2023 00:00:00 +0000

I. Overview

This is an essay defending blockchain-based generative art as a contemporary form. It will address three major critiques of generative art:

The artistic legitimacy of generative art,
The value and meaning of digital ownership, and
The advantages of a blockchain-based art market

We will demonstrate how these critiques are not only unfounded, but represent an narrow understanding of the nature and potential of the medium.

For the purposes of this essay, “blockchain-based generative art” will refer to artworks which are produced by successive runs of a computer program, with outputs not known in advance, and exist in a series whose number is fixed in advance. All artworks are publically available for viewing, and the specification and ownership of the artworks are stored in a public digital ledger.

We are specifically not discussing images generated by AI models in response to natural-language prompts, such as those of DALL-E or Midjourney. Such works are also described as “generative art”, but represent a very different form and require a different conversation.

II. Artistic Legitimacy

No one can be blamed for some skepticism concerning the artistic merit of generative art. Compared to our popular images of the fine artist painting for hours in her studio, or the metalworker welding metal in high heat, the idea of an “artist” as someone sitting in front of the computer’s blue light, producing pictures at the touch of a keyboard, seems deeply unsatisfying.

A useful resource for understanding the potential of the medium is generative artist Tyler Hobb’s essay The Rise of Long-Form Generative Art. His argument can be summarized as follows:

In the past, generative artists could produce unlimited numbers of outputs, and cherry-pick the best ones for display
Now, since outputs are public and their number fixed, the programs must meet a higher standard of consistency and quality
This has placed significant pressure on artists to produce programs which are both consistently varied and high quality
Veiwers are evaluating both individual outputs, and also how the whole collection expresses an underlying concept

What this suggests is that the constraints that the blockchain places on the medium significantly raises the technical bar for generative art, to the point of approaching the level of challenge we associate with any other legitimate art form. When evaluating a generative art piece, we are both evaluating the artist’s technical skill in producing a program which produces varied outputs of consistent quality, as well as the aesthetics of the individual images and their relationship within collection as a whole, as well as the extent to which the total work expresses an underlying concept of interest.

The fact that only a fixed number of random outputs can exist is the key to the genre. To paraphrase Martin Scorsese’s famous 2019 takedown of the last decade’s Marvel phenomenon, “art must put something at risk.” In the case of generative art, the risk is that despite the artist’s best efforts, the result is largely given by chance. An artist spends days or months developing a program, only to be judged based on random outputs after-the-fact. The giving up of control on the part of the artist, the trusting in the process and in themselves and their abilities, is the beating heart of the genre.

Another easy critique is that the production of generative art doesn’t “look like” making art. This is a red herring, and reveals some important assumptions about art production which should be interrogated.

Recall that early Impressionists were excluded from Parisian galleries on the grounds that standing outside and painting en plein air wasn’t “real” artistic production, when contrasted with their classically-trained contemporaries laboring over individual brushstrokes. What they did was too quick, too easy. And yet, faster painting meant works could be sold at lower prices, bringing fine art to the middle class. And while initially mocked, we have come to see the Impressionists as advancing a new and influential creative form, which innovated not only visually, but economically. There is no reason to believe that we will not come to feel the same about generative art, in ten or fifty years time.

Another influential advocate of generative art is Erick Calderon, a pioneering generative artist and creator of both the ArtBlocks platform and the Bright Moments network of generative art galleries. Described as “your favorite artist’s favorite artist”, Calderon’s years as the proprietor of a tile company has given him a unique insight into the dynamics and economics of artistic production.

In his keynote talk at 2023’s “Outer Edge LA” NFT conference, Erick summarized this progression as follows:

Initially, fine art was “1 of 1”, in which collectors owned unique artworks
Later, art expanded to include “1 of X”, in which collectors owned identical members of a series
With generative art, we have arrived at “1 of 1 of X”, in which collectors own unique members of a series

In Erick’s telling, the drop in cost of the production of individual artworks has not cheapened the value of the work, but rather opened up a frontier for new kinds of work. He gives an example of personalized conference badges, but this only scratches the surface of possibilities, as Calderon rightly identifies our deep emotional needs for individuation and distinction alongside communion and belonging as key drivers of demand for these new forms.

All that said, this does not mean that all generative artwork being created now will be relevant in ten years time, much like the majority of boat paintings made in France during the 19th century are not relevant today. But some certainly will be.

Further, it is not yet clear what emotional modes and moods this art form will best express. The Impressionists found that themes of nature and everyday life were well suited to their new artistic production techniques. To what modes and moods will generative art ultimately be best-suited? The answer remains to be seen.

III. Digital Ownership

A common criticism of digital art can be summarized as “it is meaningless to own artwork which anyone can view”. This critique seems sensible, even self-evident, at first blush but a closer analysis reveals that if anything, it gets things backwards.

To understand why, let’s consider some of the motivations for collecting art.

The first and most obvious motivation would be the pure pleasure of having and observing an artwork. Someone collects something that they love, and displays it in a place of their choosing, enhancing their quality of life. This is an important motivation, but it is naive to think that it is the only one.

The second and arguably more important motivation is the psychological need for individuation, for feeling unique and relevant (and ultimately, safe) in the world. As French philosopher Rene Girard has repeatedly written, our drive for uniqueness is core to social functioning, and as Thorstein Veblen famously observed, people will pay large sums to defend their uniqueness.

Art is culturally relevant, and people collect art because through owning something relevant, they become relevant. But since not all art is relevant, collecting the specific artworks that ultimately become relevant indicates that the collector is perceptive and sophisticated. This is arguably self-evident, judging by how much of the art world is driven by social proof and tastemakers.

With that in mind, we can see why in the domain of cultural relevancy, digital and physical art have very much in common.

Owning physical art gives me the right to restrict access. I can hide it away in my house and prevent anyone from seeing it. Once upon a time, this might have been important, as great works of art were not easy to come by: supply was limited and attention was abundant. But in the 21st century, the logic is reversed. The supply is abundant, yet attention is limited. It means very little to own artwork that no-one cares about.

Ultimately, art collectors are stewards of their art. To buy a piece of art is like adopting a child: the collector takes on the responsiblity of protecting the art, of defending it, of sharing it and of making sure that it is appreciated by the world. Recall: by owning something relevant, you become relevant.

This logic applies not only to speculative collectors looking to preserve wealth (a top predictor of an artist’s value at auction is the number of working artists citing them as an influence), but also to social collectors looking to establish reputations in their communities.

Returning to the question of digital ownership, then, we see how little difference it makes whether the art is digital or physical, and how little difference it makes that “anyone can download a .jpg” of an artwork. To own art, whether physical or digital, is to tell the world that you have good taste and good judgement. To own art, whether physical or digital, is to take responsibility for that artwork’s status in the world.

If anything, and this may be a stretch, digital art has the potential of being more valuable than physical art, as it’s digitally-native nature may make it more amenable to dissemination, and for the universe of digital art to be more continuously in conversation. Digital art has certainly shown itself to be highly suitable to interactive display. But the full extent remains to be seen.

IV. Art Market

For a world as lavish and flamboyant as the art world, it’s markets are famously opaque. Both buyers and sellers express frustration when transacting art, as they are frequently denied information about historical sales and demand. Prices are presented as “take-it-or-leave-it” and pressure tactics run rampant. As colorfully detailed in the Atlantic’s recent profile of Larry Gagosian, art dealers frequently engage in practices which, were they to occur in regulated financial markets, would amount to criminal insider trading.

As a luxury “Veblen” good (one where demand increases, not decreases, with price), one could argue that this opacity is essential, even valuable, in the art market. The more you pay for a piece of art, the more valuable it becomes, and prospect of huge comissions encourages art merchants to throw extravagant parties, creating an art world teeming with life.

The digital art market, on the other hand, is perfectly transparent. With ownership “on the blockchain”, so to speak, everyone knows exactly when an artwork is sold, and for how much, and to whom (to some extent). This allows potential buyers and sellers to know more exactly what they are getting, and limits the ability of middle-folk to squeeze out value while contributing little.

Conventional art dealers might argue that this level of transparency will lead to depressed art markets, or that price manipulation is needed to protect artists from hype cycles over the long term. But with digital squiggles going for tens of thousands of dollars, that seems not to be the reality.

Will the transparency of the digital art market mean an end to the parties? Or will it mean new kinds of people throwing new kinds of parties?

An optimistic view would be that this more transparent art market would lead to new, more productive, value flows. Art dealers would retain their role as taste-makers, with a blunted edge vis-a-vis their most egregious practices. New models would emerge for facilitating the discovery of art, allowing more varieties of people to sustain themselves in the art world. And of course, more could accrue to the artists themselves, allowing them to produce bolder work. How and what, remains to be seen.

V. Conclusions

As with the Impressionists laboring in the French countryside, on-chain generative art represents a new form for visual art. Like Impressionism, this form comes with a new bundle of affordances: a lower cost-of-production, new creative possibilities and constraints, and a certain sensibility and preference of theme, all underpinned by new art-market dynamics.

It is an exciting time, and it will be interesting to see how the story unfolds in the years ahead.

Thanks to dianne weinthal and Eric Rosenfeld for feedback on earlier versions of this essay.

Los Angeles

Sat, 04 Jul 2020 00:00:00 +0000

I. Overture

Los Angeles is a city dreamt into existence. Unlike the great cities of the old world (or even the American east and midwest), which emerged organically around rivers and harbors, supporting trade which supported life, Los Angeles was simply willed into being: in a desert, the product of salesmanship, speculation, and solipsism.

Truly the “postmodern city”, nestled at the edge of the world: it means nothing, and can thus mean anything.

II. Context

In his ambitious and wide-ranging City of Quartz, historian Mike Davis tells the story of early Los Angeles as one of boosterism, with land speculators imagining and selling an image of Southern California to midwestern retirees – leading to a massive internal migration west and making Los Angeles an unexpected bastion of anglo-protestant power. This influx of wealth, earned elsewhere, shaped Los Angeles into a city of consumption, not of creation. It was a place people came to relax and enjoy, not to struggle and create. A consequence of this is of course, the sloth of being too well-fed: a resistance to change, a streak of conservatism, and an apathy towards the (myriad) other which shades and colors Southern Californian politics to this day.

During the first half of the 20th century, when the prime land of the coast was virgin and undeveloped, and “high modernism” the civic ethos of the day, there seemed like nothing more worthwhile than to envision and build entire communities whole-cloth (like the pioneering, and infamous, Lakewood). Water was stolen, and the then-abundance of land obscured the contradiction inherent in its commodification. The American dream was shrink-wrapped and sold, creating vast communities lacking an orienting mythology, propped up by the (then) large and growing defense industry. Unlike other great cities, Los Angeles never had to produce itself.

Culturally, the gravity of Hollywood distorts the arts, its inexorable logic turning creative output towards profit and mass appeal – the experience of which gave rise to noir, the genre of disillusionment. As Davis observes, this unique distortive force is compounded by the city’s relative youth; unlike Paris or New York, Los Angeles lacks the “accumluated patrimony” of successive generations of homegrown cultural movements. Lacking these roots, the cultural topsoil easily erodes, leading to a city of passing fads and weird cults.

There is no one in charge. The monocentric anglo Downtown power structure of the early 20th century gave way to polycentrism, with the newly risen Jewish Westside vying for influence; the California and Jonathan Clubs contending with Hillcrest. Both live in the shadow of international capital, which can enter freely and distort the economic orbits nigh at will.

III. Trendlines

Where to go? What is the future for the postmodern city which means nothing and therefore can mean anything?

The tragedy of Los Angeles seems to be that, despite its abundance of natural beauty, it is a city which consists mostly of non-space, a graph of vital nodes and hostile edges. For somebody plugged in, the city has treasures to offer. But for a physical body in the physical space, there is nothing but heat and asphalt.

Fortunately – even miraculously – we live in an exceptional time, where the ground (to use a perhaps too-apt metaphor for a California city) is shifting beneath our feet. Decades-long trends are reversing, and an imaginative space is opening up. From the perspective of a native Angeleno recently returned after twelve years away, it seems as though we are witnessing the following:

The failure of anti-development Measure S seems to have marked a watershed moment, in which the multi-decade slow-growth wave has begun to break.
The completion of the Exposition Expo train line, and the continuation of Wilshire’s Purple line, points to the increasing effectiveness of the transit lobby.
The ongoing coronavirus pandemic has shattered conventional practices and expectations around work and home, creating space for entirely new (and low-congenstion) patterns of travel.
The recent protests contra police violence, leading to proposals to reduce LAPD funding (defundthepolice) and Mayor Garcetti’s comments that DA Jackie Lacey “might” have to go, suggest a break in the city’s longstanding, unquestioning support for law enforcement.

In these events we see an opening – towards a higher-density, transit-friendly, peaceful city – and what could be the beginning of a transformation from a militarized urban sprawl into a lively urban field. Los Angeles (and America) of the 2020s is not the violent place of the 70’s or 90’s. We live in a more peaceful time, and it is time to begin the work of slowly and carefully taking down the walls of our guarded enclaves and militarized public spaces.

America’s lack of empathy has always been our fatal flaw, but it is never too late to change – and in that change, to revitalize and renew. In the words of the Lebanese poet Kahlil Gibran, “to withhold is to perish”. Ultimately, to borrow a phrase from Lévi-Strauss, the mythic energy of America as a strong and muscular power has been spent. It will not return. We must begin to reimagine our national myth as one of empathy in a time of abundance; only in such a renewal is there hope for a new vitality. There is not so much to fear.

IV. Housing

Housing is where we begin. The remarkable dysfunction of California’s housing market is well-known, but less obvious is exactly why it should be so. Good treatments of the subject matter can be found in City of Quartz, as well as the more recent Golden Gates; here is a summary of the main trends.

California’s housing crisis can be understood as the intersection of a number of forces.

The first and simplest is that we ran out of land. Well, not land per-se, but rather prime, easily-developed coastal farm and ranch land. With a remarkable lack of foresight, early southern California was developed with an aggressive suburban attitude, as large tracts of farmland were divided up and freestanding white-picked-fenced homes were mass-produced and priced-to-own, often purchased by the factory workers drawn by the region’s defense and aerospace manufacturing. When the land ran out – and it did, abruptly, mid-century – it was like a splash of cold water after a night of heavy drinking. Supply froze, and so prices went up… and up.

This seemingly abrupt but basically inevitable housing shortage had the awkward consequence of creating an essentially random distribution of political power. Whoever happened to have bought a home in the “before times” was now a part of an abruptly wealthy and powerful interest group; wealth and power which was predicated on the maintenance of status quo – as evidenced by the passing of the highly regressive Prop 13 in 1978, which reduced property taxes significantly. These peculiar political dynamics are explored by Conor Dougherty in Golden Gates, and he makes the point that much of the state’s housing dysfunction is due to the asymmetry in political power between owners and renters: for any given proposed development, the current residents are well-defined, while the potential future residents are not. Building housing for 100 people in a neighborhood of 50 means fighting against that 50 without the 100 to back you up, since they don’t exist yet.

For any given development, this asymmetry holds, which is why local control biases towards stagnation and “NIMBY”-ism. At the municipal and state levels, however, the political calculus changes, as the renter bloc becomes increasingly politically well-defined – as we saw with the decisive failure of Measure S in 2016, the pro-growth bloc, at least at the city level, has overtaken its slow-growth counterpart. As such, it seems that forward-thinking decisions about California housing will inevitably need to be made at the city, county, and state level – neighborhoods thusfar have been unwilling to do the job.

Central control, of course, is not without risk. As strikingly described by James Scott in his excellent Seeing like a State, too much central control and we risk ending up with high-modernist wastelands like Brasilia and Chandigarh, where shallow notions of visual order and harmony preclude the development of the cozy corners and impromptu interactions which (famously described by Jane Jacobs) form the public good of a vibrant urban life. Balancing central and local control is a problem as old as philosophy, and the only way out is through. Ultimately, we must transcend the consumptive retiree mentality and the intense class and racial divides and individually acknowledge the city as a commons, the obligation to which there is no individual exit. To fail in this recognition is to sign up for a long and losing battle, propping up failing levees in a storm.

How, concretely, can we move forward? Culturally and politically, we were unprepared for the abruptness of the crisis, leading to a series of questionable policy choices (along with Prop 13, we have in the 1950’s the emergence of similarly regressive “contract cities”), which functioned ultimately to shift tax burdens from the rich to the poor, the legacy of which we live with today in the form of underfunded city services and high consumer taxes. Where from here?

One idea, too radical for this moment but something to keep in the back of our minds, is the elimination of single-family zoning in its entirety. New York, considered by many one of the most exciting and dynamic cities in the world, famously included no single-family zoning at all in its 1916 zoning plan. California, with its imaginative legacy of the “open west” will need to make some mental shifts and appreciate that it is time to do the same. The market will put the suburbs where they belong.

A second idea, also ambitious but slightly more practical, is the joint repeal of Prop 13 and the elimination of rent control. It is crucial that they occur together, as these two programs represent the yin and yang of housing misallocation: Prop 13 suppresses the cost of ownership by suppressing property taxes, while rent control supresses the cost of renting by suppressing rent. In both cases, skewed incentives discourage movement and invariably result in individuals living alone in three-bedroom apartments or five-bedroom houses, while a few streets down, families of five share a single room. Removing one without the other would be rightly seen as classist – pro-owner, pro-renter – but removing them together makes sense.

Realistically, we should proceed with incremental zoning changes, along the lines of SB 50. Here Scott Weiner seems the one to watch.

Ultimately, it is possible to believe in the value of home ownership without needing homes to be speculative assets, and nowhere are we guaranteed a fixed, unchanging urban landscape.

V. Transportation

Housing changes, of course, are impossible without corresponding changes in transportation; they support and enable each other. How we get around determines where we live, and where we live determines how we get around. Density and transit are like two wings of a bird – without them both, it cannot fly.

Ultimately, the Los Angeles of low-slung sprawl is over. It is not wanted or needed. The long parched boulevards of single-story (often auto-focused) retail must be reimagined and rebuilt as two to three story mixed-use districts. There is no need to erect skyscrapers and block out the sun, but new usage patterns which allow for street life on all (or at least, most) of the streets is essential. Rather than separating residence from commerce via tremendous distance, instead mix them more often together, allowing a higher density of residence to support a wider variety of retail and commerce, and breaking the suffocating strangehold of the car on the city. There is nothing wrong with taking a car to see a friend or to go to a show (discretionary, irregular activities well-served by ride-sharing), but having to take a car to buy milk or a sandwich seems more and more like a tragedy – in which we build more housing for cars than we do people, and high costs of housing subsidize our so called “free parking”.

Ultimately, rather that inhuman distances necessitating personal cars for quotidian activities, we would like a gradation of distances for different activities, with the proximity of goods and services being directly linked to the frequency of their need. Daily essentials should be accessible by foot; infrequent needs met by rideshare or bicycle. Owning a car in Los Angeles must become an option, rather than a necessity, for a significant part of the population.

Curiously, the coronavirus presents us with a rare opportunity in this regard. With surge in people working-from-home, the country’s entire private sector is learning just how little a daily commute is needed to run a successful organization. Certainly, video conferencing can never fully replace in-person, face-to-face interaction, but for many people, a lot of the time, it is unneeded. Making a guess, we should expect a permanent post-virus reduction in the amount of time spent in an office of anywhere from 10-20% – leading to a corresponding drop in commute days. If 1/5 of workers spent any given workday in their residential neighborhood, rather than commuting to a commercial center, we would simultaneously see a drop in road congestion and demand for parking in these commercial centers, while seeing an increase in demand for business (food, retail, etc) in the residential neighborhoods. More demand for business in the residential neighborhoods means more business density, which will make these neighborhoods more pedestrian-friendly. Overall, a greater uniformity of population distribution over the course of the day (vs. large daily migrations from residential to commercial center and back) allows for a wider variety of businesses to thrive over more of the city’s area, reducing the need to cover large distances on a daily basis.

With fewer cars on the road at any given time, alternative modes of transit can be set up for success. Taking cues from other cities, we can permanently designate certain boulevards bicycle-and-pedestrian only, doing for cyclists and pedestrians what Robert Moses did for Long Island’s beachgoers – giving them pleasant, relaxing ways to get around (and with great opportunities for sidewalk dining). In fact, we have already begun. Fewer cars on the road means more opportunity for dedicated bus lanes, which, if run properly, represent an invaluable supplement to the city’s earnest-but-outmatched rail system, allowing us to provide effective transit beyond the city center.

That said, access to a car is a great convenience, and ride-sharing and one-off rentals can be expensive and are impractical for, for example, camping trips. An easy proptech-adjacent entreprenial solution would be to offer “shared-cars-as-a-service”, where groups of people can subscribe to a personal car. The subscription would include normal maintenance and a group driver’s insurance policy, and gas usage would be tracked and the costs distributed automatically. That or something like it would fill an important niche very nicely, allowing two or three cars to meet the needs of perhaps six or ten people living in proximity.

As an aside, Los Angeles could be a cyclist’s paradise. It is relatively flat and the heat is dry, not humid, making cycling suitable for daily use by professionals (no working up a sweat). If the city’s ameneties and points of interest were more evenly distributed (as they will likely become), the addition of one or two cyclist-friendly east/west boulevards could greatly expand the potential of cycling in the city. Imagine if Olympic Blvd was reduced to two lanes of car traffic, freeing the rest for a large, protected bike path – crossing the city would be a breeze. And if that same boulevard were lines with residences, eateries, and light commercial spaces?

One could argue that a long-term coronavirus-related reduction in driving would make transit less relevant, rather than more, as it would be consequently easier to get around by car. While there is likely some truth to this, congestion remains half the equation, with parking being the other. As long as every Angeleno needs a car, parking subsidies will continue to be built into the costs of housing, exacerbating the city’s housing affordability crisis. We must seize the opportunity to build transit back into the city.

As memorably put by technology investor Ben Horowitz, “there are no silver bullets, only lead ones”. No single intervention will solve Los Angeles’ substantial transportation problems, but a variety of interventions can interact to provide an effective multi-modal transporation grid. A multi-modal transporation grid allows for more heterogenous movement patterns, meaning the load on any system is reduced – but if everyone has to drive, we could build freeways for one hundred years and never get the capacity we’d need.

VI. Outro

As mentioned in the introduction, Los Angeles is a postmodern city – a product of idea more than of material. While at first blush this might seem like a weakness or fatal flaw (“a meaningless city”), it may yet be the city’s great strength, as a postmodern city can more easily be imagined and re-imagined again.

There is an opportunity to re-imagine Los Angeles, not as a harsh urban sprawl, but as a vital urban field. A city where a density of variously-priced residences, spread throughout the city, supports a vibrant commercial life throughout. A city where lush, pedestrian-and-bicycle boulevards complement light rail and well-run protected bus routes to make getting around the city easy and pleasant (complemented by ride-share and – gasp – even some car ownership).

This is not wild speculation – much of this, at least directionally, is happening now.

Further, there is a chance to make the postmodern city – one of the most diverse on earth – into a racially integrated city, and to continue to take steps to heal the racial divides which sit at the very heart of American identity. Here again the postmodern city shines – for where else can old and tired myths be reimagined and renewed? Can we find the courage to take funding away from security and from fear, and to put it towards culture and creation? And while we’re at it, make peace with the towns upstream whose water we stole?

None of these aspirational outcomes, of course, are guaranteed. But they are possible. The trendlines are all there. With vision, leadership, courage, and fortitude, they may even be achievable. And that is something.

Selected Sources

Sharing the Wealth

Sun, 19 Apr 2020 00:00:00 +0000

This essay was originally prepared for a London-based zine on gentrification.

Smoother residential gentrification through shared ownership

From the moment early man first pointed to the ground and said “mine”, we have fought for control over land. For most of our history, this conflict involved bloody violence; in recent decades, however, economic conflict has replaced physical, and “pirate raid” is replaced by “pricing out”. It is right to interpret this as progress, for it is – and to recognize that competition over land has never been absent from the human experience.

The question is not one of “stopping gentrification” – it is intellectual laziness to conclude that our perennial competition to occupy land can be permanently stopped through some perfect policy – but rather one of best managing its energies. Here we can have hope: while a river cannot be stopped, a well-built dam can be a source of tremendous power.

Why do we view residential gentrification – the claiming of land from the less affluent by the more affluent – as “bad”, a social ill to be prevented? Surely it is not the basic experience of change, as change is as constant as breathing. No, we view residential gentrification as bad because, the logic of capitalism aside, home is an emotional sphere which exists outside and apart from the market, even while the physical space remains embedded within it. As Karl Polanyi says in his seminal The Great Transformation, there exist three “fictitious commodities”: land, labor, and capital – which we embed in markets, even though truly markets are embedded in them. We should place housing in this category also.

Unfortunately, recognizing home as a fictitious commodity does not solve the underlying problem, as we lack a better alternative for resolving conflict for the underlying land, as nationalized land ownership and rent control – two possible strategies – come with their own pernicious costs: a loss of freedom in the former, and chronic misallocation in the latter. This recognition is valuable, however, in that it suggests that there may be more to the social contract. If we accept that people may always have to leave, the question becomes one of “what does leaving look like”? And here we can find answers and inspiration.

What happens when a neighborhood gentrifies? The prices go up. Rents increase, goods and services become more expensive, and the value of land and property rise. To whom does this value accrue? Overwhelmingly, the landowners. This is the problem: the residents, who participated in the creation of the neighborhood (by living their lives, raising their families, and supporting local businesses), receive none of the upside. To transform the experience of residential gentrification, we must find a way to transfer some of this new value from the landowners to the residents. Being priced out of your home is an unfortunate but sometimes unavoidable reality. What is not unavoidable is walking away with nothing. The emotional experience of gentrification would be very different were a family to walk away with tens of thousands of dollars – or more – to start a new life.

Simply: tenants should receive partial ownership of their buildings, as a function of the duration of their tenancy. This partial ownership recognizes the role the tenants play – as the fabric of the community – in creating the value that is currently captured entirely by landowners. One scheme would be to set aside 20% of the building’s increase in value for tenants (much like companies often set aside a percentage of their stock aside for employees), and to distribute these to tenants as a function of tenure – say .2% per year. After ten years, a tenant can claim 2% of the increased value of the building. If the value of that building increases by $1,000,000, that tenant receives $20,000.

There are many ways such schemes could be implemented. One approach involves landlords adopting a policy where, every ten or so years, they “buy out” their tenants at the then-appraised value. Another approach involves tenants redeeming their shares against future rental income. If I spent a decade in a neighborhood paying $1000/mo, and then get priced out at $1500/mo, then I could claim a percentage of these higher rents over a period of several years – an empowering passive income stream for a class which has historically struggled to accumulate capital.

It is reasonable to wonder why landowners would ever agree to such a scheme, absent a significant social movement to force new legislation. The answer is that it aligns the incentives between landowners and tenants, by giving tenants a reason to “think like owners”, resulting in better-maintained and more beautiful living spaces. The contemporary landlord-tenant relationship is toxic, with each party encouraged to extract as much value as possible from the other. Neither party is incentivized to invest in the improvement of the property: the tenant does not because they capture none of the value, and the landlord does not because it cuts into their short-term bottom-line. Under a scheme in which the upside is shared, the tenant knows that they will be able to capture some of the upside associated with their contributions, and the landlord knows that the tenant will be motivated to take care of any improvements – saving the landlord in maintenance costs and real, but hard-to-price, emotional conflict. While it may seem outlandish to contemplate, a scheme like this would increase the quality of landlord-tenant relationships, the way in which landlords are viewed by society, and the quality of our living spaces – a win-win-win.

Absent some radical new development in law or philosophy, we should view gentrification as a fact of life, much like death and taxes. The productive train of thought is not how to “stop” gentrification, but rather how to shape the process. Here we propose a shared-ownership scheme which aligns the interests of landlords and tenants in a way which takes much of the bite out of gentrification, and allows the tenants, who may inevitably find themselves needing to look for a new home, to walk away with something substantial – wealth which can be invested in new neighborhoods and new communities. This new type of windfall will transform the emotional experience of residential gentrification (a key aspect of gentrification writ large) from one of powerlessness to one of agency in the face of change, and represents an important step forward in urban policy.

A Review of 'Gaming the Vote'

Sat, 04 Apr 2020 00:00:00 +0000

I. Introduction

Some months ago I read William Poundstone’s Gaming the Vote, a comprehensive survey of the history and attributes of various alternative voting systems – a topic of longstanding personal interest.

The villain of Poundstone’s story is the plurality vote, a fair-seeming but perniciously flawed way of choosing leaders, and Poundstone devotes fully the first third of the book to a survey of the method’s myriad historical vailures. The remaining two thirds are a survey of the alternatives, and a discussion of their own (inevitable) achille’s heels. Poundstone considers, in turn, the classic methods of Borda and Condorcet, the more recent innovations of Instant Runoff Voting and Approval Voting, and concludes with a bullish assessment of Score Voting as the “least worst” option. Along the way, we meet (among others) the idealistic Marquise de Condorcet, the obsessive-creative Charles Dodgson (Lewis Carroll!), and of course, Kenneth Arrow, our axis mundi.

Let’s now review the various electoral sytems (as we will see, each has a fatal flaw), and then hone in on a number of points where I think Poundstone’s argument can be extended or corrected.

II. The Voting Systems

Plurality Voting

What: Voters submit single votes; the candidate with the most votes is the winner.
But: Susceptible to vote-splitting, leading to the election of minority candidates (the “spoiler effect”).

Plurality voting (also known as “first-past-the-post”) is an electorical system in which voters cast a single vote for their preferred candidate, out of an arbitrary pool of candidates. The votes are summed up, and the candidate with the most votes is elected.

While simple and fair on its face, the critical flaw of the plurality vote is that when there are more than two candidates, often the larger group (the “majority bloc”) will find themselves choosing between two candidates, while the smaller group (the “minority bloc”) will have only one. In this case, the majority bloc, which should be the one to choose the candidate, will end up losing to the minority bloc. In concrete terms, if the majority bloc is 60% of the vote with two equally-popular candidates (Alice and Bob), then the minority candidate (Charlie) will win with 40% of the vote, while the two majority candidates will each take 30% of the vote and lose the election. Note that no candidate won a majority of the votes, a reasonable standard for legitimacy.

In real-world elections, a more common occurrence is that the majority and minority blocs are more closely matched (say 52% vs 48%), and a fringe candidate comes in to pull ~5% of the vote from the majority candidate, handing the victory to the minority bloc – the “spoiler effect” phenomenon which famously sent George Bush to the White House in the 2000 United States presidential election. In addition, Poundstone discusses the recent practice (as of the last few decades) in which minority blocs explictly encourage this phenomena by descreetly funding fringe candidates to challenge their majority opponent.

From a theoretical perspective, the key limitation of the plurality vote is that a voter is unable to provide sufficient information about their preferences. In many cases, voters who vote for a fringe candidate would still prefer the majority candidate to beat the minority candidate, but this type of “second choice” information is unavailable to the election algorithm. As we will see, the common theme of every other system Poundstone describes is their attempt to incorporate this additional information (with variously mixed results).

The Borda Count

What: Voters submit ranked lists, with candidates receiving more or less votes depending on their position. The candidate with the most votes is the winner.
But: Susceptible to tactical voting (“burying”), which can lead to the election of unintended candidates.

The Borda count is a method which attempts to avoid the flaw of plurality voting by allowing voters to convey their preferences not only for their first choice, but for all the candidates, by submitting a ranked list. Known appropriately as a “ranked choice” method, the Borda count assigns a numeric score to every candidate based on their position in the list (i.e. for the list “Alice > Bob > Charlie”, Alice gets two points, Bob one, and Charlie zero).

The Borda count thus avoids the spoiler effect by allowing multiple candidates to “share” the support of their bloc, in such a way that one of the majority candidates should prevail over the minority. To return to our earlier example, say that Alice and Bob are equally-popular candidates for the 60% majority bloc, while Charlie is the sole candidate for the 40% minority bloc. With the Borda count, each of Alice and Bob will receive a score of 30 * 2 + 30 * 1 = 90, while Charlie will recieve a score of 40 * 2 = 80. If we assume some small amount of randomness such that an exact tie is avoided, one of either Alice or Bob will win.

However, the Borda count’s flaw is that by assigning scores to individual candidates as a function of the number of total candidates, it makes it possible to create “artificial distance” between candidates (i.e. to create a distance of “two” between Alice and Bob, simply by the presence of Charlie). This ability to create distance between candidates leads to the phenomenon of “burying”, a type of strategic vote where strong candidates are ranked “artificially” low.

In extreme cases this can lead to unexpected candidates being elected. Consider an example of Alice, Bob, and Charlie, where Alice is the majority bloc candidate (60%), Bob is the minority bloc candidate (40%), and Charlie is a moderate. With plurality voting, Alice would easily win. But under the Borda count, the minority bloc can vote strategically to put Charlie in office: if the majority bloc ranks Alice, Charlie, and Bob, then the minority bloc can vote tactically, falsely putting Charlie as their top candidate (and Alice last). This would lead to a Charlie victory with a score of 40 * 2 + 60 * 1 = 140 vs. Alice’s score of 60 * 2 = 120.

Theoretically, the problem is rooted in the ability to create absolute (numeric) distance between a pair of candidates, compared to simply relative distance, as a function of something other than the pair of candidates themselves (in this case, the number of candidates total). The number of candidates in the election should not be able to affect the relative preferences of pairs of candidates (where the majority prefers Alice to Charlie), but in the Borda count it does. Another way to frame this limitation is that the Borda count provides no way to express non-uniform “distances” between the candidates – the psychic “space” between Alice and Bob is assumed to be just as large as that between Bob and Charlie. This can be understood as a type of information-theoretic noise caused by the measurement not quite fitting the thing being measured (this will be a recurring theme).

The Condorect Winner

What: Voters submit ranked lists, which are translated into pairwise contests. The candidate which defeats every other candidate, pairwise, is the winner.
But: No guarantee of transitivity, i.e. a winner might not exist.

The Condorcet winner is the candidate who would beat every other in a two-way contest. This method attempts to both avoid the spoiler effect and the problems of the Borda count by allowing voters to submit multiple preferences without creating artificial distances.

To return to our opening example, in an election where Alice and Bob are majority candidates and Charlie is the minority candidate, both Alice and Bob will beat Charlie (60/40), and then Alice and Bob will themselves face off in what will amount to a 50/50 split (with some small randomness breaking the tie). This method solves the problems of plurality voting by allowing for the incorporation of the information that 60% of the people would prefer Alice and Bob to beat Charlie, while avoiding the problems of the Borda count by never casting relative preference to absolute (i.e. if I prefer Alice to Bob, ranking Bob last doesn’t make Alice beat him by “more” as long as he is ranked after Alice).

The problem with this method, however, is that the Condorcet winner may not exist. Consider a scenario with three equal-sized blocs (and three candidates), we may find ourselves in a situation where Alice beats Bob by 2:1 (i.e. bloc A and C both prefer Alice to Bob), but Bob beats Charlie 2:1 (i.e. bloc A and B both prefer Bob to Charlie), but Charlie beats Alice by 2:1 (because bloc B and C both prefer Charlie to Alice). This can be written as:

Bloc A: Alice > Bob > Charlie
Bloc B: Bob > Charlie > Alice
Bloc C: Charlie > Alice > Bob

This creates a rock-paper-scissors situation known as a “cycle” (draw it as a graph – or scroll down – to see why), and there is no winner. Obviously it is problematic if there is “no winner” in an election, and so this is seen as a flaw in the method. Defenders of Condorcet methods say that cycles are rare in practice (it requires a particular “arrangement” of candidates and voters), and so the concern is over-blown (compared to the type of failures which can occur in the Borda count and plurality votes, which are much more common).

From a theoretical perspective, the problem here not the lack of information, but rather that the algorithm cannot “see” all the information that is there. As we will learn later, there are other techniques which can see this information and break cycles in a fair way.

Instant Runoff Voting

What: Voters submit ranked lists. An iterative algorithm re-allocates votes until a clear (majority) winner emerges.
But: The algorithm is “non-monotonic”: giving a candidates more votes can cause them to lose. Also, popular second-choice candidates may be eliminated too early.

Instant Runoff Voting (IRV) is an interesting beast. Unlike the other methods, which run in constant time, IRV is iterative: it runs in a while loop, rearranging votes until one candidate has a majority of first-place votes. Like the Borda count and Condorcet winner, IRV attempts to make second-choice votes meaningful by successively eliminating last-place candidates, reallocating votes to second (or third or fourth!) choices in the event that an eliminated candidate was a voter’s first choice. Returning to our opening example, consider the case where Alice and Bob split the 60% majority bloc’s vote down the middle (alternating as first and second choice on the ballots), while Charlie takes all of the 40% minority bloc’s votes. In the first round of the IRV algorithm, either Alice or Bob will be eliminated (having the fewest votes, ~30%, versus Charlie’s 40). Let’s say that Bob is eliminated. Now, since every voter who ranked Bob first ranked Alice second, all of Bob’s votes will now be transferred to Alice, giving her 60% of the vote and a majority victory.

IRV has proven to be popular in practice, gaining traction in governments and municipalities around the world, in part due to the intuitive nature of the algorithm making the process easy to understand. Among contemporary advocates for voting reform, IRV has become one of the most popular options (rivaling Score Voting). However, IRV is not without flaws. The essential problem with IRV is that it is, in mathematical speak, “non-monotonic”. A “monotonically increasing” function is one which is always either staying the same or increasing, but never decreasing: for IRV, the “non-monotonicity” means that giving more votes to a candidate can actually cause them to lose, a troubling phenomenon which does not appear in any of the other systems considered. Also, the nature of the IRV algorithm means that the most broadly popular candidate may still lose. To see why, consider the case where the population is split 50/50 for Alice and Bob, with Charlie being a universally-popular second choice. Charlie seems like the natural best choice, but because he receives no first-place votes, the IRV algorithm eliminates him in the first round, resulting in a deadlock between Alice and Bob – exactly the situation we would hope IRV would avoid.

Approval Voting

What: Voters submit a binary approve/reject per candidate. Votes are tallied according to plurality rules.
But: The ambiguous semantics of “approval” means that winner of the election can be hard to predict.

The Borda count, Condorcet winner, and Instant Runoff Voting all fall under the category of “ranked-choice voting” systems: they are all different algorithms which operate on the same measurement, that of a relative ranking of candidates. Approval voting (and its cousin, score voting) are fundamentally different animals, in that their primary representations are not relative, but absolute. As we will see, this approach will spare these methods from many of the flaws of their relative brethren, but introduces pernicious problems of its own.

Approval voting can be thought of as a generalization of plurality voting, but where instead of voting for one candidate, you can vote for as many as you like. This prevents the spoiler effect by allowing second-choice candidates to receive votes alongside the first-choice candidates. This also removes the benefits of voting strategically, since the sincere vote is the optimal vote. Recall Alice, Bob, and Charlie. With approval voting, both Alice and Bob will receive ~60% of the vote, compared to Charlie’s meager 40%. Some small randomness will ensure that one of Alice and Bob is elected, to the satisfaction of the majority bloc.

Unfortunately, the ambiguous semantics of “approval” (what is the standard by which someone is “approved”?) means that, contrary to expectations, mediocre candidates can prevail over strong candidates. Consider a situation where Alice is beloved by 60% of the population, Bob beloved by the other 40%, and Charlie seen as a bumbling but endearing candidate whom no-one takes seriously, but no one dispises. With approval voting, it is possible that more than 60% (potentially up to 100%) of the population will “approve” of Charlie, on the grounds that, from the perspective of each half of the population, Charlie isn’t a bad candidate. As a result, Charlie wins the election – an unintended outcome. More fundamentally, depending on how voters interpret “approval”, the same ranked-ordering of candidates can lead to different election outcomes – a phenomenon known as “indeterminacy”.

Observe that, under a Borda count, Alice would win the election, since a first-place vote from 60% of the population is worth more than a second-place vote from 100% of the population (2 * 60 > 1 * 100). With approval voting, the inability to represent the underlying relative distinctions leads to the measurement error manifesting as indeterminacy. Said another way, by treating the candidates as unrelated in the model, the base concept of “approval” decoheres and loses definition as relativity inevitably re-inserts itself.

Score Voting

What: Voters submit a numeric score per candidate. Votes are tallied according to plurality rules.
But: The ambiguous semantics of “scoring” means that winner of the election can be hard to predict.

On the surface, score voting arrives on the scene as the funnier and more handsome cousin of approval voting. Rather than precluding any expression of relative preference, score voting permits the assignment of real-valued scores to each candidate, allowing for implicit relative preference. Further, the ability to use a fuller range allows voters to avoid the false “uniformity of differences” which hounds the Borda count.

Unfortunately, this merely kicks the can down the road – it turns out that numerical scores vary as a function of the candidates just as much as binary “approvals”. Consider a beloved Alice, a well-meaning Bob, and a chicanerous Charlie. A voter might give Alice a 1, Bob a .6 (indicating their positive sentiment), and Charlie a 0. Say Charlie is indicted for fraud and drops out of the race – what happens to Bob’s score? The voter wants Alice to win, and giving Bob a 0 maximizes those chances. So we see how Bob’s score, real-valued as it is, decoheres just as much as “approval” does with binary votes. Fundamentally, the voter has no “score” for Bob, only a relative sentiment vis-a-vis Alice and Charlie. In line with our theme, we conclude that the use of real-valued scores is a mirage, providing an illusion of information.

Apart from this, score voting is subject to the same quirks as approval voting, and so there is no need to recount them here. And of course, as with all systems described here, the existence of these types of failure conditions in principle says little about the frequency with which they will be encountered in practice. All of these systems work well most of the time, which is good enough, most of the time.

III. Generalized Relativity

The Confounding of Condorcet

Let us now take the ceremonial potshot at our bugbear, the Independence of Irrelevant Alternatives (IIA) – the most frustrating of Arrow’s criteria. Consider the example on page 225 of Gaming the Vote:

Three candidates (here, Clinton, Bush, and Perot) run in a ranked-choice election with a Condorcet winner. The first ballots arrive:

Clinton > Bush > Perot (30 million)
Bush > Perot > Clinton (30 million)
Perot > Clinton > Bush (30 million)

This leads to the following graph:

As we can see, we have a nightmarish cycle in which each candidate wins and loses by a landslide, and there is intuitively no winner. With this voting data, no system could declare a winner, as the information simply does not exist. Now, additional ballots arrive:

Bush > Clinton > Perot (20 million)
Clinton > Bush > Perot (15 million)

This leads to the following graph:

Now we have sufficient information to declare a winner – but who?

As Poundstone points out, the new votes favor Bush, and yet – despite a folk moral arithmetic implying that a tie plus a victory equals a victory – Clinton is the Condorcet winner. Yet Clinton’s Condorcet victory hides the landslide victory that Bush holds over Perot – much more decisive than Clinton’s meager margin over either. It feels to us that this one landslide means more than Clinton’s two narrow victories. We spectators, with our “artist’s eye” (to borrow a term from Paglia) can “see” the relevance of this background victory to the larger picture, but the simple “machine mind” of the Condorcet algorithm cannot.

Of course, not all is lost – the information is there, clearly – we can see it. Condorcet cannot, but it turns out that Borda can. In this setting the Borda count would “see” Bush’s victory – with a count of 145 million compared to Clinton’s 140. Of course, that the Borda count is “right” in this case does not mean that it is better – as we have discussed earlier, each algorithm can “see” only certain facets of the world – and in this case, the Borda count is the machine that sees the right things.

There are more recent techniques, such as Power Ranking (the method famously underlying Google’s PageRank), which mix the numerical aspect of the Borda count with the graphical approach of of the Condorcet winner to produce compelling results, and remains on the cutting edge of applied social choice with numerous applications under active development. As promised earlier, Power Ranking is a technique capable of breaking Condorcet cycles, “spinning the wheel” to leverage more of the available information.

There is no algorithm which can fully attain the “artist’s eye”, for the same reason that there is no way to fully express a feeling. However we can get closer, and insisting on representations which as closely as possible reflect their underlying world is the start. If all mental concepts are fundamentally relative, we should stop pretending that they are not, and include relativity explicitly (and thoughtfully) in our models – before it sneaks in unnanounced. All alternatives are relevant. The two words are nearly anagrams, clearly there is a cosmic joke being played here.

Signal and Noise

Continuing our theme, let’s turn to another example in Gaming the Vote, the discussion of the infamous “Hot or Not” (chapter 14). Hot or Not, as Poundstone remembers, was (is?) a website in which people can upload photos of themselves, and have the good people of the internet submit judments as to the photo’s attractiveness, which ultimately Poundstone holds up as an example of the efficacy of score voting. Quoting directly (Poundstone, 247):

[The creators, Hong and Young] considered having visitors pick their favorite of two on-screen photos. A photo would win points for each time it was preferred over another, random photo. This would loosely simulate a Borda count. (In a true Borda count, a candidate wins a point every time a voter ranks her above a rival. No Hot or Not voter could rank all the millions of pictures on the site, of course. The aggregate effect of random visitors ranking random pairs would be similar.) However, when shown two photos that hapen to be of roughly equal attractiveness, “people will look at the pictures and not know,” Hong said. “They have a harder time deciding.”

Hong and Young also considered a simple “hot” or “not” vote on a single picture. This would be an approval vote. There it was “average” Joes and Janes which slowed things down. People would have to ponder whether to click “hot” or “not”. Range voting was faster. It seemed to require less thought. “Sometimes people can’t even express the number,” Hong explained, “they just have a feeling and like having that bar: ‘ah, it’s kinda like here.’” They position the cursor where it feels right and click.

This is a valuable history which deserves closer scrutiny, through the analytical eye of information theory.

First, some definitions: note that a single pairwise preference (“A vs B”) can be represented in one bit (0 for A, 1 for B). So too can a binary “hot or not” (0 for “not”, 1 for “hot”). A real-value, on the other hand, requires more bits – for argument’s sake, let’s say 3 bits for an 8-point scale (000 gives a 0, 111 a 7, and the rest in-between). The axioms of information theory tell us that a digital “bit” can contain up to one “bit” of information (the relationship between the digital bit and the information bit being governed by the mathematics of entropy – in the classic example, the outcome of a fair coin is exactly one bit of information, while the outcome of a loaded coin is always a little bit less).

Here, we see that score voting yields 3 bits of data, while a binary “hot or not” vote yields 1. Yet, bizarrely, it is easier for users to provide more data rather than less – suspicious. While we cannot prove which measure yields more information (as this requires access to the ineffable truth, which we lack), this juxtaposition should make us wonder how many bits of information we’re really getting in those 3 bits of real-valued scores – likely, it is less than the (up to) 1 bit we get from the binary “hot or not”.

Historical experience supports my argument. Poundstone mentions at the beginning of the chapter that, among others, YouTube uses 5-point scores for their videos. However, as discussed (in some of my work) here, YouTube (along with Netflix) have since dropped the 5-point system in favor of a binary like/dislike, on the grounds that the 5-point scale ultimately provided very little signal above and beyond what was gleaned from a like/dislike, and thus introduced mostly noise.

That it is “easier” for users to provide 3 bits tells us little about the quality of the measurement – it is the easiest thing of all to submit a random number, containing no information at all. Is not the amount of data, but the ratio of data to information, that we should care about. It is difficult decision processes that produce information-rich results.

IV. Conclusion

The foundation of science is the assumed validity of independent repetition – the idea that things which occur in the future are like things which occurred in the past, and that the things that we observe occur somewhat independently of one-another. This allows us to, for instance, re-run experiments, test theories, and to develop re-usable mathematical models of the world. Unfortunately, this assumption is, at base, incorrect. Historians know that, while we conceptualize history as a series of interconnected-but-separate episodes, in which the past contains clues about the future, the deeper truth is that history is one, single event, in which every moment is intimately and inextricably wound up with every other, and no differentiation can occur. This reality is more felt in some cases than others. The natural sciences, for one, can often get away with strong assumptions of independence (protons behave largely the same in 21st century California is they did in 10th century China). In art history, this is less true – it is virtually impossible to understand the behavior of English painters in the 19th century without understanding the Italian sculptors of the 15th. The social sciences (and by extension, voting systems) sit, somewhat frustratingly, in the middle.

In many cases, assumptions of independence are necessary to make problems tractable. Fortunately, this is not the case here. There is room in the field of electoral systems and social choice to incorporate notions of relativity alongside notions of psychic intensity, and to develop algorithms which leverage the information encoded in both. Doing so will allow our mechanisms to sit closer to the “reality” of our experience and thus yield more consistently legitimate outputs – a worthy aim in the quixotic quest for better tools of freedom.

A Mild Critique of Quadratic Funding

Fri, 13 Dec 2019 00:00:00 +0000

This essay is meant as a mild and constructive engagement with one part of the constellation of ideas being advanced under the aegis of RadicalxChange (pronounced “radical exchange”), specifically the concept of quadratic funding, and it’s claim to “optimality”. Let’s review the argument and then assess the strength of that claim. This will involve a few equations but I’ll narrate the whole thing so it shouldn’t be too hard to follow (or just skip to the critique).

A Review

From the “Liberal Radicalism” paper, we have the following notion of social welfare:

\[\sum_p (\sum_i V_i^p(F^p)) - F^p\]

Here, $i$ is a citizen in a society while $p$ is a public good in that society. $c_i^p$ (which shows up later) is the amount of money that citizen $i$ gives to good $p$, whle $F^p$ is the total amount of funding that good $p$ receives. $V_i^p(F^p)$ is the “currency-equivalent utility” that citizen $i$ receives if good $p$ is funded at level $F^p$. Pay extra special attention to the term currency-equivalent utility because it is the hinge of the critique. With these definitions, the equation is straightforward: social welfare is the sum of all individual utilities across all public goods, less the total cost of those goods. Pretty reasonable.

Now, the authors (Buterin, Hitzig, and Weyl) use this equation to show why two existing systems, namely capitalism and one-person-one-vote democracy, lead to suboptimal allocations, while their quadratic methods lead to optimal allocations. An important concept in their argument is the first derivative of the individual utility function, $V_i^{p\prime}$. This tells us how much value citizen $i$ gets from the next dollar which funds the good $p$, i.e. the slope of the curve.

For an optimal allocation, we would expect that the first derivative of the total utility for a given good (summed across all citizens) would be equal to 1, meaning that society as a whole has reached the point where giving more funding to the good would create less value than the funding itself, i.e. $V^{p\prime}(F^p) = 1$. At that point, funding should be placed elsewhere.

Now, under capitalism (the system where all contributions to public goods are made by citizens in isolation), otherwise known as $F^p = \sum_i c_i^p$, citizen $i$ will contribute to a good up until the point where their individual increase in utility is worth what they contribute, i.e. where $V_i^{p\prime}(F^p) = 1$. The problem here is that there is a lot of utility that ends up being “left on the table” – even if an extra $1 of funding can create $.5 of utility for three people (i.e. $1.5 of utility for society), no one will provide that funding since from the perspective of the individual, they are giving $1 and getting only $.5 back in value. Formally, this looks like $V^{p\prime}(F^p) > 1$, i.e. putting in more money will create more utility for society, but no one does it. Sad.

Under one-person-one-vote (1p1v) (the system where citizens vote on alloctions), otherwise known as $F^p = N \cdot \text{Median}_i V_i^{p\prime}(F^p)$, the problem is different. Here, the issue is that since the utility is determined by a majority vote (i.e. by the “median voter”), the allocation will be suboptimal to the degree to which the median voter differs from the average or mean voter. Note the appearance of the term mean here, because it sets the stage for (drumroll please) the quadratic methods.

Recall that the median is a measure of centrality which ignores degree of intensity, while the mean is exactly the measure of centrality which incorporates it, i.e. the mean minimizes the square error of itself to all the data points (while the median minimizes the absolute error).

Enter quadratic funding (the system in which the total contribution is the sum of the roots of the individual contributions), otherwise known as $F^p = (\sum_i \sqrt{c_i^p})^2$. Unlike capitalism, in which individuals contribute up until their utility matches their contribution, quadratic funding allows people to contribute until the total utility matches their contribution. We’ll look at the derivation because it’ll be instructive. Starting with the individual’s utility function, $V_i^p(F^p) - c_i^p$, we maximize by taking the derivative and setting to zero (involving several applications of the chain rule), which gives us:

\[V_i^{p\prime}(F^p) = \frac{\sqrt{c_i^p}}{\sum_j \sqrt{c_j^p}} \leq 1\]

This is an odd looking fraction, but note that it is less than (or equal to) 1, and equals one when you sum across all citizens. That is the voilà moment for quadratic funding:

\[V^{p\prime}(F^p) = \sum_i(\frac{\sqrt{c_i^p}}{\sum_j \sqrt{c_j^p}}) = 1\]

While capitalism provides funding up until individual utility matches the increased funding, quadratic funding provides funding up until the collective utility matches the increased funding, which is optimal. This is a great result and a source of legitimate excitement.

The Critique

But (and finally, we reach the critique), let us recall the key assumption of the model: individual (subjective) utility, $V_i^p$, is assumed to be both known and dollar-valued, being inferred per-citizen from the amounts contributed. This is a problematic assumption, as it equates something which is fundamentally subjective (a private feeling) with something which is fundamentally objective (a real number). The collective (subjective) utility is inferred from summing up these numbers, equating them with feelings. This seems… peculiar.

Economists have long wrestled with this problem. In his Social Choice and Individual Values, economist icon Ken Arrow famously argued that since choices are defined by relative preferences (“apple vs orange”), that “there is no quantitative meaning of utility for an individual”, and thus “interpersonal comparison [and thus summation] of utilities [have] no meaning”, since something which is not a number can be difficult to compare (i.e. it is easy to see that 6 is less than 7, but not easy to see that red is less than blue).

One might turn around and say that quadratic funding sidesteps the issue by asking citizens to make absolute decisions (“give $25 to the parks department”), rather than relative decisions (“plant apple trees, not orange trees, in the park”). In this case, citizens are telling us their currency-valued utility – $25, problem solved (known as “revealed preference”). But all that really tells us is that the citizen prefers giving the parks department $25 dollars to keeping it for themselves – and tells us nothing about the fuzzy questions of psychic insensities. Further, if we assume that everyone has the same capacity for inner experience (a question with deep ties to identity, our other bugbear), but not everyone has the same amount of money to give, then we paint ourselves into another corner: do those with more wealth, who give more, experience greater utility than those who give less? If I make $100 a day while you make $10, is my experience of satisfaction ten times yours? Probably not.

You might retort that this is excessive pedantism. Our lived experience is full of assessments of the subjective experiences of others, and – although they are based on evolved heuristics, not mathematical proofs – it seems to work well. In his Gaming the Vote (chapter 15), William Poundstone considers this debate and makes the point that “these intellectual positions… entailed a pose of fashionable agnosticism over matters previously held to be common sense.” Many economists agree, with Amartya Sen giving the famous example of Nero’s sacking of Rome: it is almost universally seen as self-evident that the negative utility of all the Romans who suffered in that blaze outweigh the positive utility that Nero experienced in the sacking, and so the sacking was “bad”. Clearly, utilitarian arguments have a place. To conclude that “we cannot model or compare subjective experience” seems like the easy way out, and evokes the behaviorist posture which constrained psychologists up until the “cognitive revolution” of the mid-20th century. Even if it’s not perfect, putting numbers to feelings seems “good enough” and gives us something to work with – so what’s the problem?

The problem is ultimately one of signal and noise, of signifier and signified, and of the risks of optimizing for proxies. Briefly, since we are unable to accurately represent (and thus measure) the thing we really care about (subjective utility), we instead measure a proxy (funding amounts). Unfortunately, there is a fundamentally unknowable gap between these two measurements, and so we cannot know how good our mechanisms really are with regard to our true goal of maximizing welfare – not only is there some error, but we cannot know what that error is.

In casual settings this is a non-issue, since this “proxy gap” will be too small to be consequential. However, the more pressure that is placed on the system (i.e. the more resources are at stake, the more people whose interests are affected), the greater the incentive to exploit the system (a phenomena known as Goodhart’s Law), and a key vector of exploitation is the gap between the desired measurement and the true measurement (for a well-known example, consider the test-prep industry which coaches students taking high-stakes standardized tests). The more resources which are deployed using quadratic funding, the more pressure is placed on the system, and so the more the gap between “true utility” and “funding amounts” (the proxy) will be exploited – leading to unexpected failures because the gap cannot be modeled by the system. Unlike other kinds of error, which can be modeled and thus handled by the system, this kind of error necessarily lies outside the system and is thus quite pernicious, as the consequences invariably come suddenly and by surprise.

All of this is not to say that quadratic funding is a bad idea – quite the opposite, in fact, as in general it will probably work well (see this experiment) and represents an important step forward. Further, these basic measurement problems do not affect quadratic funding alone – any mechanism which must represent and measure a subjective quality falls into this trap – which includes basically all voting, rating, and reputation systems.

The point is more that one of the banner claims – optimality – is overstated. Ultimately, quadratic funding is “optimal” in the same way that blue is the “optimal” color for the Blue Man Group – it follows from the definition, rather than from some essential truth. Quadratic funding does not really maximize utility – it maximizes some other amorphous “utility-like” thing. Which, again, is fine… until it’s not.

Thanks to Auryn Macmillan for feedback and for making sure I’m not an idiot.

Kronosapiens Labs

Implementing Active Ranking

I. Background

II. Variance-Based Selection

III. Composable Transforms

IV. The Pivot

V. Tuning

VI. Validation

VII. Reflections

Reinventing the Wheel

Contents

I. Introduction

II. Background

The Problem

The Ranking Engine

Prior Investigations

III. Explorations

Dynamic Damping

Cross-Dataset Validation

Handling Coalitions

Returning to Unidirectional Preferences

The Search for a Universal Curve

IV. Breakthrough

Damp-Before-Normalize

Bayesian Pseudocounts

V. Reflections

The Pairwise Paradigm

I. Motivations

II. Why Pairwise

III. The Pairwise Paradigm

1. Algorithm Selection

Elo

Bradley-Terry

Spectral Methods

Deep Funding

2. Pair Selection

Star Grouping

Active Ranking

3. Interface Design

Voting and Session Times

Input Format

Visual Elements

4. Audience Development

Audience Selection

Audience Expectations

Audience Segmentation

Audience Compensation

IV. Continuous Funding

Permissionless Entry

Stale Voting Data

Funding Rates

Process Tempo

V. Evaluation and Legitimacy

VI. Putting It All Together

Final Thoughts

Appendix: Other Considerations

The Independence of Irrelevant Alternatives

Intransitivity of Preferences

Dealing with Heterogeneity

AI and Verifiability

Exploring Deep Funding's Jury Data

I. Introduction

II. Data Analysis

Preliminaries

Overall Juror Assessments

Juror Thinking Times

III. Conclusion

Tech in the Age of AI

I. Technology

II. Labor

III. Distribution

IV. Vision

Understanding Generative Art

I. Overview

II. Artistic Legitimacy

III. Digital Ownership

IV. Art Market

V. Conclusions

Los Angeles

I. Overture