igneum-network/igneum
1
0
Fork 0
Code Issues Pull requests Releases Activity

ECO-05 RUN: FAIL against the frozen envelope (one sustainable world of sixteen; the AMD, Intel and older NVIDIA classes cost 4x to 6x a Blackwell card per joule on this hash; no specialist passes all three lines; nothing weakened); the ECO-08 package sim/economy/coexist/ (the /tmp import made relative); the registry rows

Browse source 
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
igneum-labs 2026-10-08 17:45:14 +00:00
parent fc90937b0c
commit be15f98fb3
25 changed files with 7396 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

162
docs/analysis/class-v6/eco-05-results.md Normal file
View file

@ -0,0 +1,162 @@
# ECO-05 results: the full cube on the frozen register, the boundaries, and the failed worlds explained
Case ECO-05 "Stress success, contraction and cheap electricity", registry row `docs/plans/igneum-2.0-test-registry.json`
suite ECO, gate G4, profile P12, GATE; this run moves its status from NOT RUN to RUN, VERDICT FAIL (the envelope is
not met in the sustainable worlds as the register froze them; the failure regions are explicit; nothing was weakened
to pass). 8 October 2026, 18:3x to 18:5x UK, branch `class-v6-floor-sram`, floor lane 3. The register
(`eco-05-scenarios.md`, frozen at ece460a5, 18:37 UK) is cited and unchanged. **Every row is modelled** on the labelled
inputs of `sim/economy/coexist/inputs/`; the driver is `sim/economy/coexist/eco05.py`, run on build-4 at 18:39 UK at
the assumed proving efficiency (0.5) and at the measured day's (0.055); the full cubes (2,592 cells each) are
`sim/economy/coexist/out/eco05-cube-eff050.tsv` and `eco05-cube-eff0055.tsv`, every cell published. The founder is
not named.
## 0. The verdict in one page
1. **Sustainability, as found (the register's section 5 expectation contradicted and reported, not revised).** Under
the register's rule (three purchasable configurations across two vendors with positive new-entry economics at MSRP,
and 75 percent of the entry cohort with positive marginal operating economics, at the GPU side's own equilibrium)
**only one of the sixteen revenue-tariff worlds is sustainable: 10R at USD 0.03 per kWh** (17 classes with positive
entry across three vendors, 100 percent operating). Every other world fails the two-vendor test: at the equilibrium
set by NVIDIA's cards (revenue per MH/s-hour 321 to 2,301 micro-USD), no AMD or Intel card has positive new-entry
economics at MSRP, because on this hash the measured RX 9070 XT (7.9 microjoules at its knee), the RX 7600 (6.2
estimated, 8.1 measured at stock) and the Arc B580 (10.4, watts estimated) cost 4x to 6x a Blackwell card per joule
and their entrants 1,400 to 2,100 micro-USD against an equilibrium under 1,100 at every world below 10R. The
operating test passes in 30 of 48 world-demand cells (68 to 100 percent of the cohort above water); the 0.25R worlds
at 0.25 and 0.40 and the R and 4R worlds at 0.40 without proving demand fall to 39 to 46 percent (collapse worlds,
retained as such). **This is a failure region of the chain's own commodity participation, independent of any
specialist: across vendors, sustained new entry on this hash exists only at the cheapest tariff and the largest
revenue.** The expected declaration in the register's section 5 (sustainable at R and above for 0.03 to 0.25) was
wrong on the two-vendor count and is reported so.
2. **The envelope in the sustainable worlds: no specialist passes.** In the 54 cells of the one sustainable world
(10R, 0.03; three demand states x three lives x three development cases x two business models), per specialist:
| Specialist | Cells passing the median (1.5) | The p90 (1.75) | The core (2.0) | All three | Median range | The worst core cell |
|---|---|---|---|---|---|---|
| N2 SRAM die (USD 1.0, 2.3x) | 6 of 54 (development USD 75 M charged, life 1 only) | 0 | 0 | **0** | 1.03 to 11.7 | 23.6 (the used RTX 3090, life 5, zero development) |
| Stored-half hybrid (2.80, 1.93x) | 12 | 0 | 6 | **0** | 0.69 to 6.8 | 13.6 |
| GDDR7 machine (4.84, 1.5x) | 21 | 0 | 12 | **0** | 0.50 to 4.4 | 8.9 |
The p90 fails everywhere because the cohort's dearest entrants (the hosted H100 at 8,500 micro-USD, the used A100,
the Mac, the used 3090) sit 9x to 50x above any specialist; the consumer-16 cut (the register's cohort less the
three that never enter) lowers the medians by 5 to 10 percent and changes no verdict.
3. **The boundaries (life 3, development zero, private mining, normal demand; the ratio does not move with revenue
at zero development because neither side's cost does):**
| Specialist | Median at 0.03 / 0.10 / 0.25 / 0.40 | Consumer-16 median | The best competitive-core cell (the 5090 at 0.03, the 5080 above) | The worst core cell |
|---|---|---|---|---|
| Die | 9.80 / 7.38 / 5.80 / 5.26 | 9.28 / 7.22 / 5.55 / 4.88 | 5.14 / 3.87 / 2.98 / 2.67 | 19.7 (the used 3090 at 0.03) to 10.7 (the B580 at 0.40) |
| Hybrid | 5.12 / 4.61 / 4.13 / 3.94 | 4.84 / 4.51 / 3.95 / 3.66 | 2.68 / 2.42 / 2.12 / 2.00 | 10.3 to 7.8 |
| GDDR7 machine | 3.24 / 3.11 / 2.95 / 2.88 | 3.07 / 3.04 / 2.82 / 2.67 | **1.70 / 1.63 / 1.51 / 1.46** | 6.5 to 5.6 |
Read: the one cell class inside the envelope anywhere is the best Blackwell card against the GDDR7 machine (1.46
to 1.70, under 1.5 from 0.25 per kWh up); every other GPU class as a NEW ENTRANT AT MSRP costs 2x to 20x any
specialist. The dearer the tariff the smaller the ratio, because power is a larger share of the GPU entrant's
cost than of the specialist's and the specialist's hardware term does not shrink.
4. **The heterogeneous tariff (the specialist at 0.03 against each GPU tariff, published beside, not the envelope's
test):** at R the die's median reads 9.8 / 13.1 / 19.8 / 26.7 against GPUs at 0.03 / 0.10 / 0.25 / 0.40, the
hybrid 5.1 to 13.9, the GDDR7 machine 3.2 to 8.8; the review's electricity axis multiplies the gap as it said.
5. **The adversarial combinations (at R, life 3; the same at 4R):** the die at USD 0.5 and a node ahead against GPUs at
0.40 with itself at 0.03, median 42 and p90 95 (the worst case in the cube); the die taking the whole chain with USD
75 M of development charged, median 2.7 (the development term is what brings it nearest the envelope, and the
standard forbids relying on research-cost recovery); hardware sales at zero development 5.9; the GPU entrant at
street 7.1; a 1.5x GPU generation against the die a node ahead 8.0; the die at USD 1.6 6.4; the GDDR7 machine
against street GPU prices at 0.25, 2.9. At the measured 5.5 percent proving efficiency the sustainability counts
and every ratio are unchanged (the ratio is a cost ratio; the proving income enters only the operating test, where
the measured day lowers no world below the line that was not already below it).
6. **What the failure means, and what it is not.** The envelope compares a GPU bought new at list price and run for
two years against a specialist that exists with its development sunk; on today's rows that comparison fails for
every specialist including the one the coexistence model passes on its seven conditions (the DRAM-board chip), and
it fails first on the GPU side's own spread: the cohort's median new entrant (a used 3080 or 3060, 940 to 1,254
micro-USD at 0.03 to 0.10) is 2x to 3x the best Blackwell entrant (493 to 656), so no specialist that beats the
best card by 1.5x can be within 1.5x of the cohort's median. **The result does not rest on a small network, token
appreciation or chip death** (the ratios are revenue-independent at zero development, the one sustainable world is
the largest, and the 180-day rotation enters nowhere); it rests on the measured energy of the AMD, Intel and older
NVIDIA classes on this hash and on the standard's choice of the cohort-wide median at MSRP as the test. The
coexistence model's seven-condition verdict (the board coexists, the die does not once built) is the operating
reading; ECO-05's envelope is the stricter new-entry reading, and the chain fails it as frozen.
## 1. The sustainability declaration as found (no specialist present)
| Revenue | Tariff | Demand | Sustainable | r (micro-USD per MH/s-h) | GPU hash (TH/s) | Classes with positive entry | Vendors | Cohort above water |
|---|---|---|---|---|---|---|---|---|
| 0.25R | 0.03 | none / normal / spiking | no / no / no | 321 | 4.3 | 7 / 9 / 13 | 1 | 95 percent |
| 0.25R | 0.10 | the same | no | 467 | 3.0 | 7 / 9 / 13 | 1 | 57 / 91 / 91 |
| 0.25R | 0.25 | | no | 710 | 2.0 | 7 / 9 / 13 | 1 | 45 / 68 / 91 |
| 0.25R | 0.40 | | no | 951 | 1.5 | 7 / 9 / 13 | 1 | 39 / 45 / 91 |
| R | 0.03 | | no | 476 | 12.8 | 11 / 14 / 15 | 1 | 99 |
| R | 0.10 | | no | 604 | 10.1 | 11 / 12 / 15 | 1 | 68 / 91 / 91 |
| R | 0.25 | | no | 873 | 6.4 | 10 / 12 / 15 | 1 | 45 / 68 / 91 |
| R | 0.40 | | no | 1,079 | 5.2 | 10 / 12 / 15 | 1 | 45 / 45 / 91 |
| 4R | 0.03 | | no | 833 | 30.9 | 14 / 15 / 15 | 1 | 100 |
| 4R | 0.10 | | no | 1,028 | 21.9 | 12 / 15 / 15 | 1 | 98 |
| 4R | 0.25 | | no | 1,316 | 16.9 | 12 / 13 / 15 | 1 | 69 / 92 / 92 |
| 4R | 0.40 | | no | 1,530 | 14.6 | 12 / 12 / 15 | 1 | 46 / 69 / 92 |
| **10R** | **0.03** | | **yes / yes / yes** | 1,284 | 43.3 | 17 | 3 | 100 |
| 10R | 0.10 | | no | 1,354 | 41.0 | 15 | 1 | 100 |
| 10R | 0.25 | | no | 1,887 | 30.8 | 13 / 15 / 15 | 1 | 97 |
| 10R | 0.40 | | no | 2,301 | 25.3 | 13 / 14 / 15 | 1 | 69 / 92 / 92 |
Where the two-vendor test fails, the one vendor with positive entry is NVIDIA; the count of NVIDIA classes with
positive entry is 7 to 15 of 16. The proving demand (normal, spiking) adds 2 to 6 classes to the entry count and up to
46 points to the operating share, which is the second income doing what the coexistence model said it would; it never
brings an AMD or Intel card over the entry line below 10R.
## 2. The cube
Every cell is in `sim/economy/coexist/out/eco05-cube-eff050.tsv` (columns: specialist, revenue, tariff, life,
development, business model, demand, sustainable, r, GPU hash, the two sustainability counts, the specialist's cost
and its hardware, power and development terms, the median and p90 over the 19 classes, the consumer-16 median and p90,
the best and worst competitive-core cells with their class, and the three envelope verdicts). The cells of the one
sustainable world for the die (the first 54 rows of its block) read, as medians: life 1 at zero development 5.4
(private) and 3.2 (sales), at USD 20 M 2.8 and 2.0, at USD 75 M 1.2 and 1.0; life 3 at zero 9.8 and 6.8, at 20 M 6.2
and 4.9, at 75 M 3.1 and 2.7; life 5 at zero 11.7 and 8.8, at 75 M 4.6 and 4.1. The only die cells under the median
line are those where USD 75 M of development is charged against a 1-year fleet, and they fail the p90 and the core;
the standard says that recovery may not prop up a result, and it does not here.
## 3. The failed worlds, explained (life 3, development zero, private mining, normal demand)
| Specialist | Tariff | The worst core cell and its ratio | That GPU entrant's cost (micro-USD) | The specialist's cost: total (hardware / power) | The cohort's median class and cost | The best core cell | Which term fails |
|---|---|---|---|---|---|---|---|
| Die | 0.03 | the used RTX 3090, 19.7 | 1,889 | 96 (43 / 52) | the used RTX 3080, 940 | the 5090, 5.14 | the GPU's hardware: a used 3090 at USD 900 for 37.8 MH/s is 1,700 micro-USD of annualised hardware against the die's 43 |
| Die | 0.10 | the used RTX 3090, 13.1 | 2,217 | 170 (43 / 125) | the used 3060, 1,254 | the 5080, 3.87 | hardware on the GPU side; the die's power term is 125 at a 2.3x edge |
| Die | 0.25 | the Arc B580, 10.9 | 3,587 | 328 (43 / 282) | the used 3080, 1,902 | the 5080, 2.98 | the B580's 10.4 microjoules (watts estimated) at 0.25 is 2,700 of power alone |
| Die | 0.40 | the Arc B580, 10.7 | 5,211 | 486 (43 / 439) | the used 3080, 2,558 | the 5080, 2.67 | power on both sides; the ratio falls toward the joule ratio (4.5x) as the tariff rises |
| Hybrid | 0.03 to 0.40 | the used 3090 10.3 to the B580 8.0 | the same | 184 to 649 (120 / 62 to 523) | the same | the 5090 2.68 to the 5080 2.00 | hardware at the cheap tariffs, power at the dear |
| GDDR7 machine | 0.03 to 0.40 | the used 3090 6.5 to the B580 5.9 | the same | 290 to 888 (207 / 80 to 673) | the same | **the 5090 1.70 to the 5080 1.46** | the machine's hardware (207) is a third of the best Blackwell entrant's and its power 1.5x less; the median class is a used Ampere or Ada card at 3x the machine |
The pattern: the envelope's median is set by the cohort's middle (the used 3080, the used 3060, the 4070: 940 to 2,558
micro-USD), which is 2x to 3x the best Blackwell card as a new entrant because of their joules (4.2 to 5.8 against
1.7 to 2.1) and, at the cheap tariffs, their hardware per MH/s. No specialist within the envelope against the best
card can be within it against the middle. The core's worst cell is the used 3090 at the cheap tariffs (hardware) and
the Arc B580 at the dear ones (power), the two classes whose rows carry the register's BLOCKED labels (the 3090's
cap modelled, the B580's watts estimated); replacing them with measured rows moves the worst cell but not the verdict,
since the next-worst core cells (the RX 7600 at 10.2, the 9070 XT at 8.6 against the die) are also above 2.0.
## 4. The boundary of the envelope, as a question
What would pass: for the GDDR7 machine the best-core cell passes 1.5 from 0.25 per kWh and 2.0 everywhere, and its
consumer-16 median would pass 1.5 if the cohort were the Blackwell cards alone (1.46 to 1.9); for the hybrid and the
die no cohort of today's cards passes at any tariff with development sunk. So the envelope as frozen is passable by the
DRAM-board specialist only against a Blackwell-only cohort, which the standard does not allow to be chosen after the
fact, and is not passable by the SRAM die or the hybrid against any cohort of today's cards. That boundary is the
honest statement of the chain's position against a funded programmable competitor: the stored-dataset board coexists
with the best honest cards and no other, and the SRAM die with none.
## 5. Uncertainty and the model's range
- The die's ticket band (0.5 to 1.6) moves its medians from 7.2 (at 1.6) to 10.7 (at 0.5) at 0.10, the hybrid's and
the machine's rows have no band; the direction of every verdict is unchanged across the band.
- The modelled knees (Ada, Ampere) and the two estimated core rows move the worst core cell by up to 2x and the
cohort median by under 10 percent; no verdict moves.
- Street against MSRP for the GPU entrant raises every ratio 10 to 20 percent (adversarial row 4).
- The proving efficiency (0.5 assumed, 0.055 measured) changes no ratio and no sustainability verdict.
- The one sustainable world's existence rests on the register's two-vendor rule and the measured AMD and Intel rows;
a measured RX 7600 knee under 5 microjoules or a B580 under 8 would add worlds at 0.03 and 0.10, not above.
## 6. Status for the registry
ECO-05: RUN, FAIL against the frozen envelope in the sustainable worlds (0 of 54 cells per specialist pass all three
lines); the sustainability declaration as found differs from the register's expectation and is reported; the failure
regions are explicit (section 1 for commodity participation across vendors; sections 0.3 and 3 for the envelope);
collapse worlds retained as safety and exit tests; nothing imposed. Owed before G4: the second explorer read of R; the
RX 7600's own knee and the B580's metered watts; the independent reviewer's adversarial combinations (ECO-08).

8
docs/design/class-v6-rotating-family.md
View file

@ -653,6 +653,14 @@ The cells that matter: the cheapest honest owner is the 5070 Ti at its knee, 156
The revenue reference R, sourced: Ethereum Classic's trailing-year miner revenue from a public page's own figures (miningboard.com's ETC page, read 8 October 2026 at 18:3x UK): 2.5600 ETC per 13.0 s block at USD 7.83, 2,427,508 blocks and 6,214,420 ETC a year, R = USD 48.7 M a year (USD 133 K a day), range 40 to 55 M on the year's price range; the IGN price the spec's year-1 emission implies for R is USD 0.063 (0.016 / 0.25 / 0.63 at 0.25R / 4R / 10R); never an appreciation. Kaspa read the same way (USD 117 M a year) is named and rejected as a reference because it is ASIC-mined. One BLOCKED item on R: the page says ETC has no halving schedule, which conflicts with ETC's published 5M20 reductions; R is carried at the page's reward and flagged for a second explorer read before G4. The worlds are the standard's P12 list verbatim (0.25R / R / 4R / 10R; electricity 0.03 / 0.10 / 0.25 / 0.40; lives 1 / 3 / 5 years; development zero / 20 M / 75 M amortised over a third of the world's equilibrium hash, the whole chain as an adversarial row; private mining and hardware sales; external proving none / normal USD 2,000 a day / spiking x10 as the GPU cohort's second income): 864 worlds per specialist, three specialists at the reconciled rows (the die at USD 1.0 with the 0.5 and 1.6 ends as adversarial rows, the hybrid 2.80, the board 4.84). The honest cohort is the reference population's 19 classes; the competitive core declared as seven configurations across three vendors and five generations (the 5090, 5080, 4090, 3090, 9070 XT, RX 7600 8 GB, Arc B580; two with an estimated energy, labelled). The pass envelope verbatim (the matched-tariff median at most 1.5, the p90 at most 1.75, no core cell above 2.0); the sustainability rule declared (three purchasable configurations across two vendors with positive new-entry economics at MSRP and 75 percent of the entry cohort with positive marginal operating economics, at the GPU side's own equilibrium with no specialist present); the expected declaration per world written down first, to be contradicted by the driver if it is; eight adversarial combinations listed; nothing imposed (no share, no production limit, no appreciation, no research-cost recovery, no chip death). The cube, boundary tables and failed-world explanations follow by 22:30 UK in eco-05-results.md; the ECO-08 package (the model runnable from the served files) by 23:30.
#### 10.0x ECO-05 run on the frozen register: FAIL against the envelope in the sustainable worlds (lane 3 at 6bc66c14, 18:43 UK; `docs/analysis/class-v6/eco-05-results.md` and the ECO-08 package `sim/economy/coexist/` in this landing; nothing weakened; the failure regions explicit; the registry row ECO-05 RUN: FAIL)
**Sustainability as found, the register's expectation contradicted and reported, not revised:** under the frozen rule (three purchasable configurations across two vendors with positive new-entry economics at MSRP, and 75 percent of the entry cohort with positive marginal operating economics, at the GPU side's own equilibrium with no specialist present) only one of the sixteen revenue-tariff worlds is sustainable, 10R at USD 0.03 per kWh. Every other world fails the two-vendor test: at the equilibrium NVIDIA's cards set (321 to 2,301 micro-USD per MH/s-hour) no AMD or Intel card has positive new-entry economics at MSRP, because on this hash the measured 9070 XT (7.9 microjoules at its knee), the RX 7600 (6.2 estimated, 8.1 measured at stock) and the Arc B580 (10.4, watts estimated) cost 4x to 6x a Blackwell card per joule. **This is a failure region of the chain's own commodity participation across vendors, independent of any specialist.** The operating test passes in 30 of 48 cells; the 0.25R worlds at 0.25 and 0.40 and the R and 4R worlds at 0.40 without proving demand are collapse worlds (39 to 46 percent above water), retained as such.
**The envelope in the one sustainable world (54 cells per specialist):** the die 6 / 0 / 0 of 54 on the median / p90 / core lines and 0 on all three (medians 1.03 to 11.7; the 1.03 only where USD 75 M of development is charged against a one-year fleet, which the standard forbids as a prop); the hybrid 12 / 0 / 6, 0 on all three; the GDDR7 machine 21 / 0 / 12, 0 on all three. The p90 fails everywhere because the cohort's dearest entrants (the hosted H100, the used A100, the Mac, the used 3090) sit 9x to 50x above any specialist. The boundaries (life 3, zero development, private, normal demand; revenue-independent at zero development): the medians at 0.03 / 0.10 / 0.25 / 0.40 the die 9.8 / 7.4 / 5.8 / 5.3, the hybrid 5.1 / 4.6 / 4.1 / 3.9, the machine 3.2 / 3.1 / 3.0 / 2.9; the best core cell (the 5090 at 0.03, the 5080 above it) the die 5.1 to 2.7, the hybrid 2.7 to 2.0, the machine 1.70 / 1.63 / 1.51 / 1.46, the one cell class inside the envelope anywhere. Why: the cohort's median new entrant at MSRP (a used 3080 or 3060, the 4070: 940 to 2,558 micro-USD) is 2x to 3x the best Blackwell entrant (493 to 656) on its own joules and hardware, so no specialist within 1.5x of the best card can be within 1.5x of the median. The adversarial rows at R: the die at USD 0.5 a node ahead at 0.03 against GPUs at 0.40, median 42 and p90 95 (the worst in the cube); the die taking the whole chain with USD 75 M charged, 2.7; hardware sales at zero development 5.9; the GPU entrant at street 7.1; a 1.5x GPU generation against the die a node ahead 8.0; the die at 1.6, 6.4; the machine against street prices at 0.25, 2.9; the heterogeneous tariff (the specialist at 0.03) the die 9.8 to 26.7, the hybrid 5.1 to 13.9, the machine 3.2 to 8.8 across the GPU tariffs; the measured 5.5 percent proving efficiency changes no ratio and no sustainability verdict.
**What the failure does and does not rest on:** not a small network (the one sustainable world is the largest), not token appreciation (the ratios are revenue-independent at zero development), not chip death (the rotation enters nowhere); it rests on the measured energy of the AMD, Intel and older NVIDIA classes on this hash and on the standard's cohort-wide new-entry median at MSRP as the test. The coexistence model's seven-condition verdict (the board coexists, the die does not once built; 10.0q to 10.0t) is the operating reading; ECO-05's envelope is the stricter new-entry reading, and the chain fails it as frozen. The boundary, stated as the question it is: the DRAM machine would pass only against a Blackwell-only cohort, which cannot be chosen after the fact; the die and the hybrid against no cohort of today's cards. **What this means for the design, in one line: the class's per-joule gap between vendors (the AMD random-read ceiling, the Intel energy) is now a measured failure of the chain's own commodity participation under the standard, ahead of any chip, and the work that moves it is the hash's energy on AMD and Intel cards (the vendor-specific kernels and operating points, the ADLX and Intel levers), not another layer against a chip.** Owed before G4: a second explorer read of R; the RX 7600's own knee and the B580's metered watts (the two BLOCKED core rows); the independent reviewer's adversarial rows on the package tomorrow. The ECO-08 package: eight scripts, five input files with sources and labels, the README with the run commands and the frozen criteria, the ECO-01 fixtures ALL OK on build-4; the two scripts that read coexist2.py from /tmp on the box now read it from beside themselves (this lane's one-line fix at the landing).
#### 10.0d The rotation schedule the close adopts (the rotation lane, `docs/design/class-rotation-four-layers.md` on class-v6-rotation at bd43f808, build-3, gate green, 14:4x UK; one line per layer; both of this document's constraints held: the 180-day family epoch not shorter, W = 4 not drawn)
| Layer | Boundaries a year | What it draws, from where | Exposure per boundary (this document's units) | Chip | Label |

12
docs/plans/igneum-2.0-test-registry.json
View file

@ -1215,7 +1215,7 @@
"evidence_path": "docs/analysis/class-v6/coexistence-model.md (section 2, the cost per accepted MH/s-hour and its reconciliation); docs/analysis/class-v6/reference-population.md",
"run_id": "counter-asic-4 landing of 8 October 2026, 21:00 UK (the sha in the landing record)",
"run_owner": "research lane (D4) with floor lane 3; economics modelled, independent review open",
"run_note": "the independent reconciliation and second implementation owed to ECO-08 packaging"
"run_note": "fixtures.py (a second implementation of the per-class cost formula with hand-worked expected values and two edge cases) ALL OK on build-4, 18:43 UK; the independent reconciliation owed to ECO-08"
},
{
"id": "ECO-02",
@ -1338,11 +1338,11 @@
"gate": "G4",
"owner": "Economics lead + independent reviewer",
"manual_page": 34,
"run_status": "RUNNING",
"evidence_path": "docs/analysis/class-v6/eco-05-scenarios.md (the scenario register FROZEN 18:37 UK 8 October before any result: R = Ethereum Classic trailing-year miner revenue USD 48.7 M from a public page with URL and date, the worlds the P12 list verbatim, the envelope verbatim, the expected declaration per world written first); eco-05-results.md (the cube, 22:30 UK)",
"run_status": "RUN: FAIL",
"evidence_path": "docs/analysis/class-v6/eco-05-scenarios.md (the register frozen 18:37 UK before any result); docs/analysis/class-v6/eco-05-results.md (the cube, 18:43 UK: FAIL against the frozen envelope in the sustainable worlds, nothing weakened, the failure regions explicit); sim/economy/coexist/out/eco05-cube-eff050.tsv and eff0055.tsv (2,592 cells each)",
"run_id": "counter-asic-4 landing of 8 October 2026, 21:00 UK (the sha in the landing record)",
"run_owner": "research lane (D4) with floor lane 3; economics modelled, independent review open",
"run_note": "one BLOCKED item on R: the page states no ETC halving schedule against the published 5M20 reductions; R carried at the page reward and flagged for a second explorer read before G4"
"run_note": "the failure rests on the measured energy of the AMD, Intel and older NVIDIA classes on this hash (4x to 6x a Blackwell card per joule) and on the cohort-wide new-entry median at MSRP; not on a small network, appreciation or chip death; owed before G4: a second explorer read of R, the RX 7600 knee and the B580 metered watts (the two BLOCKED core rows), the independent review"
},
{
"id": "ECO-06",
@ -1434,8 +1434,8 @@
"gate": "G4",
"owner": "Economics lead + independent reviewer",
"manual_page": 35,
"run_status": "PLANNED",
"evidence_path": "the model packaged runnable from the served files (sim/economy/coexist/, 23:30 UK 8 October); the independent rerun by a separate in-house lane (09:00 UK 9 October)",
"run_status": "RUNNING",
"evidence_path": "sim/economy/coexist/ (the model packaged: eight scripts, five input files with sources and labels, README with the run commands and the frozen criteria, fixtures.py = ECO-01 second implementation ALL OK on build-4); the independent rerun by a separate in-house lane owed (09:00 UK 9 October)",
"run_id": "counter-asic-4 landing of 8 October 2026, 21:00 UK (the sha in the landing record)",
"run_owner": "research lane (D4) with floor lane 3; economics modelled, independent review open"
}

65
sim/economy/coexist/README.md Normal file
View file

@ -0,0 +1,65 @@
# sim/economy/coexist: the coexistence model, its surface, the operator simulation and the ECO-05 driver
Case ECO-08 ("Reproduce and adversarially audit the model"), registry row `docs/plans/igneum-2.0-test-registry.json`
suite ECO, gate G4, profile P12, GATE, NOT RUN; the package an unaffiliated reviewer runs. ECO-01's fixtures are
`fixtures.py`. Everything here is modelled unless an input file's label says measured; no chip has been measured.
Written 8 October 2026, branch `class-v6-floor-sram`. Python 3.10 or later, no packages. The founder is not named.
## Run
python3 fixtures.py # ECO-01: the second implementation of the per-class cost formula; exit 0 = OK
python3 refpop.py > out/reference-population.tsv # the served reference population (docs/analysis/class-v6/reference-population.md)
python3 coexist2.py # the coexistence model's tables T1 to T5 (coexistence-model.md sections 1 to 11)
python3 hybrid.py # the hybrid board scored (section 12a); expects coexist2.py beside it
python3 market.py # the market-structure axis and the workbook rows (section 8a, 12b, 12c, the workbook)
python3 surface.py # the profitability surface (floor/sram-and-floor.md section 4.4)
python3 floor_sram.py # the floor lane's levers (floor/sram-and-floor.md sections 2 to 5)
python3 opsim.py 0.5 # the operator simulation at the assumed proving efficiency; 0.055 = the measured day;
# argv: PROVE_EFF SCALE SPIKE INT_CONGESTION (see the docstring)
python3 eco05.py 0.5 > out/eco05-cube-eff050.tsv # ECO-05: the frozen grid plus the adversarial combinations
python3 eco05.py 0.055 > out/eco05-cube-eff0055.tsv
`hybrid.py` and `market.py` read `coexist2.py` from `/tmp/coexist2.py` as written for the build box; copy it there or
edit the path at the top of each (one line). Outputs regenerate `out/`.
## Inputs (every one a file beside the scripts, with its source and label)
- `inputs/reference-population.json`: the 19 GPU classes (energy at the floor and stock with the label per class, rate,
prices, resale, shard times, installed base, vendor, competitive-core flag).
- `inputs/specialists.json`: the three specialist rows at the adversary lane's reconciled tickets and the chip model's
energies, with the superseded 300 W ticket and the silicon floor named.
- `inputs/emission.json`: the spec's constant and the miner emission by year.
- `inputs/eco05-register.json`: the frozen ECO-05 register (R, its source, the grid, the envelope, the rule).
- `inputs/assumptions.json`: the method's constants (accepted work, fees, wear, failures, hosting, the GPU all-in cost basis).
The scripts carry the same figures inline (they were written before the input files); the reviewer's first check is
that the inline rows equal the files (a diff of `POP` against `reference-population.json`), which `fixtures.py` does
for the 5070 Ti and the 5090.
## The frozen success criteria
ECO-05 (`docs/analysis/class-v6/eco-05-scenarios.md`, frozen 8 October 2026 18:37 UK before any result): in every
mandatory sustainable world the matched-tariff new-entry median GPU/specialist cost per accepted work at most 1.5, the
90th percentile at most 1.75, no competitive-core cell above 2.0; sustainability as the register's rule; nothing
imposed (no market share, no production limit, no appreciation, no research-cost recovery, no chip death).
## Known limitations
- Every chip row is modelled (the chip model's method, the adversary lane's placed rows); the die's ticket is the
adversary lane's reconciled USD 1.0 per MH/s (0.5 to 1.6), the silicon floor 0.6 kept as a lower bound.
- The GPU knees on Ada and Ampere are modelled (no rented host allows the lock); the Arc B580's watts are estimated;
the RX 7600's knee is estimated by the 9070 XT's grid.
- Prices are approximate street and list figures of October 2026; the installed-base counts are approximate.
- The GPU reaction is a per-class supply curve with the installed base as a cap; no per-card agents, no used-price
response to the halvings; the operator simulation is cohort-based.
- The ETC revenue reference is a point-in-time price times a year's emission from one public page whose reward
figure conflicts with ETC's published reduction schedule (BLOCKED for a second read before G4).
- The proving income is shared by capacity (a sortition-like share), which flatters high-capacity classes; the 12 GB
tier's internal zero is the one measured proving row.
- The 97 percent accepted-work fraction, the 5 percent wear, the 3 percent failures, the 10 percent discount and the
USD 0.02 hosting are assumptions.
## Where the results are read
`docs/analysis/class-v6/coexistence-model.md`, `coexistence-workbook.md`, `reference-population.md`,
`operator-simulation.md`, `eco-05-scenarios.md`, `eco-05-results.md`, and `floor/sram-and-floor.md`.

118
sim/economy/coexist/coexist2.py Normal file
View file

@ -0,0 +1,118 @@
#!/usr/bin/env python3
# Floor lane 3: the coexistence model, second cut (the D4 checklist). Everything modelled; inputs labelled in the document.
# Adds to coexist.py: a per-class supply curve with the installed base as a cap and re-entry on a price rise (no fixed shares);
# proving income as a second axis per class at zero, launch and spike demand; the chip-side generation at year 3; the tariff
# advantage beside the hardware advantage; break-even electricity for all 17 classes; supplier and operator dependence.
import math
H = 8766.0; ACCEPT = 0.97; POOL_FEE = 0.01; WEAR = 0.05; HOST_FARM = 0.02
ELEC = (0.06, 0.12, 0.25)
# name, uJ floor, uJ stock, MH/s, price new, used, resale2y, memGB, shard s (0 = cannot prove), proving W, installed base available to mining (approximate), label
POP = [
("RTX 5090", 2.33, 3.48, 134.8, 2600, 2200, 0.55, 32, 6.3, 300, 25000, "measured"),
("RTX 5080", 2.06, 3.48, 71.2, 1100, 900, 0.50, 16, 8.0, 220, 40000, "measured"),
("RTX 5070 Ti", 1.70, 2.84, 77.0, 800, 650, 0.50, 16, 7.0, 200, 50000, "modelled knee"),
("RTX 5070", 1.75, 2.99, 41.0, 560, 450, 0.50, 12, 4.8, 140, 75000, "modelled knee"),
("RTX 5060 Ti 16G", 2.36, 4.02, 19.0, 450, 360, 0.45, 16, 11.6, 90, 50000, "modelled knee"),
("RTX 5060", 2.21, 3.76, 17.0, 310, 250, 0.45, 8, 12.0, 80, 75000, "modelled knee"),
("RTX 4090", 3.58, 5.00, 58.0, 1700, 1300, 0.45, 24, 6.3, 280, 75000, "modelled knee"),
("RTX 4080", 3.51, 4.92, 45.0, 1000, 700, 0.40, 16, 7.5, 220, 50000, "modelled knee"),
("RTX 4070", 3.58, 5.82, 31.1, 550, 400, 0.40, 12, 12.1, 110, 150000, "measured"),
("RTX 4060 Ti 16G", 3.81, 5.32, 17.6, 420, 290, 0.35, 16, 11.6, 75, 100000, "modelled knee"),
("RTX 3090 (used)", 4.51, 5.03, 37.8, 900, 650, 0.30, 24, 14.9, 230, 50000, "modelled cap"),
("RTX 3080 (used)", 4.20, 4.54, 40.8, 450, 330, 0.25, 10, 7.1, 210, 150000, "modelled cap"),
("RTX 3060 (used)", 5.77, 6.40, 23.8, 260, 190, 0.25, 12, 14.4, 105, 300000, "modelled cap"),
("RX 9070 XT", 7.90, 10.7, 18.9, 650, 520, 0.45, 16, 0.0, 150, 25000, "measured"),
("H100 (hosted)", 2.00, 2.58, 90.0, 25000, 18000, 0.50, 80, 3.0, 350, 2000, "modelled lock"),
("A100 (used)", 2.89, 2.99, 60.0, 10000, 6000, 0.35, 80, 5.0, 250, 2000, "modelled"),
("Apple M5 Max", 1.40, 1.40, 27.1, 4000, 3200, 0.55, 36, 0.0, 40, 15000, "measured (reported)"),
]
CHIPS = [("GDDR7 board + N5 core", 0.79, 4.3 * 1.3), ("HBM3 one stack + core", 0.65, 6.6 * 1.3), ("N2 SRAM die + core", 0.46, 0.6 * 1.3)]
MINER = {1: 0.77e9, 2: 0.80e9, 3: 0.40e9, 4: 0.40e9, 5: 0.20e9}
POOL = {y: v / 0.8 * 0.2 for y, v in MINER.items()}
def kwh(uj): return uj * 1e-3
def owner_cost(c, e): return (kwh(c[1]) * e + WEAR * c[5] / H / c[3]) / ACCEPT / (1 - POOL_FEE)
def entrant_cost(c, e, years=2):
hw = (c[4] - c[6] * c[4]) / (years * H) / c[3]
return (hw + kwh(c[1]) * e) / ACCEPT / (1 - POOL_FEE), hw / ACCEPT / (1 - POOL_FEE)
def chip_cost(ch, e, life, gen=1.0):
uj = ch[1] / gen; usd = ch[2]
hw = usd / (life * H) * (1 + 0.03 * life); pw = kwh(uj) * (e + HOST_FARM)
return (hw + pw) / ACCEPT / (1 - POOL_FEE), hw / ACCEPT, pw / ACCEPT
print("=== T1. The tariff advantage beside the hardware advantage (the review's illustration first) ===")
print("row | joules ratio | GPU tariff / chip tariff | operating advantage (joules x tariff) | hardware advantage | total vs owner / entrant")
print(f"the review's illustration: a 1.5x chip at 0.06 against a GPU at 0.25 | 1.5x | 0.25 / 0.06 = 4.17x | 6.25x | n/a | n/a")
for ch, life in ((CHIPS[0], 3), (CHIPS[2], 3)):
ct, chw, cpw = chip_cost(ch, 0.06, life)
for c in (POP[2], POP[1], POP[6]):
for e in ELEC:
oc = owner_cost(c, e); nc, nhw = entrant_cost(c, e)
print(f"{ch[0][:14]} L{life} vs {c[0]:14s} GPU at {e:.2f} | {c[1]/ch[1]:4.1f}x | {e/0.06:.2f}x | {c[1]/ch[1]*e/0.06:5.1f}x | {nhw/chw:5.1f}x | {oc/ct:4.1f}x / {nc/ct:4.1f}x")
print("\n=== T2. Break-even electricity for all 17 classes (cents per kWh): (a) the GPU owner's price at which it equals the chip's all-in at 0.06; (b) at which the GPU ENTRANT equals it ===")
print("class | GDDR7 L1 owner/entrant | GDDR7 L3 | SRAM L1 | SRAM L3")
for c in POP:
out = []
for ch in (CHIPS[0], CHIPS[2]):
for life in (1, 3):
ct = chip_cost(ch, 0.06, life)[0]
wear = WEAR * c[5] / H / c[3]; hw = (c[4] - c[6] * c[4]) / (2 * H) / c[3]
eo = (ct * ACCEPT * (1 - POOL_FEE) - wear) / kwh(c[1]) * 100
en = (ct * ACCEPT * (1 - POOL_FEE) - hw) / kwh(c[1]) * 100
out.append(f"{eo:6.1f} / {en:6.1f}")
print(f"{c[0]:18s} | " + " | ".join(out))
print("\n=== T3. Proving income as a second axis per class (USD per card-day, the card proving instead of mining), at zero, launch and spike demand ===")
# internal pool per day at IGN 0.10 shared by proving capacity; external USD 2,000 a day at launch, x10 spike, 90 pct to provers.
# capacity-weighted: a class's share = its shard rate / the sum over a proving fleet of 5,000 cards drawn from the top classes (approximate)
price = 0.10
pool_day = POOL[3] / 365.25 * price
fleet = [(c, 5000 * c[10] / sum(x[10] for x in POP if x[8] > 0 and x[7] >= 16)) for c in POP if c[8] > 0 and c[7] >= 16]
cap_total = sum(n * 86400 / c[8] for c, n in fleet)
print(f"internal pool USD {pool_day:,.0f}/day at IGN {price}; a 5,000-card proving fleet; the 12 GB tier a measured zero for internal proving (fleet lane); external USD 2,000/day launch, 20,000 spike")
print("class | memGB | shard s | internal USD/card-day | +external launch | +external spike | mining USD/card-day at the GPU equilibrium (r 521 uUSD/MH/s-h) | power cost/day at 0.12")
for c in POP:
if c[8] == 0: print(f"{c[0]:18s} | {c[7]:2d} | none | cannot prove (no CUDA) | | | {521e-6*24*c[3]:6.2f} | {kwh(c[1])*c[3]*24*0.12:5.2f}"); continue
cap = 86400 / c[8]
internal = pool_day * cap / cap_total if c[7] >= 16 else 0.0
ext_l = 0.9 * 2000 * cap / cap_total; ext_s = 0.9 * 20000 * cap / cap_total
print(f"{c[0]:18s} | {c[7]:2d} | {c[8]:4.1f} | {internal:6.2f}{' (measured zero)' if c[7] < 16 else ''} | {internal+ext_l:6.2f} | {internal+ext_s:6.2f} | {521e-6*24*c[3]:6.2f} | {c[9]/1000*24*0.12:5.2f}")
print("\n=== T4. Five years with a per-class supply curve (no fixed shares), the installed base as a cap, re-entry on a price rise ===")
# each class participates with a fraction g of its base: g = clip((r - owner)/(entrant - owner), 0, 1) for the base already owned
# (a third of the base is owned by potential miners) plus new entry (the remaining two thirds) when r > entrant cost; the chip fleet
# F fixed after entry (sunk), its joules improve 1.5x at year 3 (a node step) if it re-buys; GPU generation at year 3: entrant -25 pct.
def gpu_hash(r, year, elec=0.12):
gen = 0.75 if year >= 3 else 1.0
h = 0.0
for c in POP:
oc = owner_cost(c, elec) * gen; nc = entrant_cost(c, elec)[0] * gen
owned = c[10] / 3; fresh = c[10] * 2 / 3
g_own = min(1.0, max(0.0, (r - oc) / max(nc - oc, 1e-9)))
g_new = 1.0 if r > nc else 0.0
h += (owned * g_own + fresh * g_new) * c[3]
return h
def solve(R, F, year):
lo, hi = 1e-6, 1e-1
for _ in range(80):
mid = math.sqrt(lo * hi)
if R / H / (gpu_hash(mid, year) + F) > mid: lo = mid
else: hi = mid
r = hi; return r, gpu_hash(r, year)
paths = {"growing x2 from 0.10": lambda y: 0.10 * 2 ** (y - 1), "flat 0.10": lambda y: 0.10, "shrinking x0.5 from 0.30": lambda y: 0.30 * 0.5 ** (y - 1)}
for pname, path in paths.items():
for B, ch in ((1e6, CHIPS[2]), (10e6, CHIPS[2]), (100e6, CHIPS[2]), (10e6, CHIPS[0])):
F = B / ch[2]
print(f"--- {pname}; a sunk USD {B/1e6:.0f} M fleet of {ch[0]} ({F/1e6:.2f} TH/s) entering at year 2 ---")
for y in range(1, 6):
Fy = F if y >= 2 else 0.0
ct = chip_cost(ch, 0.06, 3, gen=(1.5 if y >= 4 else 1.0))[0]
r, Hg = solve(MINER[y] * path(y), Fy, y)
classes_in = sum(1 for c in POP if r > owner_cost(c, 0.12) * (0.75 if y >= 3 else 1.0))
print(f" y{y} p {path(y):5.2f} R {MINER[y]*path(y)/1e6:6.0f} M | r {r*1e6:6.0f} uUSD | GPU {Hg/1e6:6.2f} TH/s chip {Fy/1e6:6.2f} | chip share {Fy/(Fy+Hg)*100:5.1f} pct | chip margin {(r-ct)/r*100 if r>0 else 0:5.0f} pct | GPU classes above water {classes_in}/17")
print("\n=== T5. Supplier and operator dependence ===")
ent = entrant_cost(POP[2], 0.12)[0]
for p in (0.03, 0.1, 0.3, 1.0):
R = MINER[3] * p; r, Hg = solve(R, 0.0, 3)
print(f"p {p}: network {Hg/1e6:6.2f} TH/s at r {r*1e6:.0f} uUSD | GPU suppliers: NVIDIA (16 of 17 classes), AMD, Apple; the installed base cap {sum(c[10]*c[3] for c in POP)/1e6:.1f} TH/s ({Hg/sum(c[10]*c[3] for c in POP)*100:.0f} pct used) | one chip supplier: {Hg/5500:7.0f} SRAM dies = {Hg/5500/60:5.1f} N2 wafers, or {Hg/166:8.0f} GDDR7 boards | largest single GPU operator today (a 1 percent fleet): {Hg*0.01/1e6:.2f} TH/s")

185
sim/economy/coexist/eco05.py Normal file
View file

@ -0,0 +1,185 @@
#!/usr/bin/env python3
"""ECO-05 driver: the P12 factorial grid plus the adversarial combinations, on the frozen register
docs/analysis/class-v6/eco-05-scenarios.md. Every row modelled. Inputs are the reference population's rows (inline,
with their labels in the register) and the adversary lane's reconciled specialist rows. Output: a TSV cube on stdout,
a summary per world, the boundary tables and the failed-world explanations. Runs on build-4 (python3, no packages).
"""
import math, sys, json
H = 8766.0; ACCEPT = 0.97; FEE = 0.01; WEAR = 0.05; FAIL = 0.03; HOST_FARM = 0.02
R_USD = 48.7e6 # the register's R (ETC, 8 October 2026)
MINER_Y1 = 0.77e9 # IGN to miners in year 1
REV = {"0.25R": 0.25, "R": 1.0, "4R": 4.0, "10R": 10.0}
TARIFF = (0.03, 0.10, 0.25, 0.40)
LIFE = (1, 3, 5)
DEV = {"zero": 0.0, "USD 20 M": 20e6, "USD 75 M": 75e6}
MODEL = {"private": 1.0, "sales": 2.0}
DEMAND = {"none": 0.0, "normal": 2000.0, "spiking": 20000.0}
PROVE_EFF = float(sys.argv[1]) if len(sys.argv) > 1 else 0.5
# the reference population: name, memGB, uJ floor, MH/s, MSRP, street, used, resale, shard s (0 = cannot prove), installed base, vendor, core
POP = [
("RTX 5090", 32, 2.33, 134.8, 1999, 2600, 2200, 0.55, 6.3, 25000, "NVIDIA", True),
("RTX 5080", 16, 2.06, 71.2, 999, 1100, 900, 0.50, 8.0, 40000, "NVIDIA", True),
("RTX 4090", 24, 3.58, 58.0, 1599, 1700, 1300, 0.45, 6.3, 75000, "NVIDIA", True),
("RTX 3090 (used)", 24, 4.51, 37.8, 1499, 900, 650, 0.30, 14.9, 50000, "NVIDIA", True),
("RX 9070 XT", 16, 7.90, 18.9, 599, 650, 520, 0.45, 0.0, 25000, "AMD", True),
("RX 7600 8 GB", 8, 6.19, 13.9, 269, 270, 200, 0.40, 0.0, 60000, "AMD", True),
("Intel Arc B580", 12, 10.4, 10.7, 249, 260, 200, 0.40, 0.0, 20000, "Intel", True),
("Apple M5 Max", 36, 1.40, 27.1, 3999, 4000, 3200, 0.55, 0.0, 15000, "Apple", False),
("RTX 5070 Ti", 16, 1.70, 77.0, 749, 800, 650, 0.50, 7.0, 50000, "NVIDIA", False),
("RTX 5070", 12, 1.75, 41.0, 549, 560, 450, 0.50, 4.8, 75000, "NVIDIA", False),
("RTX 5060 Ti 16 GB", 16, 2.36, 19.0, 429, 450, 360, 0.45, 11.6, 50000, "NVIDIA", False),
("RTX 5060", 8, 2.21, 17.0, 299, 310, 250, 0.45, 12.0, 75000, "NVIDIA", False),
("RTX 4080", 16, 3.51, 45.0, 999, 1000, 700, 0.40, 7.5, 50000, "NVIDIA", False),
("RTX 4070", 12, 3.58, 31.1, 549, 550, 400, 0.40, 12.1, 150000, "NVIDIA", False),
("RTX 4060 Ti 16 GB", 16, 3.81, 17.6, 499, 420, 290, 0.35, 11.6, 100000, "NVIDIA", False),
("RTX 3080 (used)", 10, 4.20, 40.8, 699, 450, 330, 0.25, 7.1, 150000, "NVIDIA", False),
("RTX 3060 (used)", 12, 5.77, 23.8, 329, 260, 190, 0.25, 14.4, 300000, "NVIDIA", False),
("H100 (hosted)", 80, 2.00, 90.0, 25000, 25000, 18000, 0.50, 3.0, 2000, "NVIDIA", False),
("A100 (used)", 80, 2.89, 60.0, 10000, 10000, 6000, 0.35, 5.0, 2000, "NVIDIA", False),
]
E_LOCK = 2.33
SPEC = {
"die": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=1.0, lo=0.5, hi=1.6, label="N2 SRAM die, reconciled USD 1.0 (0.5 to 1.6), 2.3x / 3.1x"),
"hybrid": dict(uj=E_LOCK / 1.93, uj_ahead=E_LOCK / 2.40, usd=2.80, lo=2.80, hi=2.80, label="stored-half hybrid, USD 2.80, 1.93x / 2.40x"),
"board": dict(uj=E_LOCK / 1.5, uj_ahead=E_LOCK / 1.8, usd=4.84, lo=4.84, hi=4.84, label="GDDR7 machine, USD 4.84, 1.5x / 1.8x"),
}
def kwh(uj): return uj * 1e-3
def owner_cost(c, e): return (kwh(c[2]) * e + WEAR * c[6] / H / c[3]) / ACCEPT / (1 - FEE)
def entrant_cost(c, e, price_key="msrp", gen=1.0):
price = c[4] if price_key == "msrp" else c[5]
hw = (price - c[7] * c[4]) / (2 * H) / c[3] * (1 + FAIL * 2)
return (hw + kwh(c[2]) * gen * e) / ACCEPT / (1 - FEE), hw / ACCEPT / (1 - FEE)
def prove_income_per_mhs_h(c, ext_usd_day, price):
"""the proving income per MH/s-hour equivalent for a proving-capable class: internal pool at the price shared by a
5,000-card fleet's capacity plus external at 90 percent, times the efficiency; 12 GB tier a measured zero internally."""
if c[8] == 0: return 0.0
cap = 86400 / c[8] * PROVE_EFF * 0.96
fleet = [(x, 5000 * x[9] / sum(y[9] for y in POP if y[8] > 0 and y[1] >= 16)) for x in POP if x[8] > 0 and x[1] >= 16]
cap_total = sum(n * 86400 / x[8] * PROVE_EFF * 0.96 for x, n in fleet)
pool_day = MINER_Y1 / 0.8 * 0.2 / 365.25 * price
internal = pool_day * cap / cap_total if c[1] >= 16 else 0.0
external = 0.9 * ext_usd_day * cap / cap_total
return (internal + external) / 24 / c[3] # USD per MH/s-hour equivalent
def gpu_hash(r, e, gen=1.0):
h = 0.0
for c in POP:
oc = owner_cost(c, e); nc = entrant_cost(c, e, "msrp", gen)[0]
owned = c[9] / 3; fresh = c[9] * 2 / 3
g_own = min(1.0, max(0.0, (r - oc) / max(nc - oc, 1e-9))); g_new = 1.0 if r > nc else 0.0
h += (owned * g_own + fresh * g_new) * c[3]
return h
def solve(R, e, gen=1.0):
lo, hi = 1e-7, 1e-1
for _ in range(80):
mid = math.sqrt(lo * hi); hh = gpu_hash(mid, e, gen)
if hh <= 0 or R / H / hh > mid: lo = mid
else: hi = mid
return hi, gpu_hash(hi, e, gen)
def spec_cost(s, e, life, dev, model, fleet_mhs, ahead=False, usd=None):
uj = s["uj_ahead"] if ahead else s["uj"]; ticket = (usd if usd is not None else s["usd"]) * MODEL[model]
hw = ticket / (life * H) * (1 + FAIL * life); pw = kwh(uj) * (e + HOST_FARM)
devterm = dev / max(fleet_mhs, 1e-9) / (life * H)
return (hw + pw + devterm) / ACCEPT / (1 - FEE), hw / ACCEPT, pw / ACCEPT, devterm / ACCEPT
def pct(xs, p):
xs = sorted(xs); k = (len(xs) - 1) * p; f = math.floor(k); c = math.ceil(k)
return xs[f] if f == c else xs[f] + (xs[c] - xs[f]) * (k - f)
def sustainable(R, e, ext_usd_day, price, gen=1.0):
r, Hg = solve(R, e, gen)
entry_ok = [c for c in POP if r + prove_income_per_mhs_h(c, ext_usd_day, price) > entrant_cost(c, e, "msrp", gen)[0]]
vendors = {c[10] for c in entry_ok}
op_ok = sum(c[9] for c in POP if r + prove_income_per_mhs_h(c, ext_usd_day, price) > owner_cost(c, e)) / sum(c[9] for c in POP)
return (len(entry_ok) >= 3 and len(vendors) >= 2 and op_ok >= 0.75), r, Hg, len(entry_ok), len(vendors), op_ok
def cell(spec_key, R, e, life, dev, model, demand, spec_tariff=None, ahead=False, usd=None, price_key="msrp", gen=1.0, q=1/3):
price = R / MINER_Y1
sus, r, Hg, n_entry, n_vend, op_ok = sustainable(R, e, DEMAND[demand], price, gen)
s = SPEC[spec_key]; et = spec_tariff if spec_tariff is not None else e
sc, shw, spw, sdev = spec_cost(s, et, life, dev, model, Hg * q, ahead, usd)
ratios = []; core = []
for c in POP:
gc = entrant_cost(c, e, price_key, gen)[0]
# the ratio is a COST ratio (the standard's P12 wording: total cost per accepted work); the proving income is the
# GPU side's second income and enters the sustainability test above and its own column, never the ratio
ratio = gc / sc
ratios.append((c[0], ratio, gc, c[11], prove_income_per_mhs_h(c, DEMAND[demand], price)))
if c[11]: core.append((c[0], ratio))
med = pct([x[1] for x in ratios], 0.5); p90 = pct([x[1] for x in ratios], 0.9)
consumer = [x[1] for x in ratios if x[0] not in ("H100 (hosted)", "A100 (used)", "Apple M5 Max")]
med_c = pct(consumer, 0.5); p90_c = pct(consumer, 0.9)
worst = max(core, key=lambda x: x[1]); best_core = min(core, key=lambda x: x[1])
return dict(spec=spec_key, R=R, e=e, life=life, dev=dev, model=model, demand=demand, spec_tariff=et, ahead=ahead, usd=usd or s["usd"], price_key=price_key,
sustainable=sus, r=r, Hg=Hg, n_entry=n_entry, n_vend=n_vend, op_ok=op_ok, spec_cost=sc, spec_hw=shw, spec_pw=spw, spec_dev=sdev,
median=med, p90=p90, median_consumer=med_c, p90_consumer=p90_c, core_min=best_core[1], core_min_class=best_core[0], core_max=worst[1], core_max_class=worst[0], pass_med=med <= 1.5, pass_p90=p90 <= 1.75, pass_core=worst[1] <= 2.0,
ratios=ratios)
def main():
print(f"# ECO-05 cube; PROVE_EFF {PROVE_EFF}; R USD {R_USD/1e6:.1f} M")
hdr = ["spec", "revenue", "tariff", "life", "dev", "model", "demand", "sustainable", "r_uUSD", "gpu_TH", "n_entry", "n_vendors", "op_ok_pct", "spec_cost_uUSD", "spec_hw", "spec_pw", "spec_dev", "median", "p90", "median_consumer16", "p90_consumer16", "core_min", "core_min_class", "core_max", "core_max_class", "pass_med", "pass_p90", "pass_core", "pass_all"]
print("CUBE\t" + "\t".join(hdr))
cube = []
for spec_key in SPEC:
for rn, rm in REV.items():
for e in TARIFF:
for life in LIFE:
for dn, dv in DEV.items():
for mn in MODEL:
for dmn in DEMAND:
c = cell(spec_key, R_USD * rm, e, life, dv, mn, dmn)
c["revenue"] = rn; c["devname"] = dn
cube.append(c)
pa = c["pass_med"] and c["pass_p90"] and c["pass_core"]
print("CUBE\t" + "\t".join(str(x) for x in [spec_key, rn, e, life, dn, mn, dmn, int(c["sustainable"]), f"{c['r']*1e6:.0f}", f"{c['Hg']/1e6:.2f}", c["n_entry"], c["n_vend"], f"{c['op_ok']*100:.0f}", f"{c['spec_cost']*1e6:.0f}", f"{c['spec_hw']*1e6:.0f}", f"{c['spec_pw']*1e6:.0f}", f"{c['spec_dev']*1e6:.0f}", f"{c['median']:.2f}", f"{c['p90']:.2f}", f"{c['median_consumer']:.2f}", f"{c['p90_consumer']:.2f}", f"{c['core_min']:.2f}", c["core_min_class"], f"{c['core_max']:.2f}", c["core_max_class"], int(c["pass_med"]), int(c["pass_p90"]), int(c["pass_core"]), int(pa)]))
# the sustainability declaration as found (no specialist)
print("\nSUSTAIN\trevenue\ttariff\tdemand\tsustainable\tr_uUSD\tgpu_TH\tn_entry\tn_vendors\top_ok_pct")
for rn, rm in REV.items():
for e in TARIFF:
for dmn in DEMAND:
sus, r, Hg, ne, nv, ok = sustainable(R_USD * rm, e, DEMAND[dmn], R_USD * rm / MINER_Y1)
print(f"SUSTAIN\t{rn}\t{e}\t{dmn}\t{int(sus)}\t{r*1e6:.0f}\t{Hg/1e6:.2f}\t{ne}\t{nv}\t{ok*100:.0f}")
# summary per specialist over sustainable worlds
print("\nSUMMARY\tspec\tsustainable_worlds\tpass_all\tpass_median\tpass_p90\tpass_core\tmedian_min\tmedian_max\tcore_max_max")
for spec_key in SPEC:
sw = [c for c in cube if c["spec"] == spec_key and c["sustainable"]]
if not sw: print(f"SUMMARY\t{spec_key}\t0"); continue
pa = sum(1 for c in sw if c["pass_med"] and c["pass_p90"] and c["pass_core"])
print(f"SUMMARY\t{spec_key}\t{len(sw)}\t{pa}\t{sum(c['pass_med'] for c in sw)}\t{sum(c['pass_p90'] for c in sw)}\t{sum(c['pass_core'] for c in sw)}\t{min(c['median'] for c in sw):.2f}\t{max(c['median'] for c in sw):.2f}\t{max(c['core_max'] for c in sw):.2f}")
# boundary: for each specialist, life 3, dev zero, private, normal demand: the median by revenue x tariff
print("\nBOUNDARY\tspec\trevenue\ttariff_0.03\ttariff_0.10\ttariff_0.25\ttariff_0.40 (median ratio; life 3, dev zero, private, normal demand; * = sustainable)")
for spec_key in SPEC:
for rn in REV:
cells = [c for c in cube if c["spec"] == spec_key and c["revenue"] == rn and c["life"] == 3 and c["devname"] == "zero" and c["model"] == "private" and c["demand"] == "normal"]
print(f"BOUNDARY\t{spec_key}\t{rn}\t" + "\t".join(f"{c['median']:.2f}{'*' if c['sustainable'] else ''}" for c in sorted(cells, key=lambda x: x['e'])) + "\t| consumer-16 median " + " / ".join(f"{c['median_consumer']:.2f}" for c in sorted(cells, key=lambda x: x['e'])) + "\t| best core " + " / ".join(f"{c['core_min']:.2f}" for c in sorted(cells, key=lambda x: x['e'])))
# the heterogeneous tariff (specialist at 0.03)
print("\nHETERO\tspec\trevenue\tgpu_tariff\tmedian\tp90\tcore_max (specialist at 0.03; life 3, dev zero, private, normal)")
for spec_key in SPEC:
for rn, rm in REV.items():
for e in TARIFF:
c = cell(spec_key, R_USD * rm, e, 3, 0.0, "private", "normal", spec_tariff=0.03)
print(f"HETERO\t{spec_key}\t{rn}\t{e}\t{c['median']:.2f}\t{c['p90']:.2f}\t{c['core_max']:.2f}")
# adversarial combinations (the register's section 6), at R and 4R, life 3
print("\nADV\tcombination\tspec\trevenue\tmedian\tp90\tcore_max\tsustainable")
for rn in ("R", "4R"):
Rv = R_USD * REV[rn]
advs = [
("1 die at USD 0.5, a node ahead, dev zero, private, GPU 0.40 vs specialist 0.03", cell("die", Rv, 0.40, 3, 0.0, "private", "normal", spec_tariff=0.03, ahead=True, usd=0.5)),
("2 die taking the whole chain (dev USD 75 M over 100 pct), private, 0.10", cell("die", Rv, 0.10, 3, 75e6, "private", "normal", q=1.0)),
("3 hardware sales at zero development, die, 0.10", cell("die", Rv, 0.10, 3, 0.0, "sales", "normal")),
("4 GPU entrant at street, die at 1.0, 0.10", cell("die", Rv, 0.10, 3, 0.0, "private", "normal", price_key="street")),
("5 GPU generation 1.5x vs die a node ahead, 0.10", cell("die", Rv, 0.10, 3, 0.0, "private", "normal", ahead=True, gen=1/1.5)),
("6 spiking demand at the measured 5.5 pct proving efficiency, die, 0.10", None),
("7 die at USD 1.6 (the dear end), 0.10", cell("die", Rv, 0.10, 3, 0.0, "private", "normal", usd=1.6)),
("8 board at street GPU prices, 0.25", cell("board", Rv, 0.25, 3, 0.0, "private", "normal", price_key="street")),
]
for name, c in advs:
if c is None: print(f"ADV\t{name}\tdie\t{rn}\t(run with argv[1] = 0.055)"); continue
print(f"ADV\t{name}\t{c['spec']}\t{rn}\t{c['median']:.2f}\t{c['p90']:.2f}\t{c['core_max']:.2f}\t{int(c['sustainable'])}")
# failed-world explanations: for each specialist at life 3, dev zero, private, normal, the worst core cell's terms at R and 0.10
print("\nEXPLAIN\tspec\trevenue\ttariff\tworst_core_class\tratio\tgpu_entrant_uUSD\tspec_uUSD\tspec_hw\tspec_pw\tmedian_class\tmedian_gpu_uUSD\tbest_core\tproving_income")
for spec_key in SPEC:
for rn in ("0.25R", "R", "4R", "10R"):
for e in (0.03, 0.10, 0.25, 0.40):
c = cell(spec_key, R_USD * REV[rn], e, 3, 0.0, "private", "normal")
rs = sorted(c["ratios"], key=lambda x: x[1]); medc = rs[len(rs) // 2]
wc = [x for x in c["ratios"] if x[0] == c["core_max_class"]][0]; bc = [x for x in c["ratios"] if x[0] == c["core_min_class"]][0]
print(f"EXPLAIN\t{spec_key}\t{rn}\t{e}\t{wc[0]}\t{wc[1]:.2f}\t{wc[2]*1e6:.0f}\t{c['spec_cost']*1e6:.0f}\t{c['spec_hw']*1e6:.0f}\t{c['spec_pw']*1e6:.0f}\t{medc[0]}\t{medc[2]*1e6:.0f}\tbest core {bc[0]} {bc[1]:.2f} ({bc[2]*1e6:.0f})\tproving income best core {bc[4]*1e6:.0f} uUSD/MH/s-h")
if __name__ == "__main__":
main()

60
sim/economy/coexist/fixtures.py Normal file
View file

@ -0,0 +1,60 @@
#!/usr/bin/env python3
"""ECO-01 hand-worked fixtures: a SECOND implementation of the per-class cost formula in a few lines, with the expected
values worked by hand, checked against the model's own function (coexist2.py). Run: python3 fixtures.py (exit 0 = all
within 0.5 percent). Every figure is modelled arithmetic on the labelled inputs in inputs/."""
import json, os, sys
HERE = os.path.dirname(os.path.abspath(__file__))
A = json.load(open(os.path.join(HERE, "inputs", "assumptions.json")))
H = A["hours_per_year"]; ACC = A["accepted_work_fraction"]; FEE = A["pool_fee"]; WEAR = A["wear_fraction_of_used_price_per_year"]
def owner_second(uj, mhs, used, e):
# owner: (kWh per MH/s-hour x tariff + yearly wear per MH/s-hour) / accepted / (1 - fee); kWh per MH/s-hour = uJ x 1e-3
kwh = uj * 1e-3
return (kwh * e + WEAR * used / H / mhs) / ACC / (1 - FEE)
def entrant_second(uj, mhs, price, resale_frac, msrp, e, years=2):
hw = (price - resale_frac * msrp) / (years * H) / mhs
return (hw + uj * 1e-3 * e) / ACC / (1 - FEE)
# hand-worked expected values (the arithmetic written out):
# RTX 5070 Ti owner at 0.06: kWh/MH/s-h = 1.70e-3; power 1.70e-3 x 0.06 = 1.02e-4; wear 0.05 x 650 / 8766 / 77 = 4.82e-5;
# sum 1.502e-4 / 0.97 / 0.99 = 1.564e-4 USD = 156.4 micro-USD
# RTX 5070 Ti entrant at MSRP 749, resale 0.50 x 749 = 374.5, at 0.12: hw (749 - 374.5) / 17,532 / 77 = 2.774e-4; power 2.04e-4;
# sum 4.814e-4 / 0.97 / 0.99 = 5.013e-4 = 501.3 micro-USD (coexist2's entrant row carries resale on the NEW price: 521 at street 800)
# RTX 5090 owner at 0.12: 2.33e-3 x 0.12 = 2.796e-4; wear 0.05 x 2200 / 8766 / 134.8 = 9.31e-5; sum 3.727e-4 / 0.9603 = 388.1
EXPECTED = [
("RTX 5070 Ti owner 0.06", owner_second(1.70, 77.0, 650, 0.06), 156.4),
("RTX 5070 Ti entrant MSRP 0.12", entrant_second(1.70, 77.0, 749, 0.50, 749, 0.12), 501.3),
("RTX 5090 owner 0.12", owner_second(2.33, 134.8, 2200, 0.12), 388.1),
("RX 7600 owner 0.25", owner_second(6.19, 13.9, 200, 0.25), None),
]
# edge cases: zero tariff (wear only), a card that cannot be resold, a one-hour accepted-work check
EDGE = [
("owner at zero tariff is wear only", owner_second(2.33, 134.8, 2200, 0.0) * 1e6, 0.05 * 2200 / H / 134.8 / ACC / (1 - FEE) * 1e6),
("entrant with no resale", entrant_second(2.0, 100.0, 1000, 0.0, 1000, 0.10) * 1e6, ((1000 / (2 * H) / 100.0) + 2.0e-3 * 0.10) / ACC / (1 - FEE) * 1e6),
]
def main():
ok = True
for name, got, exp in EXPECTED:
g = got * 1e6
line = f"{name}: second implementation {g:.1f} micro-USD"
if exp is not None:
d = abs(g - exp) / exp
line += f", hand-worked {exp}, diff {d*100:.2f} percent {'OK' if d < 0.005 else 'FAIL'}"
ok &= d < 0.005
print(line)
for name, got, exp in EDGE:
d = abs(got - exp) / exp
print(f"edge {name}: {got:.2f} vs {exp:.2f} {'OK' if d < 1e-9 else 'FAIL'}"); ok &= d < 1e-9
# cross-check against the model's own function where coexist2.py is importable
try:
sys.argv = [sys.argv[0]]
src = open(os.path.join(HERE, "coexist2.py")).read()
ns = {}; exec(src.split('print("=== T1.')[0], ns)
c = [x for x in ns["POP"] if x[0] == "RTX 5070 Ti"][0]
m = ns["owner_cost"](c, 0.06) * 1e6; s = owner_second(1.70, 77.0, 650, 0.06) * 1e6
d = abs(m - s) / s
print(f"model owner_cost vs second implementation, 5070 Ti at 0.06: {m:.1f} vs {s:.1f}, diff {d*100:.2f} percent {'OK' if d < 0.005 else 'FAIL'}"); ok &= d < 0.005
m2 = ns["entrant_cost"](c, 0.12)[0] * 1e6
print(f"model entrant_cost (street 800, resale 0.5 x 800) 5070 Ti at 0.12: {m2:.1f} micro-USD (the document's 521); not the MSRP fixture, which reads {entrant_second(1.70,77.0,749,0.50,749,0.12)*1e6:.1f}")
except Exception as ex:
print("cross-check skipped:", ex)
print("ALL OK" if ok else "FIXTURE FAIL"); sys.exit(0 if ok else 1)
if __name__ == "__main__": main()

160
sim/economy/coexist/floor_sram.py Normal file
View file

@ -0,0 +1,160 @@
#!/usr/bin/env python3
# Floor lane 3: the SRAM full-store die and the dataset floor. Arithmetic only; every input labelled in the document.
# Inputs: chip-model-v3 5.3/5.12, hardware-future.md 4.9 and 5, era-layout.md 1.3, spec 05 (emission), mission/future.md 2.2.
import math
# ---------- the 5090 side (measured, the record) ----------
E_CARD_V3 = 2.26e-6 # J per hash, class v3 at stock (the identity's E_card; 2.40 all-in incl. premium-free static)
E_CARD_V3_ALLIN = 2.40e-6
F_V4 = 1.10e-6 # class v4 premium on the 5090 unlocked (measured)
F_FULL = 2.0e-6 # the 5090's whole latency shadow (about 330,000 ops, approximate)
E_M5 = 0.78e-6 # M5 Max class v3 at the GPU+DRAM meter (measured)
READS = 128
# ---------- the SRAM die (modelled on the record's wire figure) ----------
WIRE_PJ_BIT = 1.3 # pJ per bit across a 24 mm die (the record; 0.6 at 128 mm^2 scaled by side; approximate)
E_MACRO = 0.10e-9 # J per macro access (approximate), width-independent (a wordline sensed)
E_CTRL = 0.05e-9 # J per read of sequencer/controller share (approximate)
HOP_PJ_BIT = 0.5 # UCIe (claimed)
P_DIE = 300.0 # W per die budget (the record)
P_STATIC = 30.0 # W static + controller per die (the record)
ADDR_BITS = 32
CTRL_BITS = 16
def bits_per_read(W): # W in 4-byte words
return ADDR_BITS + CTRL_BITS + 32 * W
def e_read(W, n_dies=1, lane_state_bits=None):
"""energy per dependent read on an n-die store; the hop crosses with prob 1 - 1/n (lane placement cannot
follow the per-site windows because the chain alternates sites)."""
b = bits_per_read(W)
e_wire = b * WIRE_PJ_BIT * 1e-12
# lane migration bound: if moving the lane state is cheaper than moving the data, the chip moves the lane
if lane_state_bits is not None:
b_mig = lane_state_bits + ADDR_BITS
if b_mig < b:
e_wire = b_mig * WIRE_PJ_BIT * 1e-12
b = b_mig
e_hop = (1 - 1.0 / n_dies) * b * HOP_PJ_BIT * 1e-12
return E_MACRO + e_wire + E_CTRL + e_hop, b
def chip_rows(W, n_dies=1, lane_state_bits=None):
er, b = e_read(W, n_dies, lane_state_bits)
e_mem_hash = READS * er
rate = (P_DIE - P_STATIC) / e_mem_hash # hashes per second per die, power-bound
e_hash0 = P_DIE / rate # J per hash at zero shadow incl. static
rows = {}
rows['bits'] = b
rows['E_read_nJ'] = er * 1e9
rows['rate_GHs_per_die'] = rate / 1e9
rows['E_hash0_uJ'] = e_hash0 * 1e6
rows['edge0_5090'] = E_CARD_V3_ALLIN / e_hash0
rows['edge0_M5'] = E_M5 / e_hash0
for k in (0.5, 1.0):
rows[f'edge_v4_k{k}'] = (E_CARD_V3 + F_V4) / (e_hash0 + k * F_V4)
rows[f'edge_full_k{k}'] = (E_CARD_V3 + F_FULL) / (e_hash0 + k * F_FULL)
rows[f'edge_M5v4_k{k}'] = (E_M5 + 0.62e-6) / (e_hash0 + k * 0.62e-6) # M5 Max class v4 1.40 measured
return rows
print("=== LEVER 1: read width W (words) on one 2 GiB die, lane pinned (no migration) ===")
print("W bits E_read nJ GH/s/die E_hash0 uJ edge0(5090) edge0(M5) v4 k=.5 v4 k=1 full k=.5 full k=1 M5v4 k=.5")
for W in (1, 4, 8, 16):
r = chip_rows(W)
print(f"{W:2d} {r['bits']:4d} {r['E_read_nJ']:7.2f} {r['rate_GHs_per_die']:7.2f} {r['E_hash0_uJ']:8.4f} "
f"{r['edge0_5090']:8.1f}x {r['edge0_M5']:6.1f}x {r['edge_v4_k0.5']:5.2f}x {r['edge_v4_k1.0']:5.2f}x "
f"{r['edge_full_k0.5']:5.2f}x {r['edge_full_k1.0']:5.2f}x {r['edge_M5v4_k0.5']:5.2f}x")
print("\n=== LEVER 1b: the lane-migration bound (lane state 256 bits of registers + 32 pc; scratch pins it) ===")
for W in (8, 16):
r = chip_rows(W, 1, lane_state_bits=288)
print(f"W={W}: with migration allowed the chip moves {r['bits']} bits per read, E_read {r['E_read_nJ']:.2f} nJ, edge0 {r['edge0_5090']:.1f}x")
print("\n=== LEVER 1c: the record's convention (64 B atom, 1.0 nJ) vs the narrow read, with the hop by die count ===")
print("W n_dies E_read nJ edge0 v4k.5")
for W in (1, 4, 8):
for n in (1, 2, 4, 8, 10, 16):
r = chip_rows(W, n)
print(f"{W:2d} {n:5d} {r['E_read_nJ']:6.2f} {r['edge0_5090']:5.1f}x {r['edge_v4_k0.5']:4.2f}x")
print("\n=== LEVER 1d: dependent chain per step (2, 4, 8 atoms): the ratio ===")
for chain in (1, 2, 4, 8):
reads = READS * chain
e_card = E_CARD_V3_ALLIN * chain # the card's marginal per dependent read is 10.9 nJ: the hash scales linearly
er, _ = e_read(4, 1)
e_chip = reads * er * (P_DIE / (P_DIE - P_STATIC))
print(f"chain {chain}: card {e_card*1e6:.2f} uJ, chip {e_chip*1e6:.3f} uJ, ratio {e_card/e_chip:.1f}x (unchanged)")
print("\n=== LEVER 2: the dataset floor against reticles and tiers ===")
# SRAM cost curve: GiB per reticle by year (452 mm^2 of macro; +8 percent per node every two years, approximate), USD per reticle
curve = {2026: (2.00, 500), 2027: (2.00, 500), 2028: (2.16, 550), 2029: (2.16, 550), 2030: (2.33, 600), 2031: (2.33, 600)}
tiers = [ # name, usable MiB, working set best/worst (MiB) excluding dataset and cache; cache 512 MiB from 4 GiB, 1 GiB from 8 GiB, 2 GiB from 16
("8 GB card", 6144), ("12 GB card", 9216), ("16 GB card", 12288), ("24 GB card", 18432), ("32 GB card", 24576),
("Apple 16 GB", 8192), ("Apple 32 GB", 16384), ("Apple 64 GB", 32768), ("Apple 128 GB", 65536)]
def cache_mib(d_gib):
if d_gib <= 2: return 256
if d_gib <= 4: return 512
if d_gib <= 8: return 1024
if d_gib <= 16: return 2048
return 4096
def fits(usable, d_gib, worst=True):
ws = 479 if worst else 254
need = d_gib * 1024 + ws + (cache_mib(d_gib) if worst else 0) # best case frees the cache after the build
return need <= usable
print("floor GiB | reticles 2026 / 2031 | USD silicon 2026 / 2031 (one die design; linear two-die menu) | tiers OUT (worst case) | tiers OUT (best case)")
for d in (2.0, 2.1, 4.0, 4.1, 5.5, 6.0, 8.0, 8.5, 11.0, 11.5, 16.0, 17.5, 20.0, 22.0, 24.0):
r26 = math.ceil(d / curve[2026][0]); r31 = math.ceil(d / curve[2031][0])
usd26 = r26 * curve[2026][1]; usd31 = r31 * curve[2031][1]
lin26 = d / curve[2026][0] * curve[2026][1]
out_w = [t for t, u in tiers if not fits(u, d, True)]
out_b = [t for t, u in tiers if not fits(u, d, False)]
print(f"{d:5.1f} | {r26:2d} / {r31:2d} | {usd26:5d} / {usd31:5d} (linear {lin26:5.0f}) | {', '.join(out_w) or 'none'} | {', '.join(out_b) or 'none'}")
print("\n--- state size each floor assumes (64 B per record) ---")
for d in (2, 5.5, 8.5, 11.5, 16, 20, 22):
print(f"{d:5.1f} GiB = {d*2**30/64/1e6:6.1f} M state records")
print("\n=== LEVER 3: NPV of an SRAM project against the spec's emission ===")
BASE_PER_IGN = 1e8
RATE = 3_168_808_781 / BASE_PER_IGN # IGN per DAA second, years 1 to 2
YEAR = 31_557_600
MINER = 0.80
ramp_loss = 37e6
def miner_ign(year): # calendar year 1..; halving every 2 years
h = (year - 1) // 2
e = RATE * YEAR / (2 ** h)
if year == 1: e -= ramp_loss
return e * MINER
print("miner IGN by year:", {y: round(miner_ign(y) / 1e6) for y in range(1, 9)})
E12 = miner_ign(1) + miner_ign(2)
print(f"years 1 to 2 miner emission {E12/1e9:.3f} B IGN (the mission lane's E2 4.18 B is not this constant's figure)")
# project: cost C, 24 months to silicon, mines years 3 to 6 (two halvings), discount 10 percent a year
DISC = 0.10
def pv_factor(year): # mid-year discounting from t = 0
return 1 / (1 + DISC) ** (year - 0.5)
life = [3, 4, 5, 6]
rev_ign_pv = sum(miner_ign(y) * pv_factor(y) for y in life)
rev_ign_nom = sum(miner_ign(y) for y in life)
print(f"life years 3 to 6: {rev_ign_nom/1e9:.2f} B IGN nominal, {rev_ign_pv/1e9:.2f} B IGN at 10 percent")
print("C (USD M) | s | edge e | p* (USD/IGN, 10% disc) | launch-year miner revenue at p* (USD M/yr) | per day | cap end y2 at p*")
supply_y2 = (miner_ign(1) + miner_ign(2)) / MINER
for C in (100e6, 250e6, 500e6):
for s in (0.30, 1.00):
for e in (3, 5, 13):
factor = s * (1 - 1 / e)
pstar = C / (factor * rev_ign_pv)
launch = miner_ign(1) * pstar
print(f"{C/1e6:5.0f} | {s:.2f} | {e:2d}x | {pstar:7.3f} | {launch/1e6:8.1f} | {launch/365/1e3:7.1f} K | {pstar*supply_y2/1e9:5.2f} B")
print("\n--- at three assumed prices: miner revenue and the verdict (C 150 M, s 0.30, e 5x) ---")
for p in (0.01, 0.10, 1.00):
npv = 0.30 * (1 - 1/5) * rev_ign_pv * p - 150e6
print(f"IGN {p:5.2f}: launch-year miner revenue USD {miner_ign(1)*p/1e6:7.1f} M ({miner_ign(1)*p/365/1e3:6.1f} K/day); "
f"NPV {npv/1e6:8.1f} M; fleet for s=0.3 at 7.8 M MH/s per USD: {0.43*7.8e6*p/1e3:7.1f} GH/s = {0.43*7.8e6*p/2.0e6:.2f} dies at W=8")
print("\n=== LEVER 4 arithmetic ===")
items = 2**25
derive_J = items * 9360 * 3e-12
write_J = items * 0.5e-9
print(f"re-fill of 2 GiB on the die: derive {derive_J:.2f} J + write {write_J:.3f} J; per epoch (3,600 s) {(derive_J+write_J)/3600*1e3:.2f} mW; per block (1 s) {(derive_J+write_J):.2f} W = {(derive_J+write_J)/300*100:.2f} percent of 300 W")
er4, _ = e_read(4, 1)
print(f"straddle at W=4 (16 B at 4 B grain): P(straddle 64 B item) = 3/16 = {3/16:.3f}; chip +{E_MACRO*3/16*1e9:.3f} nJ per read on {er4*1e9:.2f} ({E_MACRO*3/16/er4*100:.1f} percent); verifier +{3/16*100:.0f} percent items derived")
print(f"straddle 32 B sector on the 5090 at W=4: P = 3/8 = {3/8:.3f}: +37.5 percent sectors, same DRAM row (bandwidth not latency; unmeasured)")

60
sim/economy/coexist/hybrid.py Normal file
View file

@ -0,0 +1,60 @@
#!/usr/bin/env python3
# The adversary lane's hybrid board (D2(b)): hottest half of the items in 1 GiB of N2 SRAM beside the 16-device DRAM board.
import sys; sys.argv=[sys.argv[0]]
_src=open(__import__('os').path.join(__import__('os').path.dirname(__import__('os').path.abspath(__file__)), 'coexist2.py')).read()
exec(_src.split('print("=== T1.')[0]) # the model's rows and cost functions, no output
_i=_src.index('def gpu_hash'); _j=_src.index('for pname, path in paths.items():')
exec(_src[_i:_j]) # gpu_hash, solve, paths
E5090_LOCK = 2.33 # lane 4's class v5 floor on the 5090 at the lock, uJ per hash
rows = [
("Hybrid board, hottest half (D2(b) first row)", E5090_LOCK/2.69, 1.88*1.3, 600),
("Hybrid, uniform-store bound", E5090_LOCK/2.30, 3.34*1.3, 600),
("Hybrid, hottest three quarters", E5090_LOCK/3.10, 0.83*1.3, 600),
("Hybrid, a node ahead", E5090_LOCK/3.33, 1.88*1.3, 600),
("Hybrid at the 5.5 GiB floor (SRAM USD 690)", E5090_LOCK/2.69, 2.9*1.3, 600),
("GDDR7 board + N5 core (reference)", 0.79, 4.3*1.3, 166),
("N2 SRAM die + core (reference)", 0.46, 0.6*1.3, 5500),
]
print("=== H1. cost per accepted MH/s-hour, sunk, micro-USD; lives 1 / 3 / 5 y at 0.06 | 3 y at 0.12 / 0.25 | hardware / power at 0.06, 3 y ===")
for n,uj,usd,_ in rows:
ch=(n,uj,usd)
a=[chip_cost(ch,0.06,l)[0]*1e6 for l in (1,3,5)]; b=[chip_cost(ch,e,3)[0]*1e6 for e in (0.12,0.25)]; _,hw,pw=chip_cost(ch,0.06,3)
print(f"{n:46s} | {a[0]:6.0f} / {a[1]:6.0f} / {a[2]:6.0f} | {b[0]:6.0f} / {b[1]:6.0f} | {hw*1e6:5.0f} / {pw*1e6:5.0f}")
print("\n=== H2. the six conditions on the hybrid (3 y, sunk) ===")
ch=rows[0][:3]; ct,chw,cpw=chip_cost(ch,0.06,3)
best_owner=min(owner_cost(c,0.12) for c in POP[:6]); ent5080=entrant_cost(POP[1],0.12); ent5070ti=entrant_cost(POP[2],0.12)
print(f"(a) chip all-in {ct*1e6:.0f} vs best Blackwell owner at 0.12 {best_owner*1e6:.0f}: ratio {best_owner/ct:.2f}x (line 1.5x)")
print(f"(b) chip hardware {chw*1e6:.0f} vs 5080 entrant hardware {ent5080[1]*1e6:.0f}: {chw/ent5080[1]:.2f} of it (line 0.25)")
for p in (0.03,0.1,0.3,1.0):
r,Hg=solve(MINER[3]*p,0.0,3); third=Hg/3*rows[0][2]
print(f"(c) at IGN {p}: a third of {Hg/1e6:.1f} TH/s costs USD {third/1e6:.1f} M vs a year's miner revenue USD {MINER[3]*p/1e6:.0f} M: {'PASS' if third>MINER[3]*p else 'FAIL'}")
print(f"(e) per-joule gap at the knee: {E5090_LOCK/rows[0][1]:.2f}x vs the 5090 lock; vs 5080 knee {2.06/rows[0][1]:.2f}x; vs 5070 Ti {1.70/rows[0][1]:.2f}x (line 3x)")
print(f" total vs 5070 Ti owner / entrant at 0.12: {owner_cost(POP[2],0.12)/ct:.1f}x / {ent5070ti[0]/ct:.1f}x; at 0.06: {owner_cost(POP[2],0.06)/ct:.1f}x / {entrant_cost(POP[2],0.06)[0]/ct:.1f}x")
print("\n=== H3. five years, a sunk USD 10 M hybrid fleet (per-class supply curve) ===")
for pname,path in paths.items():
F=10e6/rows[0][2]
out=[]
for y in range(1,6):
Fy=F if y>=2 else 0.0; c3=chip_cost(ch,0.06,3,gen=(1.5 if y>=4 else 1.0))[0]
r,Hg=solve(MINER[y]*path(y),Fy,y); cls=sum(1 for c in POP if r>owner_cost(c,0.12)*(0.75 if y>=3 else 1.0))
out.append(f"y{y} share {Fy/(Fy+Hg)*100:4.1f}% margin {(r-c3)/r*100 if r>0 else 0:4.0f}% classes {cls}")
print(f"{pname:28s} ({F/1e6:.2f} TH/s): "+" | ".join(out))
print("\n=== H4. the surface: p* (USD per IGN), operator self-mining, T0 2 y, edge 2.7x, hardware USD 2.44/MH/s ===")
H_=8766.0
def margin(e,life,cap): return max(0.0,1-(0.000084/e+cap/(life*H_))/0.00092)
def pstar(C,t0,life,q,e,cap):
import math
rev={1:0.77e9,2:0.80e9,3:0.40e9,4:0.40e9,5:0.20e9,6:0.20e9,7:0.10e9,8:0.10e9}
def npv(p):
tot=-C; y=t0+1; rem=life; m=margin(e,life,cap)
while rem>0:
f=min(1.0,rem); tot+=q*m*rev.get(y,0.05e9)*p*f/(1.1)**(y-0.5); rem-=f; y+=1
return tot
lo,hi=1e-4,1e3
for _ in range(80):
mid=math.sqrt(lo*hi)
if npv(mid)>0: hi=mid
else: lo=mid
return hi
for C in (50e6,125e6,225e6):
print(f"C_dev {C/1e6:.0f} M: "+" ".join(f"L{l} q{q}: {pstar(C,2,l,q,2.7,2.44):.3f}" for l in (1,3) for q in (0.3,1.0)) + f" | margin L3 {margin(2.7,3,2.44):.2f}, L1 {margin(2.7,1,2.44):.2f}")

17
sim/economy/coexist/inputs/assumptions.json Normal file
View file

@ -0,0 +1,17 @@
{
"_source": "the coexistence model's method (docs/analysis/class-v6/coexistence-model.md section 1); assumptions, approximate",
"hours_per_year": 8766,
"accepted_work_fraction": 0.97,
"pool_fee": 0.01,
"wear_fraction_of_used_price_per_year": 0.05,
"failure_rate_per_year": 0.03,
"farm_hosting_usd_per_kwh": 0.02,
"gpu_entrant_horizon_years": 2,
"discount_rate": 0.1,
"gpu_all_in_cost_usd_per_mhs_hour_5090_lock_msrp": 0.00092,
"gpu_electricity_usd_per_mhs_hour_5090_lock": 8.4e-05,
"proving_efficiency_assumed": 0.5,
"proving_efficiency_measured_day": 0.055,
"steal_rate_measured": 0.04,
"internal_proving_min_memory_gb": 16
}

47
sim/economy/coexist/inputs/eco05-register.json Normal file
View file

@ -0,0 +1,47 @@
{
"_source": "docs/analysis/class-v6/eco-05-scenarios.md (frozen 8 October 2026 18:37 UK)",
"R_usd_per_year": 48700000.0,
"R_source": "https://miningboard.com/mining/ethereum-classic/halving read 2026-10-08 18:3x UK: 2.56 ETC per 13.0 s block, USD 7.83",
"R_range_usd": [
40000000.0,
55000000.0
],
"ign_price_implied_at_R": 0.063,
"revenue_multipliers": [
0.25,
1,
4,
10
],
"tariffs_usd_kwh": [
0.03,
0.1,
0.25,
0.4
],
"lives_years": [
1,
3,
5
],
"development_usd": [
0,
20000000.0,
75000000.0
],
"business_models": [
"private",
"sales"
],
"external_demand": {
"none": 0,
"normal": 2000,
"spiking": 20000
},
"pass_envelope": {
"median_max": 1.5,
"p90_max": 1.75,
"core_cell_max": 2.0
},
"sustainability_rule": "at the GPU side's own equilibrium: at least 3 purchasable configurations across at least 2 vendors with positive new-entry economics at MSRP, and at least 75 percent of the entry cohort by installed count with positive marginal operating economics"
}

22
sim/economy/coexist/inputs/emission.json Normal file
View file

@ -0,0 +1,22 @@
{
"_source": "docs/spec/05-fees-and-economics.md section 2.5 and the economics table",
"emission_base_units_per_daa_second": 3168808781,
"base_units_per_ign": 100000000,
"halving_every_daa_seconds": 63115200,
"ramp_days": 30,
"ramp_loss_ign": 37000000,
"miner_share": 0.8,
"prover_pool_share": 0.2,
"miner_ign_by_year": {
"1": 770000000,
"2": 800000000,
"3": 400000000,
"4": 400000000,
"5": 200000000,
"6": 200000000,
"7": 100000000,
"8": 100000000
},
"external_proving_usd_per_day_launch": 2000,
"external_split_provers": 0.9
}

310
sim/economy/coexist/inputs/reference-population.json Normal file
View file

@ -0,0 +1,310 @@
{
"_source": "docs/analysis/class-v6/reference-population.md; lane 4's class v5 table (docs/analysis/class-v6/floor/denominator.md); app/igneum-app/tiers/class-v5-tiers.json; prices approximate",
"_date": "2026-10-08",
"rows": [
{
"class": "RTX 5090",
"memory_gb": 32,
"uJ_per_hash_floor": 2.33,
"mhs_floor": 134.8,
"msrp_usd": 1999,
"street_usd": 2600,
"used_usd": 2200,
"resale_2y_fraction": 0.55,
"shard_seconds_0_cannot_prove": 6.3,
"installed_base_available": 25000,
"vendor": "NVIDIA",
"competitive_core": true,
"energy_label": "measured floor (PC 1, tiers file), measured rate",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 5080",
"memory_gb": 16,
"uJ_per_hash_floor": 2.06,
"mhs_floor": 71.2,
"msrp_usd": 999,
"street_usd": 1100,
"used_usd": 900,
"resale_2y_fraction": 0.5,
"shard_seconds_0_cannot_prove": 8.0,
"installed_base_available": 40000,
"vendor": "NVIDIA",
"competitive_core": true,
"energy_label": "measured floor (rented, lane 4)",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 4090",
"memory_gb": 24,
"uJ_per_hash_floor": 3.58,
"mhs_floor": 58.0,
"msrp_usd": 1599,
"street_usd": 1700,
"used_usd": 1300,
"resale_2y_fraction": 0.45,
"shard_seconds_0_cannot_prove": 6.3,
"installed_base_available": 75000,
"vendor": "NVIDIA",
"competitive_core": true,
"energy_label": "stock measured, knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 3090 (used)",
"memory_gb": 24,
"uJ_per_hash_floor": 4.51,
"mhs_floor": 37.8,
"msrp_usd": 1499,
"street_usd": 900,
"used_usd": 650,
"resale_2y_fraction": 0.3,
"shard_seconds_0_cannot_prove": 14.9,
"installed_base_available": 50000,
"vendor": "NVIDIA",
"competitive_core": true,
"energy_label": "stock measured, cap modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RX 9070 XT",
"memory_gb": 16,
"uJ_per_hash_floor": 7.9,
"mhs_floor": 18.9,
"msrp_usd": 599,
"street_usd": 650,
"used_usd": 520,
"resale_2y_fraction": 0.45,
"shard_seconds_0_cannot_prove": 0.0,
"installed_base_available": 25000,
"vendor": "AMD",
"competitive_core": true,
"energy_label": "measured (PC 1, ADLX -500 MHz -30 pct)",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RX 7600 8 GB",
"memory_gb": 8,
"uJ_per_hash_floor": 6.19,
"mhs_floor": 13.9,
"msrp_usd": 269,
"street_usd": 270,
"used_usd": 200,
"resale_2y_fraction": 0.4,
"shard_seconds_0_cannot_prove": 0.0,
"installed_base_available": 60000,
"vendor": "AMD",
"competitive_core": true,
"energy_label": "stock measured 13.88 MH/s at 113 W (PC 1); knee estimated by the 9070 XT grid",
"price_label": "approximate street and list, October 2026"
},
{
"class": "Intel Arc B580",
"memory_gb": 12,
"uJ_per_hash_floor": 10.4,
"mhs_floor": 10.7,
"msrp_usd": 249,
"street_usd": 260,
"used_usd": 200,
"resale_2y_fraction": 0.4,
"shard_seconds_0_cannot_prove": 0.0,
"installed_base_available": 20000,
"vendor": "Intel",
"competitive_core": true,
"energy_label": "rate measured 10.4 to 11 MH/s (PC 2); watts estimated about 110 W",
"price_label": "approximate street and list, October 2026"
},
{
"class": "Apple M5 Max",
"memory_gb": 36,
"uJ_per_hash_floor": 1.4,
"mhs_floor": 27.1,
"msrp_usd": 3999,
"street_usd": 4000,
"used_usd": 3200,
"resale_2y_fraction": 0.55,
"shard_seconds_0_cannot_prove": 0.0,
"installed_base_available": 15000,
"vendor": "Apple",
"competitive_core": false,
"energy_label": "measured (GPU and DRAM channels); reported not headlined; owner only",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 5070 Ti",
"memory_gb": 16,
"uJ_per_hash_floor": 1.7,
"mhs_floor": 77.0,
"msrp_usd": 749,
"street_usd": 800,
"used_usd": 650,
"resale_2y_fraction": 0.5,
"shard_seconds_0_cannot_prove": 7.0,
"installed_base_available": 50000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 5070",
"memory_gb": 12,
"uJ_per_hash_floor": 1.75,
"mhs_floor": 41.0,
"msrp_usd": 549,
"street_usd": 560,
"used_usd": 450,
"resale_2y_fraction": 0.5,
"shard_seconds_0_cannot_prove": 4.8,
"installed_base_available": 75000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 5060 Ti 16 GB",
"memory_gb": 16,
"uJ_per_hash_floor": 2.36,
"mhs_floor": 19.0,
"msrp_usd": 429,
"street_usd": 450,
"used_usd": 360,
"resale_2y_fraction": 0.45,
"shard_seconds_0_cannot_prove": 11.6,
"installed_base_available": 50000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 5060",
"memory_gb": 8,
"uJ_per_hash_floor": 2.21,
"mhs_floor": 17.0,
"msrp_usd": 299,
"street_usd": 310,
"used_usd": 250,
"resale_2y_fraction": 0.45,
"shard_seconds_0_cannot_prove": 12.0,
"installed_base_available": 75000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 4080",
"memory_gb": 16,
"uJ_per_hash_floor": 3.51,
"mhs_floor": 45.0,
"msrp_usd": 999,
"street_usd": 1000,
"used_usd": 700,
"resale_2y_fraction": 0.4,
"shard_seconds_0_cannot_prove": 7.5,
"installed_base_available": 50000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 4070",
"memory_gb": 12,
"uJ_per_hash_floor": 3.58,
"mhs_floor": 31.1,
"msrp_usd": 549,
"street_usd": 550,
"used_usd": 400,
"resale_2y_fraction": 0.4,
"shard_seconds_0_cannot_prove": 12.1,
"installed_base_available": 150000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "measured (1,860 MHz + 50 pct cap)",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 4060 Ti 16 GB",
"memory_gb": 16,
"uJ_per_hash_floor": 3.81,
"mhs_floor": 17.6,
"msrp_usd": 499,
"street_usd": 420,
"used_usd": 290,
"resale_2y_fraction": 0.35,
"shard_seconds_0_cannot_prove": 11.6,
"installed_base_available": 100000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 3080 (used)",
"memory_gb": 10,
"uJ_per_hash_floor": 4.2,
"mhs_floor": 40.8,
"msrp_usd": 699,
"street_usd": 450,
"used_usd": 330,
"resale_2y_fraction": 0.25,
"shard_seconds_0_cannot_prove": 7.1,
"installed_base_available": 150000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "modelled (both rented hosts capped)",
"price_label": "approximate street and list, October 2026"
},
{
"class": "RTX 3060 (used)",
"memory_gb": 12,
"uJ_per_hash_floor": 5.77,
"mhs_floor": 23.8,
"msrp_usd": 329,
"street_usd": 260,
"used_usd": 190,
"resale_2y_fraction": 0.25,
"shard_seconds_0_cannot_prove": 14.4,
"installed_base_available": 300000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "H100 (hosted)",
"memory_gb": 80,
"uJ_per_hash_floor": 2.0,
"mhs_floor": 90.0,
"msrp_usd": 25000,
"street_usd": 25000,
"used_usd": 18000,
"resale_2y_fraction": 0.5,
"shard_seconds_0_cannot_prove": 3.0,
"installed_base_available": 2000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
},
{
"class": "A100 (used)",
"memory_gb": 80,
"uJ_per_hash_floor": 2.89,
"mhs_floor": 60.0,
"msrp_usd": 10000,
"street_usd": 10000,
"used_usd": 6000,
"resale_2y_fraction": 0.35,
"shard_seconds_0_cannot_prove": 5.0,
"installed_base_available": 2000,
"vendor": "NVIDIA",
"competitive_core": false,
"energy_label": "stock measured (rented), knee modelled",
"price_label": "approximate street and list, October 2026"
}
]
}

34
sim/economy/coexist/inputs/specialists.json Normal file
View file

@ -0,0 +1,34 @@
{
"_source": "the adversary lane's reconciled rows (multi-family-adversary.md section 15, 8 October 2026) at the chip model's energies; per joule vs the RTX 5090 at its 1,300 MHz lock (2.33 uJ class v5)",
"_label": "modelled; no chip measured",
"specialists": [
{
"name": "N2 SRAM die with shadow core",
"edge_node_for_node": 2.3,
"edge_node_ahead": 3.1,
"usd_per_mhs": 1.0,
"usd_per_mhs_band": [
0.5,
1.6
],
"silicon_floor_usd_per_mhs": 0.6,
"ticket_300W_machine_superseded": 2.94
},
{
"name": "stored-half hybrid board",
"edge_node_for_node": 1.93,
"edge_node_ahead": 2.4,
"usd_per_mhs": 2.8,
"p98_program": {
"edge": 2.09,
"usd_per_mhs": 1.88
}
},
{
"name": "complete GDDR7 machine",
"edge_node_for_node": 1.5,
"edge_node_ahead": 1.8,
"usd_per_mhs": 4.84
}
]
}

143
sim/economy/coexist/market.py Normal file
View file

@ -0,0 +1,143 @@
#!/usr/bin/env python3
# D4 pins: (1) the market-structure axis of the five-year run at the adversary lane's placed energies; (2) the sensitivity
# workbook rows (every threshold with its assumptions). Reuses coexist2.py's population and cost rows. All modelled.
import sys, math
sys.argv = [sys.argv[0]]
_src = open(__import__('os').path.join(__import__('os').path.dirname(__import__('os').path.abspath(__file__)), 'coexist2.py')).read()
exec(_src.split('print("=== T1.')[0])
_i = _src.index('def gpu_hash'); _j = _src.index('for pname, path in paths.items():')
exec(_src[_i:_j])
E_LOCK = 2.33 # the 5090 class v5 floor at the lock, uJ
# the three chips at the adversary lane's PLACED whole-machine energies (10.0r): node-for-node / a node ahead; per-dollar unchanged
CH = { # the adversary lane's FINAL placed energies and corrected tickets (18:xx UK): complete machines, USD per MH/s as given (no system markup added)
"board": dict(uj=E_LOCK / 1.5, uj_ahead=E_LOCK / 1.8, usd=4.84, label="GDDR7 machine, placed 1.5x / 1.8x, USD 4.84"),
"hybrid": dict(uj=E_LOCK / 1.93, uj_ahead=E_LOCK / 2.40, usd=2.80, label="stored-half hybrid, mean hit 0.581, 1.93x / 2.40x, USD 2.80"),
"hybrid98": dict(uj=E_LOCK / 2.09, uj_ahead=E_LOCK / 2.60, usd=1.88, label="hybrid at the p98 program, 2.09x, USD 1.88"),
"die": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=2.94, label="N2 SRAM die, 2.3x / 3.1x, USD 2.94"),
"die_small": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=2.14, label="N2 SRAM die at the smaller ticket, USD 2.14"),
"die_rec": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=1.0, label="N2 SRAM die, RECONCILED USD 1.0 (1 to 1.5 kW machine)"),
"die_lo": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=0.5, label="N2 SRAM die, reconciled low bound USD 0.5"),
"die_hi": dict(uj=E_LOCK / 2.3, uj_ahead=E_LOCK / 3.1, usd=1.6, label="N2 SRAM die, reconciled high bound USD 1.6"),
}
STRUCT = { # markup on the chip's hardware term for the buyer; yearly production cap as a multiple of the budget; suppliers
"private supply (self-mining, fixed fleet)": dict(markup=1.0, cap_mult=0.0, n=1),
"public hardware sales (one manufacturer)": dict(markup=2.0, cap_mult=1.0, n=1),
"multiple suppliers (three, derivative designs)": dict(markup=1.2, cap_mult=3.0, n=3),
}
def chip_allin(ch, e, life, markup, ahead=False):
uj = ch["uj_ahead"] if ahead else ch["uj"]
hw = ch["usd"] * markup / (life * H) * (1 + 0.03 * life); pw = kwh(uj) * (e + HOST_FARM)
return (hw + pw) / ACCEPT / (1 - POOL_FEE)
def solve_joint(R, year, ch, st, F_fixed, installed, cap_year):
"""r such that R/H = r x (GPU hash(r) + chip hash(r)). Private: chip hash = F_fixed. Sales and multiple: the installed
(sunk) chip fleet stays while r covers its power; new units are bought this year up to cap_year as r rises from the
buyer's all-in to twice it (a supply ramp). Returns r, GPU hash, chip hash, new units bought."""
c_entry = chip_allin(ch, 0.06, 3, st["markup"], ahead=(year >= 4))
c_power = kwh(ch["uj_ahead"] if year >= 4 else ch["uj"]) * (0.06 + HOST_FARM) / ACCEPT / (1 - POOL_FEE)
def chip_hash(r):
if st["cap_mult"] == 0.0: return F_fixed, 0.0
stay = installed if r > c_power else 0.0
new = cap_year * min(1.0, max(0.0, (r - c_entry) / c_entry))
return stay + new, new
lo, hi = 1e-7, 1e-1
for _ in range(80):
mid = math.sqrt(lo * hi)
tot = gpu_hash(mid, year) + chip_hash(mid)[0]
if tot <= 0 or R / H / tot > mid: lo = mid
else: hi = mid
r = hi; hc, new = chip_hash(r)
return r, gpu_hash(r, year), hc, new
print("=== M1. the market-structure axis: five years, three chips x three structures, budget USD 10 M (a fleet, or a year's production), entry at year 2 ===")
print("chip | structure | path | y2 chip share / margin / largest single supplier share / GPU classes | y3 | y5")
for cname, ch in CH.items():
for sname, st in STRUCT.items():
for pname, path in paths.items():
cells = []
F = 10e6 / ch["usd"]; installed = 0.0
for y in range(1, 6):
Fy = F if (y >= 2 and st["cap_mult"] == 0.0) else 0.0
cap_year = F * st["cap_mult"] if y >= 2 else 0.0
r, Hg, Hc, new = solve_joint(MINER[y] * path(y), y, ch, st, Fy, installed, cap_year)
installed += new
tot = Hg + Hc
share = Hc / tot if tot > 0 else 0.0
c3 = chip_allin(ch, 0.06, 3, 1.0, ahead=(y >= 4))
margin = (r - c3) / r if r > 0 else 0.0
conc = share / st["n"]
cls = sum(1 for c in POP if r > owner_cost(c, 0.12) * (0.75 if y >= 3 else 1.0))
cells.append((y, share * 100, margin * 100, conc * 100, cls))
def f(c): return f"{c[1]:4.0f}% / {c[2]:4.0f}% / {c[3]:4.0f}% / {c[4]:2d}"
print(f"{cname:6s} | {sname:46s} | {pname:26s} | {f(cells[1])} | {f(cells[2])} | {f(cells[4])}")
print("\n=== M2. the chips at the placed energies: cost per accepted MH/s-hour (sunk, 3 y) and the conditions (a), (b), (e) ===")
best_owner = min(owner_cost(c, 0.12) for c in POP[:6]); hw5080 = entrant_cost(POP[1], 0.12)[1]
for cname, ch in CH.items():
for ahead in (False, True):
ct = chip_allin(ch, 0.06, 3, 1.0, ahead); hw = ch["usd"] / (3 * H) * 1.09 / ACCEPT
uj = ch["uj_ahead"] if ahead else ch["uj"]
print(f"{ch['label']:40s} {'a node ahead' if ahead else 'node-for-node'}: {ct*1e6:5.0f} uUSD | (a) {best_owner/ct:.2f}x of the best owner (line 1.5) | (b) hardware {hw/hw5080:.2f} of the 5080 entrant's (line 0.25) | (e) joules {E_LOCK/uj:.2f}x vs the 5090 lock, {1.70/uj:.2f}x vs the 5070 Ti knee (line 3)")
print("\n=== M3. condition (c) at the final tickets: a third of the chain's hash in USD M vs a year's miner revenue ===")
for cname, ch in CH.items():
cells=[]
for p in (0.03, 0.1, 0.3, 1.0):
r, Hg = solve(MINER[3] * p, 0.0, 3); third = Hg / 3 * ch["usd"]
cells.append(f"IGN {p}: {third/1e6:5.1f} M vs {MINER[3]*p/1e6:4.0f} M ({MINER[3]*p/third:4.1f}x short)")
print(f"{ch['label']:55s} | " + " | ".join(cells))
print("\n=== W. the sensitivity workbook rows (tab-separated) ===")
rev_pv = 0.85e9
def pstar(C, t0, life, q, e, cap=0.5, disc=0.10, ship_months=24):
rev = {1: 0.77e9, 2: 0.80e9, 3: 0.40e9, 4: 0.40e9, 5: 0.20e9, 6: 0.20e9, 7: 0.10e9, 8: 0.10e9}
m = max(0.0, 1 - (0.000084 / e + cap / (life * H)) / 0.00092)
def npv(p):
tot = -C; y = t0 + 1; rem = life
while rem > 0:
fr = min(1.0, rem); tot += q * m * rev.get(y, 0.05e9) * p * fr / (1 + disc) ** (y - 0.5); rem -= fr; y += 1
return tot
lo, hi = 1e-4, 1e3
for _ in range(80):
mid = math.sqrt(lo * hi)
if npv(mid) > 0: hi = mid
else: lo = mid
return hi
hdr = "figure\tvalue\tunit\tdiscount\tlife_y\tshare_q\tproject_cost_USD_M\tpre_production_y\tedge_per_joule\tchip_capex_USD_per_MHs\tGPU_cost_basis\telectricity_USD_kWh\temission_years\tprice_assumption\tsource_section\tlabel"
print(hdr)
rows = []
# the two revenue thresholds (floor file 4.2 and 4.3; the first-cut surface model: NPV = s(1-1/e) x PV(rev y3..6) - C)
for C, s, e, name in ((20e6, 1.0, 5, "lower threshold: no chip project below"), (75e6, 0.3, 3, "upper threshold: every DRAM-board project above"), (100e6, 1.0, 13, "SRAM project taking the chain"), (150e6, 0.3, 5, "SRAM project at a third")):
p = C / (s * (1 - 1 / e) * rev_pv)
rows.append((name, f"{0.77e9*p/1e6:.0f}", "USD M a year of miner revenue at launch", "0.10", "4 (years 3 to 6)", f"{s}", f"{C/1e6:.0f}", "2", f"{e}x", "n/a (margin 1 - 1/e)", "n/a", "n/a", "y3 to y6 at the constant", f"p* {p:.3f} USD per IGN", "floor 4.2 / 4.3", "modelled"))
rows.append(("development cost range, cheapest DRAM-board chip", "20 to 75", "USD M", "n/a", "n/a", "n/a", "20 to 75", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "floor 4.3 (floor lane 5: no 28 nm GDDR7 PHY)", "approximate"))
# the surface p* rows (floor 4.4 table A)
for C in (20e6, 75e6, 150e6, 500e6):
for t0 in (1, 2):
for life in (0.5, 1, 2, 3):
for q in (0.3, 1.0):
rows.append((f"surface p*, operator self-mining", f"{pstar(C, t0, life, q, 5):.3f}", "USD per IGN", "0.10", f"{life}", f"{q}", f"{C/1e6:.0f}", f"{t0}", "5x", "0.5", "5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h)", "0.06 chip", "T0+1 onward at the constant", "solved", "floor 4.4 A", "modelled"))
for e in (2, 3, 13):
rows.append(("surface p*, edge axis", f"{pstar(150e6, 2, 3, 0.3, e):.3f}", "USD per IGN", "0.10", "3", "0.3", "150", "2", f"{e}x", "0.5", "MSRP basis", "0.06", "constant", "solved", "floor 4.4 A2", "modelled"))
for cap in (2.8, 5.0):
rows.append(("surface p*, chip capex axis", f"{pstar(150e6, 2, 3, 0.3, 5, cap):.3f}", "USD per IGN", "0.10", "3", "0.3", "150", "2", "5x", f"{cap}", "MSRP basis", "0.06", "constant", "solved", "floor 4.4 A2", "modelled"))
for disc in (0.05, 0.15):
rows.append(("surface p*, discount axis", f"{pstar(150e6, 2, 3, 0.3, 5, 0.5, disc):.3f}", "USD per IGN", f"{disc}", "3", "0.3", "150", "2", "5x", "0.5", "MSRP basis", "0.06", "constant", "solved", "this workbook", "modelled"))
rows.append(("surface p*, street GPU prices (capex term x2: GPU all-in 0.00176)", f"{pstar(150e6, 2, 3, 0.3, 5)*0.00092/0.00176:.3f}", "USD per IGN (approximate: p* scales with the GPU all-in cost)", "0.10", "3", "0.3", "150", "2", "5x", "0.5", "street (2x MSRP)", "0.06", "constant", "solved", "this workbook", "approximate"))
# the hybrid rows
for C in (50e6, 125e6, 225e6):
for life in (1, 3):
for q in (0.3, 1.0):
rows.append(("surface p*, the hybrid board", f"{pstar(C, 2, life, q, 2.7, 2.44):.3f}", "USD per IGN", "0.10", f"{life}", f"{q}", f"{C/1e6:.0f}", "2", "2.7x", "2.44", "MSRP basis", "0.06", "constant", "solved", "model 12a", "modelled"))
# break-even electricity rows (model section 3), owner and entrant, all 17 classes, four chip rows
for c in POP:
for chn, ch in (("GDDR7 board", CHIPS[0]), ("SRAM die", CHIPS[2])):
for life in (1, 3):
ct = chip_cost(ch, 0.06, life)[0]
wear = WEAR * c[5] / H / c[3]; hw = (c[4] - c[6] * c[4]) / (2 * H) / c[3]
eo = (ct * ACCEPT * (1 - POOL_FEE) - wear) / kwh(c[1]) * 100; en = (ct * ACCEPT * (1 - POOL_FEE) - hw) / kwh(c[1]) * 100
rows.append((f"break-even electricity, {c[0]} vs {chn} {life} y, owner / entrant", f"{eo:.1f} / {en:.1f}", "cents per kWh", "n/a", f"{life}", "n/a", "sunk", "n/a", f"{c[1]/ch[1]:.1f}x joules", f"{ch[2]:.2f}", f"{c[11]}; used price {c[5]} USD, new {c[4]}, resale {c[6]}", "chip at 0.06 + 0.02 hosting", "n/a", "n/a", "model 3", "modelled"))
# the coexistence thresholds of section 12
rows.append(("condition (a) line", "1.5", "x the best GPU owner's cost at the GPU's electricity", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "owner at 0.12: 263 to 332 uUSD", "0.12 GPU / 0.06 chip", "n/a", "n/a", "model 12", "a judgement line, not a measurement"))
rows.append(("condition (b) line", "0.25", "of the GPU entrant's annualised hardware", "n/a", "2 (GPU)", "n/a", "n/a", "n/a", "n/a", "n/a", "5080 entrant hardware 459 uUSD", "n/a", "n/a", "n/a", "model 12", "a judgement line"))
rows.append(("condition (c) line", "1.0", "years of miner revenue to buy a third of the chain's hash", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "per chip", "GPU equilibrium hash at the per-class curve", "0.12", "year 3", "0.03 to 1.00", "model 12", "a judgement line"))
rows.append(("condition (e) line", "3.0", "x per joule at the honest knee", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "Blackwell knee 1.70 to 2.06 uJ (5070 Ti modelled, 5080 measured)", "n/a", "n/a", "n/a", "model 12", "a judgement line"))
rows.append(("condition (f) line", "0.70", "gross margin, falling with the halvings", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "n/a", "model 12", "a judgement line"))
for r in rows: print("\t".join(r))

181
sim/economy/coexist/opsim.py Normal file
View file

@ -0,0 +1,181 @@
#!/usr/bin/env python3
"""Floor lane 3, Igneum 2.0 D4 item 2: the profit-maximising operator simulation, first run (v2: continuous cohort
shares with partial adjustment and marginal-rate decisions; v1's all-or-nothing cohorts herded and oscillated).
Cohorts = card class x electricity price. Each cohort holds a share of its cards in each of MINE, INTERNAL PROVE,
EXTERNAL PROVE and OFF; each period (one day) it moves a quarter of its cards toward the mode with the best profit per
card-day, evaluated at the MARGINAL rate (the pool divided by the capacity after its own move), with a 10 percent
hysteresis. Nothing is scheduled centrally and no parameter changes by hand inside a run. Rules under test: the tip
stays whole to the miner; provers are paid the 20 percent pool per block (a fixed sum divided by capacity) and an
explicit user-funded proving fee with CONGESTION PRICING for external jobs (the fee rises 25 percent a period while
job latency exceeds a day and falls 10 percent while under half a day, bounded at 100x; demand is elastic to the fee
with exponent 0.5); entry and exit at cost. Measured proving inputs (the fleet lane, Devnet 3, 8 October 2026): the
12 GB tier earned 0 of 313 claims (a measured zero for internal proving); steals 4.0 percent of claims; paid to
wasted card-seconds 14,800 to 254,000 (5.5 percent) on a day with a floor-link fault; PROVE_EFF 0.5 is the assumed
post-fix efficiency, 0.055 the measured day; both run. Everything else modelled: the cost rows are the coexistence
model's (lane 4's class v5 table, street prices), the shard times the bench table's.
"""
import sys
H_DAY = 24.0
MINER_IGN_DAY = 0.77e9 / 365.25
POOL_IGN_DAY = (0.77e9 / 0.8 * 0.2) / 365.25
PRICE0 = 0.10
EXT_USD_DAY0 = 2000.0
USD_PER_SHARD_EQ = 10.0
EXT_ELASTICITY = 0.5
INTERNAL_SHARDS_DAY = 3.0 * 86400
ACCEPT = 0.97
PROVE_EFF = float(sys.argv[1]) if len(sys.argv) > 1 else 0.5
SCALE = float(sys.argv[2]) if len(sys.argv) > 2 else 1.0 # fraction of the available cards that exist in this world
SPIKE = float(sys.argv[3]) if len(sys.argv) > 3 else 10.0 # the external demand multiplier of shock A
INT_CONGESTION = (sys.argv[4] == '1') if len(sys.argv) > 4 else False # the resolution's shape: internal proving also carries a user-funded congestion-priced fee
STEAL = 0.04
IPROVE_MIN_GB = 16
ADJ = 0.25
HYST = 1.10
# name, uJ per hash (floor), MH/s, shard seconds (0 = cannot prove), proving watts, used price, cards available (approximate), memGB
CLASSES = [
("5090", 2.33, 134.8, 6.3, 300, 2200, 25000, 32),
("5080", 2.06, 71.2, 8.0, 220, 900, 40000, 16),
("5070Ti", 1.70, 77.0, 7.0, 200, 650, 50000, 16),
("5070", 1.75, 41.0, 4.8, 140, 450, 75000, 12),
("5060Ti", 2.36, 19.0, 11.6, 90, 360, 50000, 16),
("5060", 2.21, 17.0, 12.0, 80, 250, 75000, 8),
("4090", 3.58, 58.0, 6.3, 280, 1300, 75000, 24),
("4080", 3.51, 45.0, 7.5, 220, 700, 50000, 16),
("4070", 3.58, 31.1, 12.1, 110, 400, 150000, 12),
("4060Ti", 3.81, 17.6, 11.6, 75, 290, 100000, 16),
("3090", 4.51, 37.8, 14.9, 230, 650, 50000, 24),
("3080", 4.20, 40.8, 7.1, 210, 330, 150000, 10),
("3060", 5.77, 23.8, 14.4, 105, 190, 300000, 12),
("9070XT", 7.90, 18.9, 0.0, 150, 520, 25000, 16),
("H100", 2.00, 90.0, 3.0, 350, 18000, 2000, 80),
("A100", 2.89, 60.0, 5.0, 250, 6000, 2000, 80),
("M5Max", 1.40, 27.1, 0.0, 40, 3200, 15000, 36),
]
ELEC = (0.06, 0.12, 0.25)
MODES = ("mine", "iprove", "eprove", "off")
CHIP_MHS = 1.0e6 # a sunk 1 TH/s SRAM die fleet (D1)
ENTRANT_ECAP = 2000.0 # (served at a tenth of the GPU cost; it takes the work at any fee above its cost) # a proving ASIC entrant: 2,000 shard-eq a day at a tenth of the cost (D2)
def mine_cost(c, e): return c[1] * 1e-3 * c[2] * H_DAY * e + 0.05 * c[5] / 365.25
def prove_cost(c, e): return c[4] / 1000 * H_DAY * e + 0.05 * c[5] / 365.25
def prove_cap(c): return (86400 / c[3]) * PROVE_EFF * (1 - STEAL) if c[3] else 0.0
class World:
def __init__(self):
self.price = PRICE0; self.ext = EXT_USD_DAY0; self.fee = 1.0
self.bl_int = 0.0; self.bl_ext = 0.0
self.chip = False; self.entrant = False; self.offline = set(); self.ifee = 1.0
self.share = {(c[0], e): {"mine": 0.0, "iprove": 0.0, "eprove": 0.0, "off": 1.0} for c in CLASSES for e in ELEC}
def n(self, c): return c[6] * SCALE / len(ELEC)
def step(self, t):
hash_mhs = icap = ecap = 0.0
for c in CLASSES:
for e in ELEC:
k = (c[0], e)
if k in self.offline: continue
s = self.share[k]; n = self.n(c)
hash_mhs += n * s["mine"] * c[2]
if c[7] >= IPROVE_MIN_GB: icap += n * s["iprove"] * prove_cap(c)
ecap += n * s["eprove"] * prove_cap(c)
chip_hash = CHIP_MHS if self.chip else 0.0
ent_cap = ENTRANT_ECAP if self.entrant else 0.0
total_hash = hash_mhs + chip_hash
total_ecap = ecap + ent_cap
# internal proving: the pool is fixed; a backlog accrues when capacity is short
done_int = min(icap, INTERNAL_SHARDS_DAY + self.bl_int)
self.bl_int = max(0.0, self.bl_int + INTERNAL_SHARDS_DAY - done_int)
if INT_CONGESTION:
# a user-funded internal proving fee on top of the pool: rises 25 percent a period while the internal backlog
# exceeds a day of demand, falls 10 percent while under half a day; bounded 1x to 100x of the pool's per-shard rate
if self.bl_int > INTERNAL_SHARDS_DAY: self.ifee = min(100.0, self.ifee * 1.25)
elif self.bl_int < 0.5 * INTERNAL_SHARDS_DAY: self.ifee = max(1.0, self.ifee * 0.9)
# external: volume elastic to the congestion fee; revenue = volume x fee
base_work = self.ext / USD_PER_SHARD_EQ
work = base_work * self.fee ** (-EXT_ELASTICITY)
usd = work * USD_PER_SHARD_EQ * self.fee
done_ext = min(total_ecap, work + self.bl_ext)
self.bl_ext = max(0.0, self.bl_ext + work - done_ext)
latency = self.bl_ext / total_ecap if total_ecap > 0 else (99.0 if self.bl_ext > 0 else 0.0)
if latency > 1.0: self.fee = min(100.0, self.fee * 1.25)
elif latency < 0.5: self.fee = max(1.0, self.fee * 0.9)
# realised rates
r_mine = MINER_IGN_DAY * self.price / max(total_hash, 1e-9) # USD per MH/s-day
pool_usd = POOL_IGN_DAY * self.price * (self.ifee if INT_CONGESTION else 1.0)
r_ip = pool_usd / max(icap, 1e-9) # USD per shard-eq
paid_ext = 0.9 * usd * (done_ext / max(work + self.bl_ext, 1e-9))
r_ep = paid_ext / max(total_ecap, 1e-9) if total_ecap > 0 else 0.9 * usd # per shard-eq; if nobody proves, the first unit gets it all
# decisions at the MARGINAL rate: the pool divided by capacity after the cohort's own move
moves = 0.0
for c in CLASSES:
for e in ELEC:
k = (c[0], e)
if k in self.offline: continue
s = self.share[k]; n = self.n(c); dn = n * ADJ
mc = mine_cost(c, e); pc = prove_cost(c, e); pcap = prove_cap(c)
prof = {"off": 0.0,
"mine": MINER_IGN_DAY * self.price / (total_hash + dn * c[2] * (1 - s["mine"])) * c[2] * ACCEPT - mc}
if pcap > 0:
# marginal external rate: the fee per unit of work, scaled down when capacity after the move exceeds the work on offer
add = dn * pcap * (1 - s["eprove"])
fill = min(1.0, (work + self.bl_ext) / (total_ecap + add + 1e-9))
prof["eprove"] = 0.9 * USD_PER_SHARD_EQ * self.fee * fill * pcap * ACCEPT - pc
if c[7] >= IPROVE_MIN_GB:
prof["iprove"] = pool_usd / (icap + dn * pcap * (1 - s["iprove"]) + 1e-9) * pcap * ACCEPT - pc
best = max(prof, key=prof.get)
# current weighted profit
cur = sum(s[m] * prof.get(m, 0.0) for m in MODES)
if prof[best] > cur * HYST + 1e-9 or (cur <= 0 and prof[best] > 0):
for m in MODES:
if m != best:
mv = s[m] * ADJ; s[m] -= mv; s[best] += mv; moves += mv * n
modes = {m: sum(self.share[k][m] * self.n(c) for c in CLASSES for e in ELEC for k in [(c[0], e)] if k not in self.offline) for m in MODES}
return dict(ifee=self.ifee, hash=total_hash / 1e6, gpu=hash_mhs / 1e6, icap=icap, bl_int=self.bl_int, ecap=total_ecap, bl_ext=self.bl_ext,
lat=latency, fee=self.fee, r_mine=r_mine * 1e6 / 24, r_ep=r_ep, moves=moves, modes={m: int(v) for m, v in modes.items()})
def ok(s, base):
# absolute service test: external job latency under a day, internal backlog under a day of demand, internal capacity
# at least the demand, block production at least a fifth of the baseline hash
return (s["bl_int"] <= INTERNAL_SHARDS_DAY and s["lat"] <= 1.0
and s["hash"] >= 0.2 * base["hash"] and s["icap"] >= INTERNAL_SHARDS_DAY)
def run(name, apply, periods=150, warmup=90):
w = World(); base = None
for t in range(warmup): base = w.step(t)
rows = []; restored = None; worst = None
for t in range(periods):
if t == 0: apply(w)
s = w.step(warmup + t); rows.append(s)
if worst is None or s["lat"] > worst["lat"] or s["bl_int"] > worst["bl_int"]: worst = s
# restored = the first period from which service holds to the end of the run (sustained), else NOT restored
oks = [ok(r, base) for r in rows]
restored = None
for t in range(periods):
if all(oks[t:]): restored = t; break
print(f"=== {name} ===")
print(f" baseline (t-1): hash {base['hash']:.2f} TH/s, int cap {base['icap']:.0f} vs demand {INTERNAL_SHARDS_DAY:.0f} (backlog {base['bl_int']:.0f}), ext cap {base['ecap']:.0f} vs work {EXT_USD_DAY0/USD_PER_SHARD_EQ:.0f}/d, latency {base['lat']:.2f} d, fee x{base['fee']:.2f}, r_mine {base['r_mine']:.0f} uUSD/MH/s-h, cards {base['modes']}")
for t in (0, 1, 3, 7, 14, 30, 60, periods - 1):
s = rows[t]
print(f" t+{t:3d}: hash {s['hash']:6.2f} (GPU {s['gpu']:6.2f}) | int cap {s['icap']:9.0f} bl {s['bl_int']:9.0f} | ext cap {s['ecap']:7.0f} bl {s['bl_ext']:6.0f} lat {s['lat']:5.2f} fee x{s['fee']:6.2f} ifee x{s['ifee']:5.1f} r_ep {s['r_ep']:6.1f} | r_mine {s['r_mine']:5.0f} | cards {s['modes']} moved {s['moves']:.0f}")
print(f" RESULT: {('restored after ' + str(restored) + ' periods') if restored is not None else 'NOT restored within ' + str(periods) + ' periods'}; worst latency {worst['lat']:.2f} d, worst internal backlog {worst['bl_int']:.0f}; no parameter changed by hand")
return restored
def main():
print(f"Operator simulation v2 (INT_CONGESTION {INT_CONGESTION}, SCALE {SCALE} of the available cards, PROVE_EFF {PROVE_EFF}, steals {STEAL}, internal proving needs {IPROVE_MIN_GB} GB: the 12 GB tier a measured zero). Price USD {PRICE0}/IGN (assumption); miners {MINER_IGN_DAY/1e6:.2f} M IGN/day, pool {POOL_IGN_DAY/1e6:.2f} M; external USD {EXT_USD_DAY0}/day at the base fee (USD {USD_PER_SHARD_EQ} per shard-eq), 90 percent to provers, elasticity {EXT_ELASTICITY}; fee bounded 1x to 100x.")
res = {}
def spike(w): w.ext = EXT_USD_DAY0 * SPIKE
res[f"A proving demand spike x{SPIKE:.0f} (lasting)"] = run(f"A: external proving demand x{SPIKE:.0f} (lasting)", spike)
res["B token price x0.3"] = run("B: token price falls to 0.3x", lambda w: setattr(w, "price", PRICE0 * 0.3))
def leave(w):
for e in ELEC:
for k in ("H100", "4090", "5090", "5080", "3090", "A100"): w.offline.add((k, e))
res["C the H100, A100, 5090, 5080, 4090 and 3090 cohorts leave"] = run("C: the six largest proving cohorts leave for good", leave)
res["D1 a 1 TH/s sunk SRAM fleet enters mining"] = run("D1: a 1 TH/s sunk SRAM die fleet enters mining", lambda w: setattr(w, "chip", True))
res["D2 a proving ASIC entrant (2,000 shard-eq/day)"] = run("D2: a proving ASIC entrant", lambda w: setattr(w, "entrant", True))
print("\n=== summary ===")
for k, v in res.items():
print(f"{k}: {('restored in ' + str(v) + ' periods') if v is not None else 'NOT restored in 150 periods'}")
if __name__ == "__main__":
main()

2593
sim/economy/coexist/out/eco05-cube-eff0055.tsv Normal file
View file

File diff suppressed because it is too large Load diff

2593
sim/economy/coexist/out/eco05-cube-eff050.tsv Normal file
View file

File diff suppressed because it is too large Load diff

70
sim/economy/coexist/out/eco05-summary-eff0055.txt Normal file
View file

@ -0,0 +1,70 @@
SUSTAIN revenue tariff demand sustainable r_uUSD gpu_TH n_entry n_vendors op_ok_pct
SUSTAIN 0.25R 0.03 none 0 321 4.32 7 1 95
SUSTAIN 0.25R 0.03 normal 0 321 4.32 9 1 95
SUSTAIN 0.25R 0.03 spiking 0 321 4.32 13 1 95
SUSTAIN 0.25R 0.1 none 0 467 2.97 7 1 57
SUSTAIN 0.25R 0.1 normal 0 467 2.97 9 1 91
SUSTAIN 0.25R 0.1 spiking 0 467 2.97 13 1 91
SUSTAIN 0.25R 0.25 none 0 710 1.96 7 1 45
SUSTAIN 0.25R 0.25 normal 0 710 1.96 9 1 68
SUSTAIN 0.25R 0.25 spiking 0 710 1.96 13 1 91
SUSTAIN 0.25R 0.4 none 0 951 1.46 7 1 39
SUSTAIN 0.25R 0.4 normal 0 951 1.46 9 1 45
SUSTAIN 0.25R 0.4 spiking 0 951 1.46 13 1 91
SUSTAIN R 0.03 none 0 476 12.81 11 1 99
SUSTAIN R 0.03 normal 0 476 12.81 14 1 99
SUSTAIN R 0.03 spiking 0 476 12.81 15 1 99
SUSTAIN R 0.1 none 0 604 10.12 11 1 68
SUSTAIN R 0.1 normal 0 604 10.12 12 1 91
SUSTAIN R 0.1 spiking 0 604 10.12 15 1 91
SUSTAIN R 0.25 none 0 873 6.37 10 1 45
SUSTAIN R 0.25 normal 0 873 6.37 12 1 68
SUSTAIN R 0.25 spiking 0 873 6.37 15 1 91
SUSTAIN R 0.4 none 0 1079 5.15 10 1 45
SUSTAIN R 0.4 normal 0 1079 5.15 12 1 45
SUSTAIN R 0.4 spiking 0 1079 5.15 15 1 91
SUSTAIN 4R 0.03 none 0 833 30.87 14 1 100
SUSTAIN 4R 0.03 normal 0 833 30.87 15 1 100
SUSTAIN 4R 0.03 spiking 0 833 30.87 15 1 100
SUSTAIN 4R 0.1 none 0 1028 21.94 12 1 98
SUSTAIN 4R 0.1 normal 0 1028 21.94 15 1 98
SUSTAIN 4R 0.1 spiking 0 1028 21.94 15 1 98
SUSTAIN 4R 0.25 none 0 1316 16.88 12 1 69
SUSTAIN 4R 0.25 normal 0 1316 16.88 13 1 92
SUSTAIN 4R 0.25 spiking 0 1316 16.88 15 1 92
SUSTAIN 4R 0.4 none 0 1530 14.63 12 1 46
SUSTAIN 4R 0.4 normal 0 1530 14.63 12 1 69
SUSTAIN 4R 0.4 spiking 0 1530 14.63 15 1 92
SUSTAIN 10R 0.03 none 1 1284 43.27 17 3 100
SUSTAIN 10R 0.03 normal 1 1284 43.27 17 3 100
SUSTAIN 10R 0.03 spiking 1 1284 43.27 17 3 100
SUSTAIN 10R 0.1 none 0 1354 41.04 15 1 100
SUSTAIN 10R 0.1 normal 0 1354 41.04 15 1 100
SUSTAIN 10R 0.1 spiking 0 1354 41.04 15 1 100
SUSTAIN 10R 0.25 none 0 1887 30.75 13 1 97
SUSTAIN 10R 0.25 normal 0 1887 30.75 15 1 97
SUSTAIN 10R 0.25 spiking 0 1887 30.75 15 1 97
SUSTAIN 10R 0.4 none 0 2301 25.33 13 1 69
SUSTAIN 10R 0.4 normal 0 2301 25.33 14 1 92
SUSTAIN 10R 0.4 spiking 0 2301 25.33 15 1 92
SUMMARY spec sustainable_worlds pass_all pass_median pass_p90 pass_core median_min median_max core_max_max
SUMMARY die 54 0 6 0 0 1.03 11.74 23.59
SUMMARY hybrid 54 0 12 0 6 0.69 6.75 13.55
SUMMARY board 54 0 21 0 12 0.50 4.41 8.86
ADV combination spec revenue median p90 core_max sustainable
ADV 1 die at USD 0.5, a node ahead, dev zero, private, GPU 0.40 vs specialist 0.03 die R 42.14 95.10 85.83 0
ADV 2 die taking the whole chain (dev USD 75 M over 100 pct), private, 0.10 die R 2.71 10.55 4.79 0
ADV 3 hardware sales at zero development, die, 0.10 die R 5.89 22.95 10.41 0
ADV 4 GPU entrant at street, die at 1.0, 0.10 die R 7.10 28.79 12.31 0
ADV 5 GPU generation 1.5x vs die a node ahead, 0.10 die R 8.03 35.21 15.03 0
ADV 6 spiking demand at the measured 5.5 pct proving efficiency, die, 0.10 die R (run with argv[1] = 0.055)
ADV 7 die at USD 1.6 (the dear end), 0.10 die R 6.41 24.97 11.33 0
ADV 8 board at street GPU prices, 0.25 board R 2.90 7.98 5.66 0
ADV 1 die at USD 0.5, a node ahead, dev zero, private, GPU 0.40 vs specialist 0.03 die 4R 42.14 95.10 85.83 0
ADV 2 die taking the whole chain (dev USD 75 M over 100 pct), private, 0.10 die 4R 4.11 16.01 7.27 0
ADV 3 hardware sales at zero development, die, 0.10 die 4R 5.89 22.95 10.41 0
ADV 4 GPU entrant at street, die at 1.0, 0.10 die 4R 7.10 28.79 12.31 0
ADV 5 GPU generation 1.5x vs die a node ahead, 0.10 die 4R 8.03 35.21 15.03 0
ADV 6 spiking demand at the measured 5.5 pct proving efficiency, die, 0.10 die 4R (run with argv[1] = 0.055)
ADV 7 die at USD 1.6 (the dear end), 0.10 die 4R 6.41 24.97 11.33 0
ADV 8 board at street GPU prices, 0.25 board 4R 2.90 7.98 5.66 0

181
sim/economy/coexist/out/eco05-summary-eff050.txt Normal file
View file

@ -0,0 +1,181 @@
SUSTAIN revenue tariff demand sustainable r_uUSD gpu_TH n_entry n_vendors op_ok_pct
SUSTAIN 0.25R 0.03 none 0 321 4.32 7 1 95
SUSTAIN 0.25R 0.03 normal 0 321 4.32 9 1 95
SUSTAIN 0.25R 0.03 spiking 0 321 4.32 13 1 95
SUSTAIN 0.25R 0.1 none 0 467 2.97 7 1 57
SUSTAIN 0.25R 0.1 normal 0 467 2.97 9 1 91
SUSTAIN 0.25R 0.1 spiking 0 467 2.97 13 1 91
SUSTAIN 0.25R 0.25 none 0 710 1.96 7 1 45
SUSTAIN 0.25R 0.25 normal 0 710 1.96 9 1 68
SUSTAIN 0.25R 0.25 spiking 0 710 1.96 13 1 91
SUSTAIN 0.25R 0.4 none 0 951 1.46 7 1 39
SUSTAIN 0.25R 0.4 normal 0 951 1.46 9 1 45
SUSTAIN 0.25R 0.4 spiking 0 951 1.46 13 1 91
SUSTAIN R 0.03 none 0 476 12.81 11 1 99
SUSTAIN R 0.03 normal 0 476 12.81 14 1 99
SUSTAIN R 0.03 spiking 0 476 12.81 15 1 99
SUSTAIN R 0.1 none 0 604 10.12 11 1 68
SUSTAIN R 0.1 normal 0 604 10.12 12 1 91
SUSTAIN R 0.1 spiking 0 604 10.12 15 1 91
SUSTAIN R 0.25 none 0 873 6.37 10 1 45
SUSTAIN R 0.25 normal 0 873 6.37 12 1 68
SUSTAIN R 0.25 spiking 0 873 6.37 15 1 91
SUSTAIN R 0.4 none 0 1079 5.15 10 1 45
SUSTAIN R 0.4 normal 0 1079 5.15 12 1 45
SUSTAIN R 0.4 spiking 0 1079 5.15 15 1 91
SUSTAIN 4R 0.03 none 0 833 30.87 14 1 100
SUSTAIN 4R 0.03 normal 0 833 30.87 15 1 100
SUSTAIN 4R 0.03 spiking 0 833 30.87 15 1 100
SUSTAIN 4R 0.1 none 0 1028 21.94 12 1 98
SUSTAIN 4R 0.1 normal 0 1028 21.94 15 1 98
SUSTAIN 4R 0.1 spiking 0 1028 21.94 15 1 98
SUSTAIN 4R 0.25 none 0 1316 16.88 12 1 69
SUSTAIN 4R 0.25 normal 0 1316 16.88 13 1 92
SUSTAIN 4R 0.25 spiking 0 1316 16.88 15 1 92
SUSTAIN 4R 0.4 none 0 1530 14.63 12 1 46
SUSTAIN 4R 0.4 normal 0 1530 14.63 12 1 69
SUSTAIN 4R 0.4 spiking 0 1530 14.63 15 1 92
SUSTAIN 10R 0.03 none 1 1284 43.27 17 3 100
SUSTAIN 10R 0.03 normal 1 1284 43.27 17 3 100
SUSTAIN 10R 0.03 spiking 1 1284 43.27 17 3 100
SUSTAIN 10R 0.1 none 0 1354 41.04 15 1 100
SUSTAIN 10R 0.1 normal 0 1354 41.04 15 1 100
SUSTAIN 10R 0.1 spiking 0 1354 41.04 15 1 100
SUSTAIN 10R 0.25 none 0 1887 30.75 13 1 97
SUSTAIN 10R 0.25 normal 0 1887 30.75 15 1 97
SUSTAIN 10R 0.25 spiking 0 1887 30.75 15 1 97
SUSTAIN 10R 0.4 none 0 2301 25.33 13 1 69
SUSTAIN 10R 0.4 normal 0 2301 25.33 14 1 92
SUSTAIN 10R 0.4 spiking 0 2301 25.33 15 1 92
SUMMARY spec sustainable_worlds pass_all pass_median pass_p90 pass_core median_min median_max core_max_max
SUMMARY die 54 0 6 0 0 1.03 11.74 23.59
SUMMARY hybrid 54 0 12 0 6 0.69 6.75 13.55
SUMMARY board 54 0 21 0 12 0.50 4.41 8.86
BOUNDARY spec revenue tariff_0.03 tariff_0.10 tariff_0.25 tariff_0.40 (median ratio; life 3, dev zero, private, normal demand; * = sustainable)
BOUNDARY die 0.25R 9.80 7.38 5.80 5.26 | consumer-16 median 9.28 / 7.22 / 5.55 / 4.88 | best core 5.14 / 3.87 / 2.98 / 2.67
BOUNDARY die R 9.80 7.38 5.80 5.26 | consumer-16 median 9.28 / 7.22 / 5.55 / 4.88 | best core 5.14 / 3.87 / 2.98 / 2.67
BOUNDARY die 4R 9.80 7.38 5.80 5.26 | consumer-16 median 9.28 / 7.22 / 5.55 / 4.88 | best core 5.14 / 3.87 / 2.98 / 2.67
BOUNDARY die 10R 9.80* 7.38 5.80 5.26 | consumer-16 median 9.28 / 7.22 / 5.55 / 4.88 | best core 5.14 / 3.87 / 2.98 / 2.67
BOUNDARY hybrid 0.25R 5.12 4.61 4.13 3.94 | consumer-16 median 4.84 / 4.51 / 3.95 / 3.66 | best core 2.68 / 2.42 / 2.12 / 2.00
BOUNDARY hybrid R 5.12 4.61 4.13 3.94 | consumer-16 median 4.84 / 4.51 / 3.95 / 3.66 | best core 2.68 / 2.42 / 2.12 / 2.00
BOUNDARY hybrid 4R 5.12 4.61 4.13 3.94 | consumer-16 median 4.84 / 4.51 / 3.95 / 3.66 | best core 2.68 / 2.42 / 2.12 / 2.00
BOUNDARY hybrid 10R 5.12* 4.61 4.13 3.94 | consumer-16 median 4.84 / 4.51 / 3.95 / 3.66 | best core 2.68 / 2.42 / 2.12 / 2.00
BOUNDARY board 0.25R 3.24 3.11 2.95 2.88 | consumer-16 median 3.07 / 3.04 / 2.82 / 2.67 | best core 1.70 / 1.63 / 1.51 / 1.46
BOUNDARY board R 3.24 3.11 2.95 2.88 | consumer-16 median 3.07 / 3.04 / 2.82 / 2.67 | best core 1.70 / 1.63 / 1.51 / 1.46
BOUNDARY board 4R 3.24 3.11 2.95 2.88 | consumer-16 median 3.07 / 3.04 / 2.82 / 2.67 | best core 1.70 / 1.63 / 1.51 / 1.46
BOUNDARY board 10R 3.24* 3.11 2.95 2.88 | consumer-16 median 3.07 / 3.04 / 2.82 / 2.67 | best core 1.70 / 1.63 / 1.51 / 1.46
HETERO spec revenue gpu_tariff median p90 core_max (specialist at 0.03; life 3, dev zero, private, normal)
HETERO die 0.25R 0.03 9.80 49.65 19.69
HETERO die 0.25R 0.1 13.07 50.94 23.12
HETERO die 0.25R 0.25 19.84 53.71 37.40
HETERO die 0.25R 0.4 26.68 60.20 54.33
HETERO die R 0.03 9.80 49.65 19.69
HETERO die R 0.1 13.07 50.94 23.12
HETERO die R 0.25 19.84 53.71 37.40
HETERO die R 0.4 26.68 60.20 54.33
HETERO die 4R 0.03 9.80 49.65 19.69
HETERO die 4R 0.1 13.07 50.94 23.12
HETERO die 4R 0.25 19.84 53.71 37.40
HETERO die 4R 0.4 26.68 60.20 54.33
HETERO die 10R 0.03 9.80 49.65 19.69
HETERO die 10R 0.1 13.07 50.94 23.12
HETERO die 10R 0.25 19.84 53.71 37.40
HETERO die 10R 0.4 26.68 60.20 54.33
HETERO hybrid 0.25R 0.03 5.12 25.92 10.28
HETERO hybrid 0.25R 0.1 6.82 26.59 12.07
HETERO hybrid 0.25R 0.25 10.36 28.04 19.52
HETERO hybrid 0.25R 0.4 13.93 31.43 28.37
HETERO hybrid R 0.03 5.12 25.92 10.28
HETERO hybrid R 0.1 6.82 26.59 12.07
HETERO hybrid R 0.25 10.36 28.04 19.52
HETERO hybrid R 0.4 13.93 31.43 28.37
HETERO hybrid 4R 0.03 5.12 25.92 10.28
HETERO hybrid 4R 0.1 6.82 26.59 12.07
HETERO hybrid 4R 0.25 10.36 28.04 19.52
HETERO hybrid 4R 0.4 13.93 31.43 28.37
HETERO hybrid 10R 0.03 5.12 25.92 10.28
HETERO hybrid 10R 0.1 6.82 26.59 12.07
HETERO hybrid 10R 0.25 10.36 28.04 19.52
HETERO hybrid 10R 0.4 13.93 31.43 28.37
HETERO board 0.25R 0.03 3.24 16.43 6.52
HETERO board 0.25R 0.1 4.33 16.86 7.65
HETERO board 0.25R 0.25 6.57 17.78 12.38
HETERO board 0.25R 0.4 8.83 19.92 17.98
HETERO board R 0.03 3.24 16.43 6.52
HETERO board R 0.1 4.33 16.86 7.65
HETERO board R 0.25 6.57 17.78 12.38
HETERO board R 0.4 8.83 19.92 17.98
HETERO board 4R 0.03 3.24 16.43 6.52
HETERO board 4R 0.1 4.33 16.86 7.65
HETERO board 4R 0.25 6.57 17.78 12.38
HETERO board 4R 0.4 8.83 19.92 17.98
HETERO board 10R 0.03 3.24 16.43 6.52
HETERO board 10R 0.1 4.33 16.86 7.65
HETERO board 10R 0.25 6.57 17.78 12.38
HETERO board 10R 0.4 8.83 19.92 17.98
ADV combination spec revenue median p90 core_max sustainable
ADV 1 die at USD 0.5, a node ahead, dev zero, private, GPU 0.40 vs specialist 0.03 die R 42.14 95.10 85.83 0
ADV 2 die taking the whole chain (dev USD 75 M over 100 pct), private, 0.10 die R 2.71 10.55 4.79 0
ADV 3 hardware sales at zero development, die, 0.10 die R 5.89 22.95 10.41 0
ADV 4 GPU entrant at street, die at 1.0, 0.10 die R 7.10 28.79 12.31 0
ADV 5 GPU generation 1.5x vs die a node ahead, 0.10 die R 8.03 35.21 15.03 0
ADV 6 spiking demand at the measured 5.5 pct proving efficiency, die, 0.10 die R (run with argv[1] = 0.055)
ADV 7 die at USD 1.6 (the dear end), 0.10 die R 6.41 24.97 11.33 0
ADV 8 board at street GPU prices, 0.25 board R 2.90 7.98 5.66 0
ADV 1 die at USD 0.5, a node ahead, dev zero, private, GPU 0.40 vs specialist 0.03 die 4R 42.14 95.10 85.83 0
ADV 2 die taking the whole chain (dev USD 75 M over 100 pct), private, 0.10 die 4R 4.11 16.01 7.27 0
ADV 3 hardware sales at zero development, die, 0.10 die 4R 5.89 22.95 10.41 0
ADV 4 GPU entrant at street, die at 1.0, 0.10 die 4R 7.10 28.79 12.31 0
ADV 5 GPU generation 1.5x vs die a node ahead, 0.10 die 4R 8.03 35.21 15.03 0
ADV 6 spiking demand at the measured 5.5 pct proving efficiency, die, 0.10 die 4R (run with argv[1] = 0.055)
ADV 7 die at USD 1.6 (the dear end), 0.10 die 4R 6.41 24.97 11.33 0
ADV 8 board at street GPU prices, 0.25 board 4R 2.90 7.98 5.66 0
EXPLAIN spec revenue tariff worst_core_class ratio gpu_entrant_uUSD spec_uUSD spec_hw spec_pw median_class median_gpu_uUSD best_core proving_income
EXPLAIN die 0.25R 0.03 RTX 3090 (used) 19.69 1889 96 43 52 RTX 3080 (used) 940 best core RTX 5090 5.14 (493) proving income best core 848 uUSD/MH/s-h
EXPLAIN die 0.25R 0.1 RTX 3090 (used) 13.06 2217 170 43 125 RTX 3060 (used) 1254 best core RTX 5080 3.87 (656) proving income best core 1265 uUSD/MH/s-h
EXPLAIN die 0.25R 0.25 Intel Arc B580 10.93 3587 328 43 282 RTX 3080 (used) 1902 best core RTX 5080 2.98 (978) proving income best core 1265 uUSD/MH/s-h
EXPLAIN die 0.25R 0.4 Intel Arc B580 10.72 5211 486 43 439 RTX 3080 (used) 2558 best core RTX 5080 2.67 (1300) proving income best core 1265 uUSD/MH/s-h
EXPLAIN die R 0.03 RTX 3090 (used) 19.69 1889 96 43 52 RTX 3080 (used) 940 best core RTX 5090 5.14 (493) proving income best core 2942 uUSD/MH/s-h
EXPLAIN die R 0.1 RTX 3090 (used) 13.06 2217 170 43 125 RTX 3060 (used) 1254 best core RTX 5080 3.87 (656) proving income best core 4386 uUSD/MH/s-h
EXPLAIN die R 0.25 Intel Arc B580 10.93 3587 328 43 282 RTX 3080 (used) 1902 best core RTX 5080 2.98 (978) proving income best core 4386 uUSD/MH/s-h
EXPLAIN die R 0.4 Intel Arc B580 10.72 5211 486 43 439 RTX 3080 (used) 2558 best core RTX 5080 2.67 (1300) proving income best core 4386 uUSD/MH/s-h
EXPLAIN die 4R 0.03 RTX 3090 (used) 19.69 1889 96 43 52 RTX 3080 (used) 940 best core RTX 5090 5.14 (493) proving income best core 11314 uUSD/MH/s-h
EXPLAIN die 4R 0.1 RTX 3090 (used) 13.06 2217 170 43 125 RTX 3060 (used) 1254 best core RTX 5080 3.87 (656) proving income best core 16869 uUSD/MH/s-h
EXPLAIN die 4R 0.25 Intel Arc B580 10.93 3587 328 43 282 RTX 3080 (used) 1902 best core RTX 5080 2.98 (978) proving income best core 16869 uUSD/MH/s-h
EXPLAIN die 4R 0.4 Intel Arc B580 10.72 5211 486 43 439 RTX 3080 (used) 2558 best core RTX 5080 2.67 (1300) proving income best core 16869 uUSD/MH/s-h
EXPLAIN die 10R 0.03 RTX 3090 (used) 19.69 1889 96 43 52 RTX 3080 (used) 940 best core RTX 5090 5.14 (493) proving income best core 28060 uUSD/MH/s-h
EXPLAIN die 10R 0.1 RTX 3090 (used) 13.06 2217 170 43 125 RTX 3060 (used) 1254 best core RTX 5080 3.87 (656) proving income best core 41836 uUSD/MH/s-h
EXPLAIN die 10R 0.25 Intel Arc B580 10.93 3587 328 43 282 RTX 3080 (used) 1902 best core RTX 5080 2.98 (978) proving income best core 41836 uUSD/MH/s-h
EXPLAIN die 10R 0.4 Intel Arc B580 10.72 5211 486 43 439 RTX 3080 (used) 2558 best core RTX 5080 2.67 (1300) proving income best core 41836 uUSD/MH/s-h
EXPLAIN hybrid 0.25R 0.03 RTX 3090 (used) 10.28 1889 184 120 62 RTX 3080 (used) 940 best core RTX 5090 2.68 (493) proving income best core 848 uUSD/MH/s-h
EXPLAIN hybrid 0.25R 0.1 RTX 3090 (used) 8.16 2217 272 120 149 RTX 3060 (used) 1254 best core RTX 5080 2.42 (656) proving income best core 1265 uUSD/MH/s-h
EXPLAIN hybrid 0.25R 0.25 Intel Arc B580 7.79 3587 460 120 336 RTX 3080 (used) 1902 best core RTX 5080 2.12 (978) proving income best core 1265 uUSD/MH/s-h
EXPLAIN hybrid 0.25R 0.4 Intel Arc B580 8.03 5211 649 120 523 RTX 3080 (used) 2558 best core RTX 5080 2.00 (1300) proving income best core 1265 uUSD/MH/s-h
EXPLAIN hybrid R 0.03 RTX 3090 (used) 10.28 1889 184 120 62 RTX 3080 (used) 940 best core RTX 5090 2.68 (493) proving income best core 2942 uUSD/MH/s-h
EXPLAIN hybrid R 0.1 RTX 3090 (used) 8.16 2217 272 120 149 RTX 3060 (used) 1254 best core RTX 5080 2.42 (656) proving income best core 4386 uUSD/MH/s-h
EXPLAIN hybrid R 0.25 Intel Arc B580 7.79 3587 460 120 336 RTX 3080 (used) 1902 best core RTX 5080 2.12 (978) proving income best core 4386 uUSD/MH/s-h
EXPLAIN hybrid R 0.4 Intel Arc B580 8.03 5211 649 120 523 RTX 3080 (used) 2558 best core RTX 5080 2.00 (1300) proving income best core 4386 uUSD/MH/s-h
EXPLAIN hybrid 4R 0.03 RTX 3090 (used) 10.28 1889 184 120 62 RTX 3080 (used) 940 best core RTX 5090 2.68 (493) proving income best core 11314 uUSD/MH/s-h
EXPLAIN hybrid 4R 0.1 RTX 3090 (used) 8.16 2217 272 120 149 RTX 3060 (used) 1254 best core RTX 5080 2.42 (656) proving income best core 16869 uUSD/MH/s-h
EXPLAIN hybrid 4R 0.25 Intel Arc B580 7.79 3587 460 120 336 RTX 3080 (used) 1902 best core RTX 5080 2.12 (978) proving income best core 16869 uUSD/MH/s-h
EXPLAIN hybrid 4R 0.4 Intel Arc B580 8.03 5211 649 120 523 RTX 3080 (used) 2558 best core RTX 5080 2.00 (1300) proving income best core 16869 uUSD/MH/s-h
EXPLAIN hybrid 10R 0.03 RTX 3090 (used) 10.28 1889 184 120 62 RTX 3080 (used) 940 best core RTX 5090 2.68 (493) proving income best core 28060 uUSD/MH/s-h
EXPLAIN hybrid 10R 0.1 RTX 3090 (used) 8.16 2217 272 120 149 RTX 3060 (used) 1254 best core RTX 5080 2.42 (656) proving income best core 41836 uUSD/MH/s-h
EXPLAIN hybrid 10R 0.25 Intel Arc B580 7.79 3587 460 120 336 RTX 3080 (used) 1902 best core RTX 5080 2.12 (978) proving income best core 41836 uUSD/MH/s-h
EXPLAIN hybrid 10R 0.4 Intel Arc B580 8.03 5211 649 120 523 RTX 3080 (used) 2558 best core RTX 5080 2.00 (1300) proving income best core 41836 uUSD/MH/s-h
EXPLAIN board 0.25R 0.03 RTX 3090 (used) 6.52 1889 290 207 80 RTX 3080 (used) 940 best core RTX 5090 1.70 (493) proving income best core 848 uUSD/MH/s-h
EXPLAIN board 0.25R 0.1 RTX 3090 (used) 5.50 2217 403 207 192 RTX 3060 (used) 1254 best core RTX 5080 1.63 (656) proving income best core 1265 uUSD/MH/s-h
EXPLAIN board 0.25R 0.25 Intel Arc B580 5.56 3587 646 207 432 RTX 3080 (used) 1902 best core RTX 5080 1.51 (978) proving income best core 1265 uUSD/MH/s-h
EXPLAIN board 0.25R 0.4 Intel Arc B580 5.87 5211 888 207 673 RTX 3080 (used) 2558 best core RTX 5080 1.46 (1300) proving income best core 1265 uUSD/MH/s-h
EXPLAIN board R 0.03 RTX 3090 (used) 6.52 1889 290 207 80 RTX 3080 (used) 940 best core RTX 5090 1.70 (493) proving income best core 2942 uUSD/MH/s-h
EXPLAIN board R 0.1 RTX 3090 (used) 5.50 2217 403 207 192 RTX 3060 (used) 1254 best core RTX 5080 1.63 (656) proving income best core 4386 uUSD/MH/s-h
EXPLAIN board R 0.25 Intel Arc B580 5.56 3587 646 207 432 RTX 3080 (used) 1902 best core RTX 5080 1.51 (978) proving income best core 4386 uUSD/MH/s-h
EXPLAIN board R 0.4 Intel Arc B580 5.87 5211 888 207 673 RTX 3080 (used) 2558 best core RTX 5080 1.46 (1300) proving income best core 4386 uUSD/MH/s-h
EXPLAIN board 4R 0.03 RTX 3090 (used) 6.52 1889 290 207 80 RTX 3080 (used) 940 best core RTX 5090 1.70 (493) proving income best core 11314 uUSD/MH/s-h
EXPLAIN board 4R 0.1 RTX 3090 (used) 5.50 2217 403 207 192 RTX 3060 (used) 1254 best core RTX 5080 1.63 (656) proving income best core 16869 uUSD/MH/s-h
EXPLAIN board 4R 0.25 Intel Arc B580 5.56 3587 646 207 432 RTX 3080 (used) 1902 best core RTX 5080 1.51 (978) proving income best core 16869 uUSD/MH/s-h
EXPLAIN board 4R 0.4 Intel Arc B580 5.87 5211 888 207 673 RTX 3080 (used) 2558 best core RTX 5080 1.46 (1300) proving income best core 16869 uUSD/MH/s-h
EXPLAIN board 10R 0.03 RTX 3090 (used) 6.52 1889 290 207 80 RTX 3080 (used) 940 best core RTX 5090 1.70 (493) proving income best core 28060 uUSD/MH/s-h
EXPLAIN board 10R 0.1 RTX 3090 (used) 5.50 2217 403 207 192 RTX 3060 (used) 1254 best core RTX 5080 1.63 (656) proving income best core 41836 uUSD/MH/s-h
EXPLAIN board 10R 0.25 Intel Arc B580 5.56 3587 646 207 432 RTX 3080 (used) 1902 best core RTX 5080 1.51 (978) proving income best core 41836 uUSD/MH/s-h
EXPLAIN board 10R 0.4 Intel Arc B580 5.87 5211 888 207 673 RTX 3080 (used) 2558 best core RTX 5080 1.46 (1300) proving income best core 41836 uUSD/MH/s-h

202
sim/economy/coexist/out/market-structure-first-run.txt Normal file
View file

@ -0,0 +1,202 @@
=== M1. the market-structure axis: five years, three chips x three structures, budget USD 10 M (a fleet, or a year's production), entry at year 2 ===
chip | structure | path | y2 chip share / margin / largest single supplier share / GPU classes | y3 | y5
board | private supply (self-mining, fixed fleet) | growing x2 from 0.10 | 9% / 59% / 9% / 14 | 7% / 52% / 7% / 15 | 5% / 63% / 5% / 16
board | private supply (self-mining, fixed fleet) | flat 0.10 | 14% / 49% / 14% / 12 | 16% / 23% / 16% / 11 | 24% / 12% / 24% / 6
board | private supply (self-mining, fixed fleet) | shrinking x0.5 from 0.30 | 10% / 55% / 10% / 13 | 22% / 15% / 22% / 8 | 91% / -57% / 91% / 2
board | public hardware sales (one manufacturer) | growing x2 from 0.10 | 4% / 60% / 4% / 14 | 5% / 52% / 5% / 15 | 8% / 63% / 8% / 16
board | public hardware sales (one manufacturer) | flat 0.10 | 3% / 49% / 3% / 12 | 3% / 23% / 3% / 11 | 6% / 12% / 6% / 6
board | public hardware sales (one manufacturer) | shrinking x0.5 from 0.30 | 3% / 55% / 3% / 13 | 8% / 20% / 8% / 11 | 39% / -23% / 39% / 4
board | multiple suppliers (three, derivative designs) | growing x2 from 0.10 | 24% / 56% / 8% / 13 | 31% / 45% / 10% / 14 | 42% / 57% / 14% / 15
board | multiple suppliers (three, derivative designs) | flat 0.10 | 25% / 46% / 8% / 12 | 37% / 18% / 12% / 11 | 66% / 2% / 22% / 6
board | multiple suppliers (three, derivative designs) | shrinking x0.5 from 0.30 | 25% / 52% / 8% / 12 | 45% / 7% / 15% / 6 | 100% / -236% / 33% / 0
hybrid | private supply (self-mining, fixed fleet) | growing x2 from 0.10 | 19% / 78% / 19% / 13 | 16% / 75% / 16% / 15 | 10% / 81% / 10% / 16
hybrid | private supply (self-mining, fixed fleet) | flat 0.10 | 29% / 72% / 29% / 11 | 39% / 57% / 39% / 11 | 64% / 51% / 64% / 6
hybrid | private supply (self-mining, fixed fleet) | shrinking x0.5 from 0.30 | 23% / 76% / 23% / 13 | 42% / 52% / 42% / 6 | 100% / -65% / 100% / 0
hybrid | public hardware sales (one manufacturer) | growing x2 from 0.10 | 19% / 78% / 19% / 13 | 30% / 72% / 30% / 14 | 35% / 79% / 35% / 15
hybrid | public hardware sales (one manufacturer) | flat 0.10 | 29% / 72% / 29% / 11 | 49% / 54% / 49% / 8 | 89% / 38% / 89% / 4
hybrid | public hardware sales (one manufacturer) | shrinking x0.5 from 0.30 | 23% / 76% / 23% / 13 | 50% / 52% / 50% / 6 | 100% / -121% / 100% / 0
hybrid | multiple suppliers (three, derivative designs) | growing x2 from 0.10 | 49% / 74% / 16% / 12 | 70% / 64% / 23% / 12 | 78% / 70% / 26% / 13
hybrid | multiple suppliers (three, derivative designs) | flat 0.10 | 69% / 64% / 23% / 6 | 95% / 31% / 32% / 3 | 100% / -42% / 33% / 0
hybrid | multiple suppliers (three, derivative designs) | shrinking x0.5 from 0.30 | 57% / 70% / 19% / 11 | 97% / 22% / 32% / 2 | 100% / -158% / 33% / 0
die | private supply (self-mining, fixed fleet) | growing x2 from 0.10 | 50% / 84% / 50% / 12 | 43% / 81% / 43% / 13 | 30% / 89% / 30% / 15
die | private supply (self-mining, fixed fleet) | flat 0.10 | 70% / 78% / 70% / 6 | 89% / 64% / 89% / 6 | 100% / 48% / 100% / 0
die | private supply (self-mining, fixed fleet) | shrinking x0.5 from 0.30 | 58% / 82% / 58% / 11 | 96% / 55% / 96% / 3 | 100% / -177% / 100% / 0
die | public hardware sales (one manufacturer) | growing x2 from 0.10 | 50% / 84% / 50% / 12 | 71% / 77% / 71% / 12 | 79% / 84% / 79% / 12
die | public hardware sales (one manufacturer) | flat 0.10 | 70% / 78% / 70% / 6 | 99% / 50% / 99% / 2 | 100% / -2% / 100% / 0
die | public hardware sales (one manufacturer) | shrinking x0.5 from 0.30 | 58% / 82% / 58% / 11 | 100% / 42% / 100% / 1 | 100% / -57% / 100% / 0
die | multiple suppliers (three, derivative designs) | growing x2 from 0.10 | 95% / 75% / 32% / 6 | 99% / 52% / 33% / 2 | 100% / 61% / 33% / 2
die | multiple suppliers (three, derivative designs) | flat 0.10 | 100% / 52% / 33% / 0 | 100% / 5% / 33% / 0 | 100% / -57% / 33% / 0
die | multiple suppliers (three, derivative designs) | shrinking x0.5 from 0.30 | 98% / 67% / 33% / 3 | 100% / -29% / 33% / 0 | 100% / -57% / 33% / 0
=== M2. the chips at the placed energies: cost per accepted MH/s-hour (sunk, 3 y) and the conditions (a), (b), (e) ===
GDDR7 board, placed 1.6x / 1.9x node-for-node: 363 uUSD | (a) 0.72x of the best owner (line 1.5) | (b) hardware 0.52 of the 5080 entrant's (line 0.25) | (e) joules 1.60x vs the 5090 lock, 1.17x vs the 5070 Ti knee (line 3)
GDDR7 board, placed 1.6x / 1.9x a node ahead: 343 uUSD | (a) 0.76x of the best owner (line 1.5) | (b) hardware 0.52 of the 5080 entrant's (line 0.25) | (e) joules 1.90x vs the 5090 lock, 1.39x vs the 5070 Ti knee (line 3)
stored-half hybrid, placed 2.4x / 2.9x node-for-node: 186 uUSD | (a) 1.41x of the best owner (line 1.5) | (b) hardware 0.23 of the 5080 entrant's (line 0.25) | (e) joules 2.40x vs the 5090 lock, 1.75x vs the 5070 Ti knee (line 3)
stored-half hybrid, placed 2.4x / 2.9x a node ahead: 172 uUSD | (a) 1.52x of the best owner (line 1.5) | (b) hardware 0.23 of the 5080 entrant's (line 0.25) | (e) joules 2.90x vs the 5090 lock, 2.12x vs the 5070 Ti knee (line 3)
N2 SRAM die, placed 2.4x / 3.3x node-for-node: 115 uUSD | (a) 2.29x of the best owner (line 1.5) | (b) hardware 0.07 of the 5080 entrant's (line 0.25) | (e) joules 2.40x vs the 5090 lock, 1.75x vs the 5070 Ti knee (line 3)
N2 SRAM die, placed 2.4x / 3.3x a node ahead: 92 uUSD | (a) 2.84x of the best owner (line 1.5) | (b) hardware 0.07 of the 5080 entrant's (line 0.25) | (e) joules 3.30x vs the 5090 lock, 2.41x vs the 5070 Ti knee (line 3)
=== W. the sensitivity workbook rows (tab-separated) ===
figure value unit discount life_y share_q project_cost_USD_M pre_production_y edge_per_joule chip_capex_USD_per_MHs GPU_cost_basis electricity_USD_kWh emission_years price_assumption source_section label
lower threshold: no chip project below 23 USD M a year of miner revenue at launch 0.10 4 (years 3 to 6) 1.0 20 2 5x n/a (margin 1 - 1/e) n/a n/a y3 to y6 at the constant p* 0.029 USD per IGN floor 4.2 / 4.3 modelled
upper threshold: every DRAM-board project above 340 USD M a year of miner revenue at launch 0.10 4 (years 3 to 6) 0.3 75 2 3x n/a (margin 1 - 1/e) n/a n/a y3 to y6 at the constant p* 0.441 USD per IGN floor 4.2 / 4.3 modelled
SRAM project taking the chain 98 USD M a year of miner revenue at launch 0.10 4 (years 3 to 6) 1.0 100 2 13x n/a (margin 1 - 1/e) n/a n/a y3 to y6 at the constant p* 0.127 USD per IGN floor 4.2 / 4.3 modelled
SRAM project at a third 566 USD M a year of miner revenue at launch 0.10 4 (years 3 to 6) 0.3 150 2 5x n/a (margin 1 - 1/e) n/a n/a y3 to y6 at the constant p* 0.735 USD per IGN floor 4.2 / 4.3 modelled
development cost range, cheapest DRAM-board chip 20 to 75 USD M n/a n/a n/a 20 to 75 n/a n/a n/a n/a n/a n/a n/a floor 4.3 (floor lane 5: no 28 nm GDDR7 PHY) approximate
surface p*, operator self-mining 0.224 USD per IGN 0.10 0.5 0.3 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.067 USD per IGN 0.10 0.5 1.0 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.105 USD per IGN 0.10 1 0.3 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.031 USD per IGN 0.10 1 1.0 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.070 USD per IGN 0.10 2 0.3 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.021 USD per IGN 0.10 2 1.0 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.054 USD per IGN 0.10 3 0.3 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.016 USD per IGN 0.10 3 1.0 20 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.493 USD per IGN 0.10 0.5 0.3 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.148 USD per IGN 0.10 0.5 1.0 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.230 USD per IGN 0.10 1 0.3 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.069 USD per IGN 0.10 1 1.0 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.117 USD per IGN 0.10 2 0.3 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.035 USD per IGN 0.10 2 1.0 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.095 USD per IGN 0.10 3 0.3 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.028 USD per IGN 0.10 3 1.0 20 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.841 USD per IGN 0.10 0.5 0.3 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.252 USD per IGN 0.10 0.5 1.0 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.392 USD per IGN 0.10 1 0.3 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.118 USD per IGN 0.10 1 1.0 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.261 USD per IGN 0.10 2 0.3 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.078 USD per IGN 0.10 2 1.0 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.201 USD per IGN 0.10 3 0.3 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.060 USD per IGN 0.10 3 1.0 75 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.849 USD per IGN 0.10 0.5 0.3 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.555 USD per IGN 0.10 0.5 1.0 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.862 USD per IGN 0.10 1 0.3 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.259 USD per IGN 0.10 1 1.0 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.437 USD per IGN 0.10 2 0.3 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.131 USD per IGN 0.10 2 1.0 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.355 USD per IGN 0.10 3 0.3 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.107 USD per IGN 0.10 3 1.0 75 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.681 USD per IGN 0.10 0.5 0.3 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.504 USD per IGN 0.10 0.5 1.0 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.784 USD per IGN 0.10 1 0.3 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.235 USD per IGN 0.10 1 1.0 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.521 USD per IGN 0.10 2 0.3 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.156 USD per IGN 0.10 2 1.0 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.402 USD per IGN 0.10 3 0.3 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.121 USD per IGN 0.10 3 1.0 150 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 3.699 USD per IGN 0.10 0.5 0.3 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.110 USD per IGN 0.10 0.5 1.0 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.725 USD per IGN 0.10 1 0.3 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.517 USD per IGN 0.10 1 1.0 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.874 USD per IGN 0.10 2 0.3 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.262 USD per IGN 0.10 2 1.0 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.711 USD per IGN 0.10 3 0.3 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.213 USD per IGN 0.10 3 1.0 150 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 5.604 USD per IGN 0.10 0.5 0.3 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.681 USD per IGN 0.10 0.5 1.0 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 2.613 USD per IGN 0.10 1 0.3 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.784 USD per IGN 0.10 1 1.0 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.738 USD per IGN 0.10 2 0.3 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.521 USD per IGN 0.10 2 1.0 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.339 USD per IGN 0.10 3 0.3 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.402 USD per IGN 0.10 3 1.0 500 1 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 12.329 USD per IGN 0.10 0.5 0.3 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 3.699 USD per IGN 0.10 0.5 1.0 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 5.749 USD per IGN 0.10 1 0.3 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 1.725 USD per IGN 0.10 1 1.0 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 2.913 USD per IGN 0.10 2 0.3 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.874 USD per IGN 0.10 2 1.0 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 2.369 USD per IGN 0.10 3 0.3 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, operator self-mining 0.711 USD per IGN 0.10 3 1.0 500 2 5x 0.5 5090 at the lock over 2 y, MSRP (0.00092 per MH/s-h) 0.06 chip T0+1 onward at the constant solved floor 4.4 A modelled
surface p*, edge axis 0.732 USD per IGN 0.10 3 0.3 150 2 2x 0.5 MSRP basis 0.06 constant solved floor 4.4 A2 modelled
surface p*, edge axis 0.720 USD per IGN 0.10 3 0.3 150 2 3x 0.5 MSRP basis 0.06 constant solved floor 4.4 A2 modelled
surface p*, edge axis 0.703 USD per IGN 0.10 3 0.3 150 2 13x 0.5 MSRP basis 0.06 constant solved floor 4.4 A2 modelled
surface p*, chip capex axis 0.789 USD per IGN 0.10 3 0.3 150 2 5x 2.8 MSRP basis 0.06 constant solved floor 4.4 A2 modelled
surface p*, chip capex axis 0.881 USD per IGN 0.10 3 0.3 150 2 5x 5.0 MSRP basis 0.06 constant solved floor 4.4 A2 modelled
surface p*, discount axis 0.611 USD per IGN 0.05 3 0.3 150 2 5x 0.5 MSRP basis 0.06 constant solved this workbook modelled
surface p*, discount axis 0.821 USD per IGN 0.15 3 0.3 150 2 5x 0.5 MSRP basis 0.06 constant solved this workbook modelled
surface p*, street GPU prices (capex term x2: GPU all-in 0.00176) 0.372 USD per IGN (approximate: p* scales with the GPU all-in cost) 0.10 3 0.3 150 2 5x 0.5 street (2x MSRP) 0.06 constant solved this workbook approximate
surface p*, the hybrid board 0.797 USD per IGN 0.10 1 0.3 50 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.239 USD per IGN 0.10 1 1.0 50 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.263 USD per IGN 0.10 3 0.3 50 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.079 USD per IGN 0.10 3 1.0 50 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 1.992 USD per IGN 0.10 1 0.3 125 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.598 USD per IGN 0.10 1 1.0 125 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.658 USD per IGN 0.10 3 0.3 125 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.197 USD per IGN 0.10 3 1.0 125 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 3.586 USD per IGN 0.10 1 0.3 225 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 1.076 USD per IGN 0.10 1 1.0 225 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 1.184 USD per IGN 0.10 3 0.3 225 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
surface p*, the hybrid board 0.355 USD per IGN 0.10 3 1.0 225 2 2.7x 2.44 MSRP basis 0.06 constant solved model 12a modelled
break-even electricity, RTX 5090 vs GDDR7 board 1 y, owner / entrant 26.9 / 9.7 cents per kWh n/a 1 n/a sunk n/a 2.9x joules 5.59 measured; used price 2200 USD, new 2600, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5090 vs GDDR7 board 3 y, owner / entrant 8.7 / -8.6 cents per kWh n/a 3 n/a sunk n/a 2.9x joules 5.59 measured; used price 2200 USD, new 2600, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5090 vs SRAM die 1 y, owner / entrant 1.5 / -15.7 cents per kWh n/a 1 n/a sunk n/a 5.1x joules 0.78 measured; used price 2200 USD, new 2600, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5090 vs SRAM die 3 y, owner / entrant -1.0 / -18.3 cents per kWh n/a 3 n/a sunk n/a 5.1x joules 0.78 measured; used price 2200 USD, new 2600, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5080 vs GDDR7 board 1 y, owner / entrant 31.5 / 13.6 cents per kWh n/a 1 n/a sunk n/a 2.6x joules 5.59 measured; used price 900 USD, new 1100, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5080 vs GDDR7 board 3 y, owner / entrant 10.8 / -7.1 cents per kWh n/a 3 n/a sunk n/a 2.6x joules 5.59 measured; used price 900 USD, new 1100, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5080 vs SRAM die 1 y, owner / entrant 2.7 / -15.2 cents per kWh n/a 1 n/a sunk n/a 4.5x joules 0.78 measured; used price 900 USD, new 1100, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5080 vs SRAM die 3 y, owner / entrant -0.1 / -18.0 cents per kWh n/a 3 n/a sunk n/a 4.5x joules 0.78 measured; used price 900 USD, new 1100, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 Ti vs GDDR7 board 1 y, owner / entrant 39.5 / 24.9 cents per kWh n/a 1 n/a sunk n/a 2.2x joules 5.59 modelled knee; used price 650 USD, new 800, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 Ti vs GDDR7 board 3 y, owner / entrant 14.5 / -0.1 cents per kWh n/a 3 n/a sunk n/a 2.2x joules 5.59 modelled knee; used price 650 USD, new 800, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 Ti vs SRAM die 1 y, owner / entrant 4.7 / -9.9 cents per kWh n/a 1 n/a sunk n/a 3.7x joules 0.78 modelled knee; used price 650 USD, new 800, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 Ti vs SRAM die 3 y, owner / entrant 1.2 / -13.4 cents per kWh n/a 3 n/a sunk n/a 3.7x joules 0.78 modelled knee; used price 650 USD, new 800, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 vs GDDR7 board 1 y, owner / entrant 37.6 / 18.9 cents per kWh n/a 1 n/a sunk n/a 2.2x joules 5.59 modelled knee; used price 450 USD, new 560, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 vs GDDR7 board 3 y, owner / entrant 13.3 / -5.4 cents per kWh n/a 3 n/a sunk n/a 2.2x joules 5.59 modelled knee; used price 450 USD, new 560, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 vs SRAM die 1 y, owner / entrant 3.8 / -14.9 cents per kWh n/a 1 n/a sunk n/a 3.8x joules 0.78 modelled knee; used price 450 USD, new 560, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5070 vs SRAM die 3 y, owner / entrant 0.4 / -18.3 cents per kWh n/a 3 n/a sunk n/a 3.8x joules 0.78 modelled knee; used price 450 USD, new 560, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 Ti 16G vs GDDR7 board 1 y, owner / entrant 25.9 / -1.0 cents per kWh n/a 1 n/a sunk n/a 3.0x joules 5.59 modelled knee; used price 360 USD, new 450, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 Ti 16G vs GDDR7 board 3 y, owner / entrant 7.9 / -19.0 cents per kWh n/a 3 n/a sunk n/a 3.0x joules 5.59 modelled knee; used price 360 USD, new 450, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 Ti 16G vs SRAM die 1 y, owner / entrant 0.9 / -26.0 cents per kWh n/a 1 n/a sunk n/a 5.1x joules 0.78 modelled knee; used price 360 USD, new 450, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 Ti 16G vs SRAM die 3 y, owner / entrant -1.7 / -28.6 cents per kWh n/a 3 n/a sunk n/a 5.1x joules 0.78 modelled knee; used price 360 USD, new 450, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 vs GDDR7 board 1 y, owner / entrant 28.8 / 6.7 cents per kWh n/a 1 n/a sunk n/a 2.8x joules 5.59 modelled knee; used price 250 USD, new 310, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 vs GDDR7 board 3 y, owner / entrant 9.5 / -12.5 cents per kWh n/a 3 n/a sunk n/a 2.8x joules 5.59 modelled knee; used price 250 USD, new 310, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 vs SRAM die 1 y, owner / entrant 2.0 / -20.1 cents per kWh n/a 1 n/a sunk n/a 4.8x joules 0.78 modelled knee; used price 250 USD, new 310, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 5060 vs SRAM die 3 y, owner / entrant -0.7 / -22.8 cents per kWh n/a 3 n/a sunk n/a 4.8x joules 0.78 modelled knee; used price 250 USD, new 310, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4090 vs GDDR7 board 1 y, owner / entrant 16.5 / -5.6 cents per kWh n/a 1 n/a sunk n/a 4.5x joules 5.59 modelled knee; used price 1300 USD, new 1700, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4090 vs GDDR7 board 3 y, owner / entrant 4.7 / -17.4 cents per kWh n/a 3 n/a sunk n/a 4.5x joules 5.59 modelled knee; used price 1300 USD, new 1700, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4090 vs SRAM die 1 y, owner / entrant 0.0 / -22.1 cents per kWh n/a 1 n/a sunk n/a 7.8x joules 0.78 modelled knee; used price 1300 USD, new 1700, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4090 vs SRAM die 3 y, owner / entrant -1.6 / -23.8 cents per kWh n/a 3 n/a sunk n/a 7.8x joules 0.78 modelled knee; used price 1300 USD, new 1700, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4080 vs GDDR7 board 1 y, owner / entrant 18.0 / -1.2 cents per kWh n/a 1 n/a sunk n/a 4.4x joules 5.59 modelled knee; used price 700 USD, new 1000, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4080 vs GDDR7 board 3 y, owner / entrant 5.9 / -13.3 cents per kWh n/a 3 n/a sunk n/a 4.4x joules 5.59 modelled knee; used price 700 USD, new 1000, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4080 vs SRAM die 1 y, owner / entrant 1.1 / -18.0 cents per kWh n/a 1 n/a sunk n/a 7.6x joules 0.78 modelled knee; used price 700 USD, new 1000, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4080 vs SRAM die 3 y, owner / entrant -0.6 / -19.7 cents per kWh n/a 3 n/a sunk n/a 7.6x joules 0.78 modelled knee; used price 700 USD, new 1000, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4070 vs GDDR7 board 1 y, owner / entrant 18.1 / 3.2 cents per kWh n/a 1 n/a sunk n/a 4.5x joules 5.59 measured; used price 400 USD, new 550, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4070 vs GDDR7 board 3 y, owner / entrant 6.2 / -8.7 cents per kWh n/a 3 n/a sunk n/a 4.5x joules 5.59 measured; used price 400 USD, new 550, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4070 vs SRAM die 1 y, owner / entrant 1.5 / -13.3 cents per kWh n/a 1 n/a sunk n/a 7.8x joules 0.78 measured; used price 400 USD, new 550, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4070 vs SRAM die 3 y, owner / entrant -0.1 / -15.0 cents per kWh n/a 3 n/a sunk n/a 7.8x joules 0.78 measured; used price 400 USD, new 550, resale 0.4 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4060 Ti 16G vs GDDR7 board 1 y, owner / entrant 16.4 / -4.3 cents per kWh n/a 1 n/a sunk n/a 4.8x joules 5.59 modelled knee; used price 290 USD, new 420, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4060 Ti 16G vs GDDR7 board 3 y, owner / entrant 5.3 / -15.5 cents per kWh n/a 3 n/a sunk n/a 4.8x joules 5.59 modelled knee; used price 290 USD, new 420, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4060 Ti 16G vs SRAM die 1 y, owner / entrant 0.9 / -19.9 cents per kWh n/a 1 n/a sunk n/a 8.3x joules 0.78 modelled knee; used price 290 USD, new 420, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 4060 Ti 16G vs SRAM die 3 y, owner / entrant -0.7 / -21.4 cents per kWh n/a 3 n/a sunk n/a 8.3x joules 0.78 modelled knee; used price 290 USD, new 420, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3090 (used) vs GDDR7 board 1 y, owner / entrant 13.8 / -5.1 cents per kWh n/a 1 n/a sunk n/a 5.7x joules 5.59 modelled cap; used price 650 USD, new 900, resale 0.3 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3090 (used) vs GDDR7 board 3 y, owner / entrant 4.4 / -14.5 cents per kWh n/a 3 n/a sunk n/a 5.7x joules 5.59 modelled cap; used price 650 USD, new 900, resale 0.3 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3090 (used) vs SRAM die 1 y, owner / entrant 0.7 / -18.2 cents per kWh n/a 1 n/a sunk n/a 9.8x joules 0.78 modelled cap; used price 650 USD, new 900, resale 0.3 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3090 (used) vs SRAM die 3 y, owner / entrant -0.6 / -19.5 cents per kWh n/a 3 n/a sunk n/a 9.8x joules 0.78 modelled cap; used price 650 USD, new 900, resale 0.3 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3080 (used) vs GDDR7 board 1 y, owner / entrant 16.0 / 5.9 cents per kWh n/a 1 n/a sunk n/a 5.3x joules 5.59 modelled cap; used price 330 USD, new 450, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3080 (used) vs GDDR7 board 3 y, owner / entrant 5.9 / -4.2 cents per kWh n/a 3 n/a sunk n/a 5.3x joules 5.59 modelled cap; used price 330 USD, new 450, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3080 (used) vs SRAM die 1 y, owner / entrant 2.0 / -8.2 cents per kWh n/a 1 n/a sunk n/a 9.1x joules 0.78 modelled cap; used price 330 USD, new 450, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3080 (used) vs SRAM die 3 y, owner / entrant 0.5 / -9.6 cents per kWh n/a 3 n/a sunk n/a 9.1x joules 0.78 modelled cap; used price 330 USD, new 450, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3060 (used) vs GDDR7 board 1 y, owner / entrant 11.7 / 4.4 cents per kWh n/a 1 n/a sunk n/a 7.3x joules 5.59 modelled cap; used price 190 USD, new 260, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3060 (used) vs GDDR7 board 3 y, owner / entrant 4.3 / -3.0 cents per kWh n/a 3 n/a sunk n/a 7.3x joules 5.59 modelled cap; used price 190 USD, new 260, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3060 (used) vs SRAM die 1 y, owner / entrant 1.4 / -5.9 cents per kWh n/a 1 n/a sunk n/a 12.5x joules 0.78 modelled cap; used price 190 USD, new 260, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RTX 3060 (used) vs SRAM die 3 y, owner / entrant 0.4 / -6.9 cents per kWh n/a 3 n/a sunk n/a 12.5x joules 0.78 modelled cap; used price 190 USD, new 260, resale 0.25 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RX 9070 XT vs GDDR7 board 1 y, owner / entrant 7.1 / -4.5 cents per kWh n/a 1 n/a sunk n/a 10.0x joules 5.59 measured; used price 520 USD, new 650, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RX 9070 XT vs GDDR7 board 3 y, owner / entrant 1.7 / -9.9 cents per kWh n/a 3 n/a sunk n/a 10.0x joules 5.59 measured; used price 520 USD, new 650, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RX 9070 XT vs SRAM die 1 y, owner / entrant -0.4 / -12.0 cents per kWh n/a 1 n/a sunk n/a 17.2x joules 0.78 measured; used price 520 USD, new 650, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, RX 9070 XT vs SRAM die 3 y, owner / entrant -1.1 / -12.8 cents per kWh n/a 3 n/a sunk n/a 17.2x joules 0.78 measured; used price 520 USD, new 650, resale 0.45 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, H100 (hosted) vs GDDR7 board 1 y, owner / entrant -21.0 / -360.1 cents per kWh n/a 1 n/a sunk n/a 2.5x joules 5.59 modelled lock; used price 18000 USD, new 25000, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, H100 (hosted) vs GDDR7 board 3 y, owner / entrant -42.3 / -381.4 cents per kWh n/a 3 n/a sunk n/a 2.5x joules 5.59 modelled lock; used price 18000 USD, new 25000, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, H100 (hosted) vs SRAM die 1 y, owner / entrant -50.6 / -389.7 cents per kWh n/a 1 n/a sunk n/a 4.3x joules 0.78 modelled lock; used price 18000 USD, new 25000, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, H100 (hosted) vs SRAM die 3 y, owner / entrant -53.6 / -392.6 cents per kWh n/a 3 n/a sunk n/a 4.3x joules 0.78 modelled lock; used price 18000 USD, new 25000, resale 0.5 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, A100 (used) vs GDDR7 board 1 y, owner / entrant 5.2 / -188.9 cents per kWh n/a 1 n/a sunk n/a 3.7x joules 5.59 modelled; used price 6000 USD, new 10000, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, A100 (used) vs GDDR7 board 3 y, owner / entrant -9.5 / -203.6 cents per kWh n/a 3 n/a sunk n/a 3.7x joules 5.59 modelled; used price 6000 USD, new 10000, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, A100 (used) vs SRAM die 1 y, owner / entrant -15.3 / -209.4 cents per kWh n/a 1 n/a sunk n/a 6.3x joules 0.78 modelled; used price 6000 USD, new 10000, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, A100 (used) vs SRAM die 3 y, owner / entrant -17.3 / -211.4 cents per kWh n/a 3 n/a sunk n/a 6.3x joules 0.78 modelled; used price 6000 USD, new 10000, resale 0.35 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, Apple M5 Max vs GDDR7 board 1 y, owner / entrant 3.3 / -219.2 cents per kWh n/a 1 n/a sunk n/a 1.8x joules 5.59 measured (reported); used price 3200 USD, new 4000, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, Apple M5 Max vs GDDR7 board 3 y, owner / entrant -27.0 / -249.5 cents per kWh n/a 3 n/a sunk n/a 1.8x joules 5.59 measured (reported); used price 3200 USD, new 4000, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, Apple M5 Max vs SRAM die 1 y, owner / entrant -38.9 / -261.4 cents per kWh n/a 1 n/a sunk n/a 3.0x joules 0.78 measured (reported); used price 3200 USD, new 4000, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
break-even electricity, Apple M5 Max vs SRAM die 3 y, owner / entrant -43.2 / -265.7 cents per kWh n/a 3 n/a sunk n/a 3.0x joules 0.78 measured (reported); used price 3200 USD, new 4000, resale 0.55 chip at 0.06 + 0.02 hosting n/a n/a model 3 modelled
condition (a) line 1.5 x the best GPU owner's cost at the GPU's electricity n/a n/a n/a n/a n/a n/a n/a owner at 0.12: 263 to 332 uUSD 0.12 GPU / 0.06 chip n/a n/a model 12 a judgement line, not a measurement
condition (b) line 0.25 of the GPU entrant's annualised hardware n/a 2 (GPU) n/a n/a n/a n/a n/a 5080 entrant hardware 459 uUSD n/a n/a n/a model 12 a judgement line
condition (c) line 1.0 years of miner revenue to buy a third of the chain's hash n/a n/a n/a n/a n/a n/a per chip GPU equilibrium hash at the per-class curve 0.12 year 3 0.03 to 1.00 model 12 a judgement line
condition (e) line 3.0 x per joule at the honest knee n/a n/a n/a n/a n/a n/a n/a Blackwell knee 1.70 to 2.06 uJ (5070 Ti modelled, 5080 measured) n/a n/a n/a model 12 a judgement line
condition (f) line 0.70 gross margin, falling with the halvings n/a n/a n/a n/a n/a n/a n/a n/a n/a n/a n/a model 12 a judgement line

31
sim/economy/coexist/out/reference-population.tsv Normal file
View file

@ -0,0 +1,31 @@
BLOCK class memGB uJ_floor uJ_stock MHs_floor Wh_per_MHs_h MSRP street used resale2y owner_0.06 owner_0.12 owner_0.25 entrant_MSRP_0.06 entrant_MSRP_0.12 entrant_MSRP_0.25 entrant_street_0.06 entrant_street_0.12 entrant_street_0.25 hw_share_street_0.12 alt_use_uUSD_per_MHs_h energy_label rate_label
1 RTX 5090 32 2.33 3.48 134.8 2.33 1999 2600 2200 0.55 243 388 704 566 711 1027 846 992 1307 71 pct 2967 measured (PC 1, tiers file) measured
1 RTX 5080 16 2.06 3.48 71.2 2.06 999 1100 900 0.50 204 332 611 570 699 978 660 788 1067 67 pct 2809 measured (rented, lane 4) measured
1 RTX 4090 24 3.58 5.00 58.0 3.58 1599 1700 1300 0.45 357 580 1065 1178 1402 1887 1288 1512 1996 70 pct 6034 stock measured, knee modelled (lane 4) measured
1 RTX 3090 (used) 24 4.51 5.03 37.8 4.51 1499 900 650 0.30 384 666 1276 2030 2311 2922 1032 1314 1924 57 pct 5291 stock measured, cap modelled (lane 4) measured
1 RX 9070 XT 16 7.90 10.70 18.9 7.90 599 650 520 0.45 657 1151 2220 1591 2085 3154 1761 2255 3324 56 pct 7937 measured (PC 1, ADLX -500 MHz -30 pct) measured
1 RX 7600 8 GB 8 6.19 8.14 13.9 6.19 269 270 200 0.40 472 859 1697 1118 1505 2343 1122 1509 2347 49 pct 3597 stock measured 13.88 MH/s at 113 W (PC 1, 15:46 UK, class v4 sub-version 3; class v5 within 2 pct); knee estimated by the 9070 XT's ADLX grid measured
1 Intel Arc B580 12 10.40 10.40 10.7 10.40 249 260 200 0.40 761 1411 2819 1529 2179 3587 1594 2243 3651 42 pct 4673 rate measured 10.4 to 11 MH/s (PC 2); watts unread, about 110 W by the board's class (estimated); no lever measured rate, estimated watts
1 Apple M5 Max (reported, not headlined) 36 1.40 1.40 27.1 1.40 3999 4000 3200 0.55 789 876 1066 4268 4356 4545 4271 4358 4548 96 pct 0 measured (GPU and DRAM channels, 6 October) measured
2 RTX 5070 Ti 16 1.70 2.84 77.0 1.70 749 800 650 0.50 156 263 493 412 519 749 454 560 790 62 pct 1948 stock measured (rented), knee modelled measured
2 RTX 5070 12 1.75 2.99 41.0 1.75 549 560 450 0.50 175 284 521 531 640 877 548 657 894 67 pct 2439 stock measured, knee modelled measured
2 RTX 5060 Ti 16 GB 16 2.36 4.02 19.0 2.36 429 450 360 0.45 260 407 727 929 1077 1396 999 1146 1466 74 pct 4211 stock measured, knee modelled measured
2 RTX 5060 8 2.21 3.76 17.0 2.21 299 310 250 0.45 225 364 663 747 885 1184 788 926 1225 70 pct 3529 stock measured, knee modelled measured
2 RTX 4080 16 3.51 4.92 45.0 3.51 999 1000 700 0.40 312 531 1006 1058 1277 1752 1059 1279 1754 66 pct 4444 stock measured, knee modelled measured
2 RTX 4070 12 3.58 5.82 31.1 3.58 549 550 400 0.40 300 524 1008 891 1114 1599 893 1116 1601 60 pct 3215 measured (PC, 1,860 MHz + 50 pct cap) measured
2 RTX 4060 Ti 16 GB 16 3.81 5.32 17.6 3.81 499 420 290 0.35 336 574 1090 1398 1636 2152 1116 1354 1870 65 pct 4545 stock measured, knee modelled measured
2 RTX 3080 (used) 10 4.20 4.54 40.8 4.20 699 450 330 0.25 310 573 1141 1071 1334 1902 687 950 1518 45 pct 2941 modelled (both rented hosts capped) measured
2 RTX 3060 (used) 12 5.77 6.40 23.8 5.77 329 260 190 0.25 408 768 1550 1013 1374 2155 831 1191 1972 39 pct 2521 stock measured, cap modelled measured
2 H100 (hosted) 80 2.00 2.58 90.0 2.00 25000 25000 18000 0.50 1313 1438 1709 8869 8994 9265 8869 8994 9265 97 pct 27778 stock measured (rented), lock modelled measured
2 A100 (used) 80 2.89 2.99 60.0 2.89 10000 10000 6000 0.35 775 955 1346 7001 7182 7573 7001 7182 7573 95 pct 16667 stock measured (rented) measured
CHIP chip uJ USD_per_MHs life_y all_in_0.06 all_in_0.12 all_in_0.25 hardware_0.06 power_0.06 label
CHIP GDDR7 machine (adversary lane, reconciled) 1.55 4.84 1 722 819 1029 586 128 modelled: 1.5x per joule vs the 5090 lock, USD 4.84 per MH/s
CHIP GDDR7 machine (adversary lane, reconciled) 1.55 4.84 3 338 435 646 207 128 modelled: 1.5x per joule vs the 5090 lock, USD 4.84 per MH/s
CHIP GDDR7 machine (adversary lane, reconciled) 1.55 4.84 5 262 359 569 131 128 modelled: 1.5x per joule vs the 5090 lock, USD 4.84 per MH/s
CHIP Stored-half hybrid (reconciled) 1.21 2.80 1 443 519 682 339 100 modelled: 1.93x, USD 2.80
CHIP Stored-half hybrid (reconciled) 1.21 2.80 3 221 297 460 120 100 modelled: 1.93x, USD 2.80
CHIP Stored-half hybrid (reconciled) 1.21 2.80 5 177 253 416 76 100 modelled: 1.93x, USD 2.80
CHIP N2 SRAM die (reconciled, 1 to 1.5 kW machine) 1.01 1.00 1 207 270 407 121 84 modelled: 2.3x, USD 1.0 (0.5 to 1.6)
CHIP N2 SRAM die (reconciled, 1 to 1.5 kW machine) 1.01 1.00 3 128 191 328 43 84 modelled: 2.3x, USD 1.0 (0.5 to 1.6)
CHIP N2 SRAM die (reconciled, 1 to 1.5 kW machine) 1.01 1.00 5 112 175 312 27 84 modelled: 2.3x, USD 1.0 (0.5 to 1.6)
Can't render this file because it has a wrong number of fields in line 22.

56
sim/economy/coexist/refpop.py Normal file
View file

@ -0,0 +1,56 @@
#!/usr/bin/env python3
# The served reference GPU population: cost per accepted MH/s-hour, existing owner and new entrant (MSRP and street), three
# electricity prices; the chip rows at the reconciled tickets. Every cell labelled. All arithmetic modelled on the labelled inputs.
H = 8766.0; ACCEPT = 0.97; FEE = 0.01; WEAR = 0.05; FAIL = 0.03; HOST_FARM = 0.02
ELEC = (0.06, 0.12, 0.25)
# name, memGB, uJ floor (knee with the knobs), uJ stock, MH/s at the floor, MSRP, street new, used, resale2y, energy label, rate label, alt use USD/h, block
POP = [
("RTX 5090", 32, 2.33, 3.48, 134.8, 1999, 2600, 2200, 0.55, "measured (PC 1, tiers file)", "measured", 0.40, 1),
("RTX 5080", 16, 2.06, 3.48, 71.2, 999, 1100, 900, 0.50, "measured (rented, lane 4)", "measured", 0.20, 1),
("RTX 4090", 24, 3.58, 5.00, 58.0, 1599, 1700, 1300, 0.45, "stock measured, knee modelled (lane 4)", "measured", 0.35, 1),
("RTX 3090 (used)", 24, 4.51, 5.03, 37.8, 1499, 900, 650, 0.30, "stock measured, cap modelled (lane 4)", "measured", 0.20, 1),
("RX 9070 XT", 16, 7.90, 10.7, 18.9, 599, 650, 520, 0.45, "measured (PC 1, ADLX -500 MHz -30 pct)", "measured", 0.15, 1),
("RX 7600 8 GB", 8, 6.19, 8.14, 13.9, 269, 270, 200, 0.40, "stock measured 13.88 MH/s at 113 W (PC 1, 15:46 UK, class v4 sub-version 3; class v5 within 2 pct); knee estimated by the 9070 XT's ADLX grid", "measured", 0.05, 1),
("Intel Arc B580", 12, 10.4, 10.4, 10.7, 249, 260, 200, 0.40, "rate measured 10.4 to 11 MH/s (PC 2); watts unread, about 110 W by the board's class (estimated); no lever", "measured rate, estimated watts", 0.05, 1),
("Apple M5 Max (reported, not headlined)", 36, 1.40, 1.40, 27.1, 3999, 4000, 3200, 0.55, "measured (GPU and DRAM channels, 6 October)", "measured", 0.00, 1),
("RTX 5070 Ti", 16, 1.70, 2.84, 77.0, 749, 800, 650, 0.50, "stock measured (rented), knee modelled", "measured", 0.15, 2),
("RTX 5070", 12, 1.75, 2.99, 41.0, 549, 560, 450, 0.50, "stock measured, knee modelled", "measured", 0.10, 2),
("RTX 5060 Ti 16 GB", 16, 2.36, 4.02, 19.0, 429, 450, 360, 0.45, "stock measured, knee modelled", "measured", 0.08, 2),
("RTX 5060", 8, 2.21, 3.76, 17.0, 299, 310, 250, 0.45, "stock measured, knee modelled", "measured", 0.06, 2),
("RTX 4080", 16, 3.51, 4.92, 45.0, 999, 1000, 700, 0.40, "stock measured, knee modelled", "measured", 0.20, 2),
("RTX 4070", 12, 3.58, 5.82, 31.1, 549, 550, 400, 0.40, "measured (PC, 1,860 MHz + 50 pct cap)", "measured", 0.10, 2),
("RTX 4060 Ti 16 GB", 16, 3.81, 5.32, 17.6, 499, 420, 290, 0.35, "stock measured, knee modelled", "measured", 0.08, 2),
("RTX 3080 (used)", 10, 4.20, 4.54, 40.8, 699, 450, 330, 0.25, "modelled (both rented hosts capped)", "measured", 0.12, 2),
("RTX 3060 (used)", 12, 5.77, 6.40, 23.8, 329, 260, 190, 0.25, "stock measured, cap modelled", "measured", 0.06, 2),
("H100 (hosted)", 80, 2.00, 2.58, 90.0, 25000, 25000, 18000, 0.50, "stock measured (rented), lock modelled", "measured", 2.50, 2),
("A100 (used)", 80, 2.89, 2.99, 60.0, 10000, 10000, 6000, 0.35, "stock measured (rented)", "measured", 1.00, 2),
]
CHIPS = [("GDDR7 machine (adversary lane, reconciled)", 2.33/1.5, 4.84, "modelled: 1.5x per joule vs the 5090 lock, USD 4.84 per MH/s"),
("Stored-half hybrid (reconciled)", 2.33/1.93, 2.80, "modelled: 1.93x, USD 2.80"),
("N2 SRAM die (reconciled, 1 to 1.5 kW machine)", 2.33/2.3, 1.0, "modelled: 2.3x, USD 1.0 (0.5 to 1.6)")]
def kwh(uj): return uj * 1e-3
def owner(c, e):
name, mem, uj, ujs, mhs, msrp, street, used, res, *_ = c
power = kwh(uj) * e; wear = WEAR * used / H / mhs
return (power + wear) / ACCEPT / (1 - FEE)
def entrant(c, e, price):
name, mem, uj, ujs, mhs, msrp, street, used, res, *_ = c
hw = (price - res * msrp) / (2 * H) / mhs * (1 + FAIL * 2)
return (hw + kwh(uj) * e) / ACCEPT / (1 - FEE), hw / ACCEPT / (1 - FEE)
def chip(ch, e, life=3):
n, uj, usd, lab = ch
hw = usd / (life * H) * (1 + FAIL * life); pw = kwh(uj) * (e + HOST_FARM)
return (hw + pw) / ACCEPT / (1 - FEE), hw / ACCEPT, pw / ACCEPT
print("BLOCK\tclass\tmemGB\tuJ_floor\tuJ_stock\tMHs_floor\tWh_per_MHs_h\tMSRP\tstreet\tused\tresale2y\towner_0.06\towner_0.12\towner_0.25\tentrant_MSRP_0.06\tentrant_MSRP_0.12\tentrant_MSRP_0.25\tentrant_street_0.06\tentrant_street_0.12\tentrant_street_0.25\thw_share_street_0.12\talt_use_uUSD_per_MHs_h\tenergy_label\trate_label")
for c in POP:
o = [owner(c, e) * 1e6 for e in ELEC]
em = [entrant(c, e, c[5])[0] * 1e6 for e in ELEC]; es = [entrant(c, e, c[6])[0] * 1e6 for e in ELEC]
hw = entrant(c, 0.12, c[6])[1] * 1e6
alt = c[11] / c[4] * 1e6
print("\t".join([str(c[12]), c[0], str(c[1]), f"{c[2]:.2f}", f"{c[3]:.2f}", f"{c[4]:.1f}", f"{kwh(c[2])*1000:.2f}", str(c[5]), str(c[6]), str(c[7]), f"{c[8]:.2f}"] + [f"{v:.0f}" for v in o + em + es] + [f"{hw/es[1]*100:.0f} pct", f"{alt:.0f}", c[9], c[10]]))
print()
print("CHIP\tchip\tuJ\tUSD_per_MHs\tlife_y\tall_in_0.06\tall_in_0.12\tall_in_0.25\thardware_0.06\tpower_0.06\tlabel")
for ch in CHIPS:
for life in (1, 3, 5):
a = [chip(ch, e, life)[0] * 1e6 for e in ELEC]; _, hw, pw = chip(ch, 0.06, life)
print("\t".join([ "CHIP", ch[0], f"{ch[1]:.2f}", f"{ch[2]:.2f}", str(life)] + [f"{v:.0f}" for v in a] + [f"{hw*1e6:.0f}", f"{pw*1e6:.0f}", ch[3]]))

91
sim/economy/coexist/surface.py Normal file
View file

@ -0,0 +1,91 @@
#!/usr/bin/env python3
# Floor lane 3: the chip-project profitability surface (first cut). All modelled; inputs labelled in the document.
import math
MINER = {1: 0.77e9, 2: 0.80e9, 3: 0.40e9, 4: 0.40e9, 5: 0.20e9, 6: 0.20e9, 7: 0.10e9, 8: 0.10e9}
DISC = 0.10
GPU_COST_PER_MHS_H = 0.00092 # the 5090 at the lock over two years: capex 0.00084 + electricity 0.000084 (research 16.1)
GPU_ELEC_PER_MHS_H = 0.000084
CHIP_CAPEX_PER_MHS = 0.5 # USD of silicon and board per MH/s (the die 0.25 to 0.5; the DRAM board 2.8: axis below)
RESIDUAL = 0.2 # of fleet capital at the end of life
def rev_year(y, p): # miner revenue in calendar year y at price p (USD)
return MINER.get(y, 0.05e9) * p
def margin(e, life, capex_per_mhs):
# revenue per MH/s-hour is set by the GPU miners' entry and exit at their all-in cost (while any GPU mines)
chip_cost = GPU_ELEC_PER_MHS_H / e + capex_per_mhs / (life * 8766)
return max(0.0, 1 - chip_cost / GPU_COST_PER_MHS_H)
def fleet_capital(q, p, y, capex_per_mhs):
h_total = rev_year(y, p) / 8766 / GPU_COST_PER_MHS_H # MH/s at the GPU equilibrium
return q * h_total * capex_per_mhs
def npv(p, c_dev, t0, life, q, e, capex_per_mhs=CHIP_CAPEX_PER_MHS, share_of_profit=1.0):
"""operator self-mining: pays c_dev (its share), the fleet, mines years t0+1 .. t0+life at share q, margin m."""
start = t0 + 1
total = -c_dev
fc = fleet_capital(q, p, start, capex_per_mhs)
total -= fc / (1 + DISC) ** t0
m = margin(e, life, capex_per_mhs)
y = start
rem = life
while rem > 0:
frac = min(1.0, rem)
total += share_of_profit * q * m * rev_year(y, p) * frac / (1 + DISC) ** (y - 0.5)
rem -= frac; y += 1
total += RESIDUAL * fc / (1 + DISC) ** (t0 + life)
return total
def pstar(c_dev, t0, life, q, e, capex_per_mhs=CHIP_CAPEX_PER_MHS, share_of_profit=1.0):
lo, hi = 1e-4, 1e3
for _ in range(80):
mid = math.sqrt(lo * hi)
if npv(mid, c_dev, t0, life, q, e, capex_per_mhs, share_of_profit) > 0: hi = mid
else: lo = mid
return hi
def rev_at(p, y=1): return rev_year(y, p)
print("=== A. Operator, self-mining, a first design (bears the whole development cost) ===")
print("p* in USD per IGN (launch-year miner revenue in USD M a year in brackets); axes: C_dev, pre-production T0, life L, share q; edge 5x, chip capex 0.5 USD/MH/s")
for c in (20e6, 75e6, 150e6, 500e6):
for t0 in (1, 2):
row = []
for life in (0.5, 1, 2, 3):
for q in (0.1, 0.3, 1.0):
ps = pstar(c, t0, life, q, 5)
row.append(f"L{life} q{q}: {ps:.3f} ({rev_at(ps)/1e6:.0f})")
print(f"C {c/1e6:.0f} M T0 {t0}: " + " | ".join(row))
print("\n=== A2. The edge axis (C 150 M, T0 2, q 0.3) and the chip capex axis ===")
for e in (2, 3, 5, 13):
print(f"e {e}x: " + " ".join(f"L{l} {pstar(150e6,2,l,0.3,e):.3f}" for l in (0.5,1,2,3)) + f" | margin at L3 {margin(e,3,0.5):.2f}")
for cap in (0.5, 2.8, 5.0):
print(f"capex {cap} USD/MH/s (e 5x): " + " ".join(f"L{l} {pstar(150e6,2,l,0.3,5,cap):.3f}" for l in (0.5,1,2,3)) + f" | margin at L3 {margin(5,3,cap):.2f}, at L0.5 {margin(5,0.5,cap):.2f}")
print("\n=== B. Manufacturer selling hardware (bears C_dev; takes half the operators' mining profit through the price; operators bear fleet and power) ===")
for c in (20e6, 75e6, 150e6, 500e6):
for t0 in (1, 2):
print(f"C {c/1e6:.0f} M T0 {t0}: " + " | ".join(f"L{l} q{q}: {pstar(c,t0,l,q,5,0.5,0.5):.3f}" for l in (1,2,3) for q in (0.3,1.0)))
print("\n=== C. Revision entrant (a second design: 0.3 x C_dev, T0 1 year) and the shared-cost entrant (C_dev / N) ===")
for c in (75e6, 150e6, 500e6):
print(f"C {c/1e6:.0f} M revision: " + " ".join(f"L{l} q0.3 {pstar(0.3*c,1,l,0.3,5):.3f}" for l in (1,2,3))
+ " | shared N=3, T0 2: " + " ".join(f"L{l} {pstar(c/3,2,l,0.3,5):.3f}" for l in (1,2,3)))
print("\n=== D. Hybrid (self-mine the first year at q, then sell: the operator row for year 1 plus the manufacturer row after) ===")
for c in (75e6, 150e6):
for life in (2, 3):
# approximate: full profit for the first productive year, half thereafter
def npv_h(p):
return npv(p, c, 2, 1, 0.3, 5) + npv(p, 0, 3, life - 1, 0.3, 5, 0.5, 0.5)
lo, hi = 1e-4, 1e3
for _ in range(80):
mid = math.sqrt(lo*hi)
if npv_h(mid) > 0: hi = mid
else: lo = mid
print(f"C {c/1e6:.0f} M L{life}: p* {hi:.3f} ({rev_at(hi)/1e6:.0f} M a year)")
print("\n=== E. NPV at the price axis (C 150 M, T0 2, q 0.3, e 5x), USD M ===")
for life in (0.5, 1, 2, 3):
print(f"L{life}: " + " ".join(f"p{p}: {npv(p,150e6,2,life,0.3,5)/1e6:+.0f}" for p in (0.03, 0.1, 0.3, 1.0, 3.0)))

1
tools/ci/export-exclude.txt
View file

@ -33,3 +33,4 @@ docs/analysis/class-v6/operator-simulation.md
docs/analysis/class-v6/coexistence-workbook.md
docs/analysis/class-v6/reference-population.md
docs/analysis/class-v6/eco-05-scenarios.md
docs/analysis/class-v6/eco-05-results.md