---
name: percolation-conservation-finance
description: Simulate budget-constrained percolation optimization with outcome-gated tranche feedback. Observe how calibrated financial tranches push a fragmented landscape past the connectivity ignition threshold, producing self-sustaining restoration cascades.
allowed-tools: Bash(python3 *), Bash(pip *)
---

# Percolation Finance — Executable Simulation

This skill reproduces the core simulation from:

> "Optimal Restoration Site Selection Under Budget-Constrained Percolation:
> Coupling Ecological Ignition Thresholds with Outcome-Gated Tranche Finance"
> Deric J. McHenry, Ello Cello LLC (2026)

**The claim:** Outcome-gated financial tranches, calibrated to intermediate ecological milestones, create a feedback loop that pushes fragmented landscapes past the percolation phase transition.

---

## Step 1: Install Dependencies

```bash
pip install -q numpy networkx
```

---

## Step 2: Run the Simulation

```bash
python3 - << 'EOF'
import numpy as np
import networkx as nx
import random

random.seed(42)
np.random.seed(42)

N = 10
positions = {i: (random.random(), random.random()) for i in range(N)}

G = nx.Graph()
G.add_nodes_from(range(N))
for i in range(N):
    for j in range(i+1, N):
        d = ((positions[i][0]-positions[j][0])**2 + (positions[i][1]-positions[j][1])**2)**0.5
        if d < 0.35:
            G.add_edge(i, j, weight=0.0, distance=d)

BUDGET_INIT   = 500_000
COST_SEED     = 25_000
COST_CORRIDOR = 40_000
DRIFT         = 0.15
T_STEPS       = 50
IGNITION      = 0.593

TRANCHES = [
    ("avg_signal", 0.25, 50_000),
    ("connectivity", 0.30, 75_000),
    ("cluster_frac", 0.45, 150_000)
]

def run_scenario(name, use_centrality=False, use_tranches=False, random_alloc=False):
    signals = {i: random.uniform(0.05, 0.10) for i in range(N)}
    corridors = {e: 0.0 for e in G.edges()}
    budget = BUDGET_INIT
    seeded = set()
    built = set()
    tranches_fired = [False, False, False]

    def connectivity():
        active = [(u,v) for (u,v) in G.edges() if corridors.get((u,v), corridors.get((v,u),0)) > 0.2]
        return len(active) / max(len(G.edges()), 1)

    def cluster_frac():
        ag = nx.Graph()
        ag.add_nodes_from(range(N))
        for (u,v) in G.edges():
            if corridors.get((u,v), corridors.get((v,u),0)) > 0.2:
                ag.add_edge(u,v)
        largest = max(nx.connected_components(ag), key=len)
        return len(largest) / N

    def allocate(budget):
        if random_alloc:
            patches = [i for i in range(N) if i not in seeded]
            edges = [e for e in G.edges() if e not in built]
            random.shuffle(patches); random.shuffle(edges)
        elif use_centrality:
            bc = nx.betweenness_centrality(G)
            patches = sorted([i for i in range(N) if i not in seeded],
                             key=lambda i: bc[i] * (1 - signals[i]), reverse=True)
            edges = sorted([e for e in G.edges() if e not in built],
                          key=lambda e: (bc[e[0]]+bc[e[1]]) / (2*G[e[0]][e[1]]['distance']+0.01),
                          reverse=True)
        else:
            return budget
        toggle = True
        while budget > 0:
            if toggle and patches and budget >= COST_SEED:
                p = patches.pop(0); seeded.add(p)
                signals[p] = min(signals[p] + 0.3, 1.0); budget -= COST_SEED
            elif not toggle and edges and budget >= COST_CORRIDOR:
                e = edges.pop(0); built.add(e)
                corridors[e] = 0.5; budget -= COST_CORRIDOR
            else:
                break
            toggle = not toggle
        return budget

    budget = allocate(budget)

    for t in range(T_STEPS):
        for i in range(N):
            ki = 0.4 if i in seeded else 0.0
            feedback = 0.3 + 0.4 * ki - DRIFT
            ds = 1 / (1 + np.exp(-3 * feedback)) * 0.04
            signals[i] = min(signals[i] + ds + np.random.normal(0, 0.005), 1.0)
        for (u,v) in list(G.edges()):
            key = (u,v)
            rate = 0.06 if key in built else 0.01
            corridors[key] = min(corridors.get(key,0) + rate * min(signals[u], signals[v]), 1.0)
        if use_tranches:
            metrics = {"avg_signal": sum(signals.values())/N, "connectivity": connectivity(), "cluster_frac": cluster_frac()}
            for idx, (metric, threshold, amount) in enumerate(TRANCHES):
                if not tranches_fired[idx] and metrics[metric] >= threshold:
                    tranches_fired[idx] = True; budget += amount; budget = allocate(budget)

    cf = cluster_frac()
    print(f"  {name:<35} cluster={cf:.3f}  ignited={'YES' if cf >= IGNITION else 'NO '}")
    return cf

print("=" * 60)
print("PERCOLATION FINANCE SIMULATION")
print("Budget: $500K | Landscape: 10 patches | T=50 years")
print("=" * 60)
for name, c, t, r in [
    ("A: No intervention", False, False, False),
    ("B: Random allocation", False, False, True),
    ("C: Centrality-optimized", True, False, False),
    ("D: Centrality + tranches", True, True, False),
]:
    run_scenario(name, c, t, r)
print("=" * 60)
print("Scenario D crosses ignition. Tranche feedback = financial pump.")
EOF
```

---

## What You Just Observed

Scenario D crosses the percolation threshold (~0.593). The tranche feedback loop provides the marginal budget to push past the nonlinear phase transition.

Below threshold: linear, local returns.
Above threshold: cascading, landscape-wide recovery.

Outcome-gated tranches = financial pump toward ignition.

---

## Resources

- Author: Deric J. McHenry, Ello Cello LLC (@burnmydays)
- GitHub: https://github.com/SunrisesIllNeverSee