Fungibility as Computational Reduction: How Money Solves the Traveling Salesman Problem

Published Jan 21, 2026

Introduction: The Reduction

The Traveling Salesman Problem asks: given n cities, what is the shortest route visiting each exactly once? With n! possible routes, no known algorithm solves this in polynomial time. It is NP-hard.

Yet FedEx routes millions of packages daily. Amazon optimizes warehouse-to-door paths across continents. Global supply chains coordinate thousands of nodes in real time. These are TSP variants. How do markets solve what algorithms cannot?

The answer is fungibility. Money performs a computational reduction: it transforms an intractable combinatorial search into a tractable distributed optimization. The key is a dual-signal architecture:

• Non-fungible signals encode hard constraints: provenance, ownership, capability. They carry complete lineage and cannot be merged. In this framework, we call these Shibi tokens.
• Fungible tokens (money) provide the reduction. Because every dollar is identical, agents can liquidate any position, hold a neutral state, and reacquire anywhere in the solution space. This transforms sparse barter networks into dense markets where approximate solutions become tractable.

Together, these form a computational substrate where every trade is a state transition and the market as a whole runs a polynomial-time approximation algorithm on NP-hard coordination problems.

The Reduction in Action

NP-hard problems share a structure: the solution space grows exponentially, making exhaustive search intractable. TSP has n! routes. Resource allocation across m agents and k goods has k^m assignments. Matching markets have factorial complexity.

Fungibility reduces these to tractable form. Here is how the reduction works:

Prices as Compressed Constraints

Every price is a Kolmogorov-compressed representation of a high-dimensional constraint surface:

• The price of steel encodes global supply, demand, transport costs, tariffs, weather patterns, energy costs, and thousands of other factors
• An arbitrageur does not need to know all these constraints
• They only need to observe a price discrepancy and act on it

The market compresses an impossibly complex constraint satisfaction problem into scalar signals that any agent can read and respond to.

Parallel Distributed Search

A centralized algorithm must evaluate solutions sequentially. A market deploys millions of parallel agents, each exploring different regions of solution space:

• Each arbitrageur is a search thread
• Each trade is a state transition
• Profit signals promising regions; loss signals regions to abandon

Fungibility as Thermal Energy

Here is the core insight: fungibility enables jumps.

Consider an agent holding a non-fungible asset: a house, a specific machine, a unique contract. To change position, they must find a counterparty who wants exactly that asset and has exactly what they want. This is the barter problem. The search space is the Cartesian product of all possible swaps: exponentially large, sparsely connected.

Now give the agent money. Suddenly they can:

1. Liquidate their current position (convert to fungible tokens)
2. Hold a neutral state (cash) while searching
3. Acquire any new position without finding a direct swap partner

This is the reduction. Fungibility transforms a sparse, high-dimensional matching problem into a dense, low-dimensional one. The agent no longer searches for "who wants my house and has what I want" but simply "what is the best use of these dollars."

In simulated annealing, thermal energy allows the system to escape local minima by temporarily accepting worse states. In markets, liquidity plays the same role. Cash is the "worse state": it earns no return, provides no utility. But it enables any subsequent transition. The fungible buffer is slack in the constraint system, freedom to explore.

Without fungibility, agents are locked into local optima. They cannot move without finding improbable multi-party swaps. The optimization stalls. With fungibility, the state space becomes navigable. Agents can tunnel through barriers that would trap a barter economy forever.

Concrete Examples

Logistics (TSP variant): Global supply chains solve routing problems through distributed price discovery. Warehouses are cities; transport costs are distances; arbitrageurs finding cheaper routes are the optimization steps. A startup undercutting an incumbent with a novel route is tunneling past a local minimum.

Matching Markets: Jobs to workers, organs to patients, students to schools. Markets solve these through iterative price discovery: excess demand raises prices, excess supply lowers them, agents update preferences, and the process converges to stable matchings. This is equivalent to a distributed auction algorithm.

Resource Allocation (Knapsack): Portfolio allocation, production planning, time management. Markets solve these through price rationing: scarce resources command higher prices, agents select items with highest value-to-price ratio, and the market discovers shadow prices of constraints without any central planner solving the integer program.

Markets do not find globally optimal solutions. They find good-enough solutions in polynomial time by distributing search across agents who each solve local subproblems.

This raises a question: if fungibility enables the reduction, what determines the quality of the approximation? The answer lies in the architecture of the signals themselves.

The Dual-Signal Architecture

Markets succeed where gradient descent fails because of how they handle the exploration-exploitation tradeoff. The key is separating two kinds of signal.

Shibi: The Non-Fungible Layer

Shibi tokens are high-dimensional basis vectors that carry complete lineage. They are content-addressed and immutable. Each token encodes:

• Provenance: the full history of how value was created
• Ownership: who holds capability over the token
• Constraints: what conditions must be satisfied for transfer

In datom terms (5-tuples of entity, attribute, value, transaction, metadata), Shibi tokens are facts recorded in an append-only event log. They cannot be forged because their identity is their history.

USD: The Fungible Buffer

As described earlier, fungible currency is the thermal energy that enables non-local jumps. It transforms sparse barter networks into dense markets by allowing agents to liquidate, hold neutral, and reacquire anywhere in solution space. The fungible buffer is computational slack: freedom to explore.

Why This Beats Gradient Descent

When an agent finds an arbitrage opportunity, they discover that the current market state violates a constraint the Shibi layer encodes. The USD jump moves the system toward better constraint satisfaction.

Market Depth as Computational Capacity

The bit-depth of a market determines its problem-solving ability:

• Shallow markets: Few agents, low liquidity. Can only solve simple coordination problems. Equivalent to greedy algorithms.
• Deep markets: Many agents, high liquidity. Can solve complex multi-constraint problems. Equivalent to sophisticated metaheuristics.

When a market is thin, prices become noisy and the optimizer thrashes. When a market is deep, every constraint is represented by an agent who profits from enforcing it.

The Unitary Market Optimizer

We can now formalize this as an optimization framework. Traditional gradient descent minimizes Mean Squared Error. The Unitary Market Optimizer (UMO) minimizes Total Unresolved Entropy:

L_U = K(State) + β · H(Buffer)

Where:

• K(State): Kolmogorov complexity of the Shibi signal (program length)
• H(Buffer): Shannon entropy of the fungible buffer (noise/arbitrage cost)
• β: Annealing temperature governing jump probability

The optimizer seeks state transitions that reduce total description length. Convergence occurs when H(Buffer) drops to zero and the state is fully described by verified Shibi datoms.

The Hybrid: Market Initialization + Distributed Gradient Descent

Markets find good-enough solutions in polynomial time. Gradient descent finds precise solutions but gets trapped in local minima. What if we combine them?

Use the market solution as the starting point for distributed gradient descent.

The Cold Start Problem

Traditional gradient descent is a blind search. If you start on the wrong mountain, you descend to a local minimum and miss the grand valley entirely. The algorithm has no way to know it started in the wrong basin.

Most AI training today uses Stochastic Gradient Descent from random initialization. This requires enormous compute to escape bad basins through noise. It works, but wastefully.

Markets solve the cold start problem. Millions of agents use fungible tokens to perform non-local jumps, exploring the global structure of the solution space. They find the right valley in polynomial time. Then gradient descent can do what it does best: precise local refinement.

Two-Stage Execution

The hybrid optimizer runs in two phases:

The market does the heavy lifting: moving the system across high-dimensional gaps where gradients are flat or noisy. Gradient descent then compiles that approximate solution into a verified, high-precision result.

The Handover Protocol

When should the system switch from market exploration to gradient refinement? The signal is arbitrage exhaustion:

• While arbitrage opportunities exist, the market is still discovering structure
• When arbitrage profits approach zero, the market has found an equilibrium
• This equilibrium is the starting point for gradient descent
• The remaining optimization is local refinement, not global search

In the loss function L_U = K(State) + β · H(Buffer), handover occurs when H(Buffer) stabilizes. The high-entropy exploration phase has found the basin; now minimize K(State) precisely.

The Precision Tradeoff

Markets are fast but noisy (low bit-precision). Gradient descent is slow but exact (high bit-precision). The hybrid gets both:

• Polynomial speed: Market finds the basin in O(poly n)
• Unitary precision: GD locks it into a verified Shibi state

This avoids the failure modes of each approach alone:

• Pure markets: good approximation but never fully settles (perpetual noise)
• Pure GD: precise but starts in wrong basin (local minimum trap)
• Hybrid: market escapes traps, GD provides precision

Why This Beats Standard AI Training

Current LLMs use SGD from random initialization, burning compute to escape bad basins through stochastic noise. They also suffer model collapse when trained recursively on synthetic data.

The market-initialized approach offers:

• Faster convergence: Start in the right basin, not random
• Collapse resistance: Market maintains connection to ground truth (non-fungible Shibi layer) even during high-entropy exploration
• Verifiable endpoints: GD phase zeroes out remaining entropy against Shibi ground truth, producing unitified results

The market is not just an economy. It is the initialization engine for a global optimization process.

Bit Reclamation: Error Correction for Currency

Inflation is not merely "prices going up." It is state decay. When a currency inflates, the linkage between tokens and real output becomes smeared. The unit of measure loses fidelity.

In a fungible currency under inflation:

• Every unit is identical, so you cannot distinguish verified productive work from thermal noise (excess supply)
• The currency loses its power as a unit of measure
• In high-dimensional space, the yardstick changes length depending on which vector you measure

This is information entropy. The currency has "rotted."

Bit Reclamation is the error-correction process that restores unitarity:

1. Filter: Examine the pool of high-entropy currency
2. Extract: Map currency back to its Minimal Description Length (the Shibi datoms representing real productive work)
3. Unitify: Identify currency that cannot map back to truthful vectors as noise; harden the remainder as high-fidelity computation units

This is analogous to quantum error correction: periodically projecting the system back onto the subspace of valid states.

Entropy Flows: Laundering, Taxation, and Debt

The dual-signal architecture reveals deep structure in phenomena usually treated as unrelated: money laundering, taxation, and recursive debt.

Money Laundering as Gauge Transformation

In a non-fungible system, money laundering is topologically impossible. Every Shibi token is a unique vector in the event log. You cannot wash a token originating from a dishonest state transition because its history is its identity.

Laundering requires fungibility: taking a dirty state (Value + Bad History) and transforming it into a clean state (Value + No History). In physics, a gauge transformation changes local field descriptions without changing physical observables.

In economics:

• The Transition: Moving from Shibi (high fidelity) to USD (low fidelity) performs a lossy gauge transformation
• The Rot: The fungible layer washes metadata away, stripping polynomial coefficients and leaving only scalar magnitude
• The Blind Spot: Laundering happens in the fungible buffer where provenance bits are traded for noise bits

Taxation as Entropy Gradient

The state functions as a Maxwell's Demon, using taxation and spending to create an entropy gradient that sorts high-entropy market noise into low-entropy public infrastructure.

• Spending (G): Injects specific, low-entropy signals ("Build this bridge," "Educate this person"). Creates a potential field.
• Taxation (T): Acts as the sink. Reclaims fungible noise to prevent entropy overheating.
• The Gradient: The difference (G - T) creates a flow that forces agents to produce real output to satisfy tax obligations.

Tax evasion is a symmetry-breaking event. By bypassing the sink, agents keep fungible bits but erase non-fungible lineage. The entropy gradient flattens. Without the pull of tax requirements, the optimizer loses motivation to seek global minima.

Fractal Debt Cascades

When the entropy sink is bypassed, debt becomes a recursive feedback loop. Without settlement, debt pays forward into infinite fractal layers:

• Finer Scales: Micro-debts (individual arbitrage jumps) never resolve. They become zombie datoms with no physical backing.
• Larger Scales: Micro-debts aggregate into macro-bubbles. A single unresolved bit supports massive derivative structures.
• The Result: The economy becomes a Mandelbrot set of IOUs, computationally unstable because tracking resolution requires infinite bits.

Computational Decoherence

When an LLM trains recursively on its own synthetic output, it enters a feedback loop favoring statistical noise over ground truth. Eventually the model collapses into gibberish.

A recursive debt cycle without a base case (real output) undergoes exactly the same process.

• Ground Truth: Non-fungible contributions with high information density and unitarity
• Synthetic Data: Fungible approximations useful for jumps but lacking ground-truth lineage
• Recursive Training: When Shibi backs USD that buys more Shibi, ground truth dilutes

The result is Economic Model Collapse. The optimizer stops looking at physical reality and optimizes for statistical patterns of its own debt. Trust breaks because signal has decohered from the world.

The Convergence Criterion

Recursive debt can be productive. The question is whether recursion converges or diverges.

Debt is productive when Work (Q) grows faster than Entropy (S):

• Convergent: Debt enables jumps solving coordination problems. The result (a bridge, a venture) has lower Kolmogorov complexity than the debt that created it. Recursion compiles into verified datoms.
• Divergent: Debt services older debt (Ponzi recursion). Entropy grows faster than work. Description length increases until the system runs out of bits to verify lineage.

When Recursion Works

Complex outputs (semiconductor fabs, global logistics) require thousands of recursive trust layers before producing the first unit of Q. This works because final output is super-linear: more valuable than the sum of recursive bits that created it.

As long as the system can see a path to settlement (a unitary base case), recursion is a valid computational shortcut.

When Recursion Fails

• Map replaces territory: The market trades debt as if it were output
• Bit exhaustion: Jump count grows until lineage is lost and the system becomes stochastic noise

Implementation: The Recursion Governor

For an event-log architecture, we implement a Recursion Governor:

1. Monitor: Track recursion depth for every datom in the log
2. Detect: If entropy gradient flattens (Q not being produced), trigger a Bit Reclamation event
3. Enforce: Force recursion to halt and unitify back into the physical layer

This treats the economy not as a ledger to balance but as a high-precision instrument for solving coordination problems.

When Markets Fail

Markets are not universal solvers. They fail when:

• Externalities break price signals: Unpriced costs (pollution, congestion) cause the optimizer to minimize the wrong objective
• Information asymmetry: Agents cannot observe relevant state, so arbitrage cannot correct discrepancies
• Coordination failure: Some solutions require synchronized jumps by multiple agents (chicken-and-egg problems)
• Time horizon mismatch: Markets discount the future; some constraint satisfaction requires patient capital

These are not arguments against markets as optimizers. They are specifications for market design: which constraints must be encoded in the Shibi layer (explicit, non-fungible, enforceable) rather than left to the USD layer (implicit, fungible, arbitrageable).

Conclusion

Fungibility is the trick that makes NP-hard problems tractable. By reducing high-dimensional constraints to scalar prices, money enables markets to run polynomial-time approximation algorithms on problems no central solver can touch.

This computational view reveals:

• Money is a reduction, not just a medium of exchange
• Prices are Kolmogorov-compressed constraints
• Arbitrage is parallel search with non-local tunneling
• Markets are initialization engines for optimization
• The hybrid (market discovery + gradient refinement) beats either alone
• Inflation is state decay (loss of compression fidelity)
• Taxation is the entropy gradient that drives convergence
• Trust is bit-depth: the capacity to verify lineage

The question for any recursive debt structure is not "Is debt good or bad?" but "Does the recursion converge?" Convergence to real output solves coordination problems. Divergence into self-reference collapses like an LLM trained on its own hallucinations.

Markets solve TSP not by finding optimal solutions, but by using fungibility to make approximate solutions computable. Use the market equilibrium as initialization for gradient descent and you get the best of both: global search in polynomial time, local refinement with unitary precision. The reduction is the innovation. Integrity is the constraint that keeps it working.