igneum/sim/horizon/frontier/frontier_model.py

#!/usr/bin/env python3
"""Horizon lane 7 (frontier): the arithmetic behind docs/analysis/horizon/frontier.md.

Every input is labelled in the INPUTS dict: measured (a repo bench entry), cited (a URL
or paper named in frontier.md) or approximate (from memory, or an estimate). Nothing
here is a prediction of a coin price. Run: python3 frontier_model.py  (pure Python 3,
no numpy; about 50 ms).

Sections (one function each, printed as markdown tables):
  1. predictions_2030   VRAM, GB per dollar, random-read ceilings (GDDR7, HBM3, HBM4),
                        the f = 1 chip on HBM4 with and without the latency shadow,
                        zkVM cost per Ethereum block, prover tiers in 2028
  2. rental_tax         the reward rule: pay per block falls when hash arrives faster
                        than the 30-day weight can follow (idea 1)
  3. work_stake         vote weight as the external-job bond (idea 2)
  4. burn_bounty        audits paid from the base-fee burn by 60% signal (idea 6)
  5. rental_settlement  Igneum as the settlement layer for GPU rental (idea 10)
  6. beacon             a 30-s VDF beacon against drand quicknet (idea 12)
  7. proving_income     could proving others' chains be the main income by 2030 (idea 14)
"""
import math

INPUTS = {
    # label, value, source
    "rtx5090_mhs_v3": ("measured", 136.1, "docs/analysis/chip-model-v3.md 5.1 (bench-log Counter ASIC 2.0)"),
    "rtx5090_w_v3": ("measured", 326.0, "chip-model-v3.md 5.1 (peak with prover on; 290 W in the app, 350 W bench)"),
    "rtx5090_uj_per_hash": ("measured", 2.40, "chip-model-v3.md 5.1"),
    "rtx5090_reads_per_s": ("measured", 17.5e9, "chip-model-v3.md 5.1 (CUDA wall)"),
    "gddr7_ceiling_reads": ("approximate", 21.3e9, "chip-model-v3.md 5.3 activate-bound ceiling, 16 devices"),
    "hbm3_ceiling_reads_per_stack": ("approximate", 10.7e9, "chip-model-v3.md 5.3 (8 activates per 12 ns per channel, 16 channels)"),
    "hbm4_channels_per_stack": ("cited", 32, "JEDEC JESD270-4 via allaboutcircuits.com: channels 16 to 32, each with two pseudo-channels"),
    "hbm3_channels_per_stack": ("cited", 16, "chip-model-v3.md 5.1 (Synopsys HBM3 glossary)"),
    "gddr7_read_nj": ("approximate", 2.0, "chip-model-v3.md 5.3"),
    "hbm3_read_nj": ("approximate", 1.2, "chip-model-v3.md 5.3"),
    "hbm4_read_nj": ("approximate", 1.0, "estimate: 15 percent under HBM3 on a shorter interposer path; unsourced"),
    "hbm3_stack_usd": ("approximate", 200.0, "chip-model-v3.md 5.1 (siliconanalysts, 24 GB factory gate)"),
    "hbm4_stack_usd": ("approximate", 550.0, "siliconanalysts.com/data/hbm-pricing, 36 GB 12-high, October 2026"),
    "gddr7_2gb_usd": ("cited", 20.0, "TrendForce 24 Sep 2026 via chip-model-v3.md 5.1"),
    "gddr6_8gb_usd_2023": ("cited", 27.0, "Tom's Hardware 'GDDR6 VRAM prices plummet' (2023)"),
    "gddr6_usd_per_gb_2025": ("cited", 2.50, "TechSpot 'AI is eating all the DRAM' (2026)"),
    "gddr6_usd_per_gb_2026": ("cited", 3.30, "TechSpot, same article"),
    "rtx5090_msrp": ("cited", 1999.0, "chip-model-v3.md 5.1"),
    "rtx5090_street_2026": ("cited", 3695.0, "localaimaster.com GPU price-per-GB table, 2026"),
    "shadow_N": ("measured", 100000, "class v4 candidate mx8+sh256x27, counter-asic-3-status.md section 4"),
    "shadow_chip_core_w_at_k1": ("approximate", 150.0, "latency-shadow-2026-10-06.md via counter-asic-3-status.md section 4 (14,000-lane array, N5)"),
    "card_w_at_N100k": ("approximate", 401.0, "chip-model-v3.md 5.7 (linear toward 575 W TGP)"),
    "card_uj_at_N100k": ("approximate", 2.95, "chip-model-v3.md 5.7"),
    "ethproofs_usd_per_block_jan2025": ("cited", 1.69, "HackMD 'Ethproofs 2025 review' (willcorcoran), secondary"),
    "ethproofs_usd_per_block_sep2026": ("cited", 0.005, "ethproofs via the Sept 2026 comparative analysis (GitHub Ricosworks1), secondary; 'under 4 cents' by Dec 2025 per HackMD"),
    "eth_blocks_per_day": ("cited", 7200, "12-s slots"),
    "emission_ign_per_block": ("designed", 31.688, "sim/economy assumptions, spec 2.5, 1 block/s, pre-halving"),
    "rented_usd_per_gh_hour": ("measured", 11.69, "docs/bench-log.md line 2582, Rental cost of hash, 6 October 2026: 1,748 MH/s for USD 20.44 per hour on RunPod community pods, USD 0.0117 per MH/s-hour; the live devnet 1.16 GH/s"),
    "base_fee_full_block_ign": ("designed", 3.0, "spec 5.11: a full block burns 3 IGN at the floor"),
    "base_fee_full_day_ign": ("designed", 259200.0, "spec 5.11"),
    "vast_take": ("approximate", 0.15, "secondary comparisons (spheron, miningboard) say about 15 percent; Vast's own June 2024 update says the host fee was removed and replaced by a surcharge it does not publish"),
    "runpod_take": ("approximate", 0.07, "secondary (miningboard): hosts keep 93 percent"),
    "rtx5090_rent_usd_h": ("cited", 0.44, "Vast.ai on-demand, getdeploying.com 6 Oct 2026; RunPod secure cloud 0.99"),
    "rtx4090_rent_usd_h": ("cited", 0.31, "Vast.ai low, gpuperhour/runcrate 2026"),
    "plain_transfer_ign": ("designed", 0.0051, "spec 5.11"),
    "vdf_10min_s": ("measured", 600, "spec 04 epoch VDF; 4.47 ms verify, 516 B proof"),
    "drand_quicknet_period_s": ("cited", 3, "docs.drand.love quicknet, unchained"),
    "checkpoint_period_s": ("designed", 30, "spec 03"),
}

def v(k):
    return INPUTS[k][1]

def row(*cells):
    print("| " + " | ".join(str(c) for c in cells) + " |")

def header(*cells):
    row(*cells)
    print("|" + "---|" * len(cells))

# ---------------------------------------------------------------- 1. predictions
def predictions_2030():
    print("\n## 1. Predictions to 2030\n")
    print("### 1.1 Flagship consumer VRAM (approximate: generations from memory, the 5090 cited)\n")
    gens = [(2016, "GTX 1080", 8), (2018, "RTX 2080 Ti", 11), (2020, "RTX 3090", 24), (2022, "RTX 4090", 24), (2025, "RTX 5090", 32)]
    header("Year", "Card", "GB", "Years since 2016", "GB growth per year (compound)")
    for y, c, gb in gens:
        n = y - 2016
        g = (gb / 8) ** (1 / n) if n else float("nan")
        row(y, c, gb, n, f"{g:.3f}" if n else "")
    cagr = (32 / 8) ** (1 / 9)
    print(f"\nCompound growth 2016 to 2025: {cagr:.3f} per year (4x in 9 years). Extrapolated: 2028 {32*cagr**3:.0f} GB, 2030 {32*cagr**5:.0f} GB (approximate).")
    print("Module arithmetic: a 512-bit board is 16 devices; 2 GB devices give 32 GB, 3 GB devices 48 GB (Micron ends 2 GB GDDR7, TrendForce Sep 2026), 4 GB devices 64 GB. So the 2028 flagship is 48 GB if the RTX 60 series (Rubin GR20x, rumoured 2028, kopite7kimi via videocardz) ships 3 GB GDDR7, and 64 GB is the 2030 shape.\n")

    print("### 1.2 Memory dollars per GB (consumer GDDR)\n")
    header("Point", "USD per GB", "Source label")
    row("2023 GDDR6", f"{v('gddr6_8gb_usd_2023')/8:.2f}", "cited")
    row("2025 GDDR6", f"{v('gddr6_usd_per_gb_2025'):.2f}", "cited")
    row("2026 GDDR6", f"{v('gddr6_usd_per_gb_2026'):.2f}", "cited")
    row("Sep 2026 GDDR7 2 GB device", f"{v('gddr7_2gb_usd')/2:.2f}", "cited")
    row("Sep 2026 GDDR7 3 GB device", f"{65/3:.2f}", "cited (60 to 70 USD per device)")
    print("\nDirection: GB per dollar fell in 2026 for the first time in a decade (DRAM shortage, forecast tight through 2027). The chip model's f = 1 chip pays the same device price the GPU does, so the ratio of chip memory cost to GPU memory cost is unchanged; what changes is the share of each bill of materials that is memory.\n")

    print("### 1.3 Random-read ceilings per memory system (reads per second; the lottery is latency-bound, so this is the number that matters, not GB/s)\n")
    hbm4_ceiling = v("hbm3_ceiling_reads_per_stack") * v("hbm4_channels_per_stack") / v("hbm3_channels_per_stack")
    header("Memory system", "Reads/s ceiling", "Scaling rule", "Label")
    row("GDDR7, 16 devices, 512-bit (RTX 5090 board)", f"{v('gddr7_ceiling_reads')/1e9:.1f} G", "activates per tFAW per channel x 64 channels; pin rate irrelevant (28 Gbps = 48 Gbps)", "approximate")
    row("RTX 5090 measured", f"{v('rtx5090_reads_per_s')/1e9:.1f} G", "82 percent of the ceiling", "measured")
    row("HBM3 or HBM3E, one stack", f"{v('hbm3_ceiling_reads_per_stack')/1e9:.1f} G", "16 channels", "approximate")
    row("HBM4, one stack", f"{hbm4_ceiling/1e9:.1f} G", "32 channels (JEDEC): 2x the activate parallelism per stack if tFAW per channel holds", "approximate, derived")
    row("A 48 GB GDDR7 board (16 x 3 GB)", f"{v('gddr7_ceiling_reads')/1e9:.1f} G", "same channel count; capacity does not add channels", "approximate")

    print("\n### 1.4 The stored-dataset (f = 1) chip in 2028 on HBM4, bare and under the latency shadow\n")
    def chip(ceiling, read_nj, static_w, ctrl_w, mem_usd, extra_w=0.0, label=""):
        rate = ceiling / 128
        p = rate * 128 * read_nj * 1e-9 + static_w + ctrl_w + extra_w
        uj = p / rate * 1e6
        return rate, p, uj
    header("Chip", "MH/s per chip", "W", "uJ per hash", "Gain per joule vs 5090 at 2.40 uJ", "Gain per joule vs 5090 under the shadow (2.95 uJ at N = 100k)", "Memory USD")
    for name, ceil, nj, st, ct, usd in [
        ("GDDR7 f=1 (today's model row)", v("gddr7_ceiling_reads"), v("gddr7_read_nj"), 20, 15, 320),
        ("HBM3 one stack f=1", v("hbm3_ceiling_reads_per_stack"), v("hbm3_read_nj"), 4, 10, 400),
        ("HBM4 one stack f=1 (2028)", hbm4_ceiling, v("hbm4_read_nj"), 5, 10, v("hbm4_stack_usd") + 200),
    ]:
        r, p, uj = chip(ceil, nj, st, ct, usd)
        r2, p2, uj2 = chip(ceil, nj, st, ct, usd, extra_w=v("shadow_chip_core_w_at_k1"))
        row(name, f"{r/1e6:.0f}", f"{p:.0f} (bare) / {p2:.0f} (with a 150 W shadow core at k = 1)", f"{uj:.2f} / {uj2:.2f}", f"{2.40/uj:.1f}x", f"{v('card_uj_at_N100k')/uj2:.1f}x", f"{usd:.0f}")
    print("\nReading: HBM4's doubled channel count doubles the chip's rate per stack at about the same watts, so the bare per-joule edge rises from about 7x to about 11x, and under the class v4 shadow (N = 100,000, k = 1) from about 2.3x to about 2.7x (approximate; every chip figure is arithmetic). The lever that answers it is N: the chip's shadow core scales with N while the card's spare ALU budget is 330,000 ops per hash on the 5090. Verifier cost is N x 32 ops per warp: 3.2 M ops at N = 100k (about 1 ms on one M5 Max core, measured class), 10 M at N = 330k (about 3 ms), inside the 10 ms gate; the 2019-class core is unmeasured.\n")
    # N needed to hold 2x on HBM4
    for N in (100000, 200000, 330000):
        card_w = 326 + (575 - 326) * N / 330000
        card_uj = card_w / 136.1
        core_w = v("shadow_chip_core_w_at_k1") * N / 100000
        r, p, uj = chip(hbm4_ceiling, v("hbm4_read_nj"), 5, 10, 0, extra_w=core_w)
        print(f"- N = {N:,}: card {card_w:.0f} W, {card_uj:.2f} uJ; HBM4 chip {p:.0f} W, {uj:.2f} uJ; gain {card_uj/uj:.2f}x at k = 1")
    print("So the schedule for N should be written into the era draw at genesis (a doubling per era is the candidate), because the memory generation it answers arrives every two to three years and the verifier has 10x of headroom.\n")

    print("### 1.5 Chip fabrication cost curve (mask sets, cited; project totals approximate)\n")
    header("Node", "Mask set USD", "Source", "What it means for Igneum")
    row("28 nm", "1 to 3 M", "TubeTime (3 M), VBsemi (over 1 M)", "The f = 1 memory-controller chip lives here: no mixer on the die. Project 5 to 30 M (history 2.5)")
    row("7 nm", "10 to 15 M", "VBsemi, HN thread", "The f = 0 recompute chip with the 256 MiB cache on die. Project 50 to 75 M")
    row("5 nm", "6.5 M (2026 data) to 30 M (2023 estimate)", "siliconanalysts, HN", "The shadow core at N5 (30 mm^2 at N = 100k) pushes the f = 1 chip from a 28 nm project to a 5 nm one, or to a reticle-class 28 nm die")
    row("3 nm", "15 to 22 M (Q4 2025), up to 40 M (older estimate)", "siliconanalysts, semianalysis", "Not relevant to a chip whose cost is memory")
    print("\nThe curve is falling at a given node (5 nm masks quoted at 30 M in 2023 and 6.5 M in 2026) while the leading node's cost rises. Consequence: the shadow lever's economic teeth (forcing an advanced-node core onto a memory-controller chip) weaken by about 4x in mask cost over three years; the rate and joule arithmetic above, not the fab bill, is what holds in 2030.\n")

    print("### 1.6 zkVM proving cost per Ethereum block (public tracker, secondary sources, approximate)\n")
    a, b = v("ethproofs_usd_per_block_jan2025"), v("ethproofs_usd_per_block_sep2026")
    months = 20
    per_year = (b / a) ** (12 / months)
    header("Point", "USD per Ethereum block proof", "Hardware named")
    row("Jan 2025", f"{a:.2f}", "about 160 RTX 4090s for 90 percent real-time (Succinct, May 2025 estimate)")
    row("Dec 2025", "under 0.04", "16 x RTX 5090 (SP1 Hypercube 99.7 percent under 12 s); Pico Prism 16 GPUs")
    row("Sep 2026", f"{b:.3f}", "ZisK 4 x RTX 5090 p99 9.62 s (Aug 2026); Cysic Venus 7.4 s on 24 GPUs (Apr 2026)")
    print(f"\nThe 20-month ratio is {a/b:.0f}x, which is {1/per_year:.0f}x per year. That rate cannot hold (it is software catching up with hardware), so the table below uses 1.5x, 3x and 10x per year from today's measured Igneum shard times.\n")

    print("### 1.7 Which card tier proves a v1 shard in under 10 s in 2028 (measured 6 Oct 2026 times, prover-tiers-real-cards.md, divided by two years of software gain)\n")
    tiers = [("RTX 3060 12 GB", 37.5, 14.4), ("RTX 4060 8 GB (core-only beside, alone)", 22.1, 18.4), ("RTX 4070 12 GB", 27.3, 12.1), ("RTX 4060 Ti 16 GB", 34.6, 11.6), ("RTX 3080 10 GB", 25.6, 7.1), ("RTX 3090 24 GB", 19.9, 14.9), ("RTX 4090 24 GB", 26.1, 6.3), ("RTX 5070 12 GB", 37.2, 4.8), ("RTX 5090 32 GB", 10.7, 6.3)]
    header("Card", "Beside the miner today, s", "Alone today, s", "2028 at 1.5x/yr (beside / alone)", "2028 at 3x/yr", "2028 at 10x/yr", "Under 10 s beside the miner in 2028?")
    for name, beside, alone in tiers:
        cells = []
        for g in (1.5, 3, 10):
            cells.append(f"{beside/g**2:.1f} / {alone/g**2:.1f}")
        verdict = "yes at 3x or more" if beside / 9 < 10 else "no"
        if beside / 2.25 < 10:
            verdict = "yes even at 1.5x"
        row(name, beside, alone, *cells, verdict)
    print("\nConsequence per tier: at the floor rate (1.5x a year) only the 32 GB card mines and proves inside 10 s in 2028, so a 10-s proof lag at launch is a 24 GB and 32 GB story; at 3x a year every card from the 3060 up does it, and the 8 GB card alone proves in 2 s. The block-proof target (under 10 s behind the tip) should be written as a function of the measured fleet median, re-read each era, not as a date.\n")

# ---------------------------------------------------------------- 2. rental tax
def rental_tax():
    print("\n## 2. Idea 1: the reward rule that prices rented hash out\n")
    print("Rule modelled: m = clamp(W30 / H_now, m_min, 1) where W30 is the 30-day work-weighted hash (the finality window's blue blocks per DAA second, which every node already computes for W2) and H_now the DAA-window estimate. The block subsidy paid to the producer is m x the schedule; the remainder (1 - m) x subsidy goes to the proving pool escrow of that block (not to incumbents, to avoid the cartel transfer; see the Monero attack in the text). Fees are untouched.\n")
    E = v("emission_ign_per_block") * 3600  # IGN per hour
    rent = v("rented_usd_per_gh_hour")
    header("Network hash", "Attacker adds", "H_now / W30", "m", "Attacker's share of blocks", "Attacker IGN per hour, no rule", "With rule", "Rent USD per hour", "Break-even IGN price, no rule", "With rule", "To the pool per hour, IGN")
    for net in (1, 10, 100, 1000):
        for mult in (1.0, 2.0, 5.0):
            add = net * mult
            ratio = (net + add) / net
            m = max(0.25, min(1.0, 1 / ratio))
            share = add / (net + add)
            no_rule = E * share
            with_rule = no_rule * m
            cost = add * rent
            pool = E * (1 - m)
            row(f"{net} GH/s", f"{add:.0f} GH/s", f"{ratio:.1f}", f"{m:.2f}", f"{share:.2f}", f"{no_rule:,.0f}", f"{with_rule:,.0f}", f"{cost:,.0f}", f"{cost/no_rule:.5f}", f"{cost/with_rule:.5f}", f"{pool:,.0f}")
    print("\nHonest-growth cost: a listing that doubles honest hash overnight halves every miner's subsidy per block (not per hash: difficulty halves the per-hash rate anyway; the rule halves it again) until W30 catches up, which is the 30-day ramp of ledger C7 (0.9x on day 28 to 31). With the floor m_min = 0.25 the worst case is a 4x cut, and the money is not lost to the chain: it reaches the provers of the same block, who are the same population. Per tier: a home miner's monthly income during a doubling month falls 50 percent under the rule against 50 percent already from difficulty (so 25 percent of the pre-event figure); a pool user sees the same through PPLNS; a prover with weight gains the diverted share. The gate: in the economy simulator (sim/economy/sim.py scenario f, a pool with the network's hash arriving on day 10) the incumbents' income under the rule must stay above the no-rule row for the 30 days and the newcomers' under; and in the fast-time harness a timestamp-manipulated H_now (headers inside the 132-s tolerance) must move m by under 2 percent.\n")

# ---------------------------------------------------------------- 3. work stake
def work_stake():
    print("\n## 3. Idea 2: work-stake, vote weight as the external-job bond\n")
    print("A key that claims an external job and delivers late or wrong loses s of its 30-day weight for 30 days (as equivocation strips 100 percent, spec 3.6). Weight is blue blocks; it cannot be bought, only mined. Arithmetic: what a stripped key forgoes.\n")
    E = v("emission_ign_per_block")
    header("Key's hash share", "Blocks per 30 days at 1 bps", "Weight share", "Shard sortition income per 30 days (20 percent pool, pro rata), IGN", "Stripped at s = 25 percent: lost pool income over 30 days, IGN", "Stripped at s = 100 percent", "IGN bond that would match (design 4.6: maxPgas x f_p x 1.5 for a 1 B-cycle job at the floor)")
    for share in (0.0001, 0.001, 0.01, 0.1):
        blocks = share * 86400 * 30
        pool_30d = 0.2 * E * 86400 * 30 * share
        row(f"{share*100:.2f} percent", f"{blocks:,.0f}", f"{share*100:.2f} percent", f"{pool_30d:,.0f}", f"{pool_30d*0.25:,.0f}", f"{pool_30d:,.0f}", "0.0015 IGN")
    print("\nReading: for every key above dust the 30-day pool income at risk is many orders above the designed IGN bond for one job, so weight is a far larger bond than coins, and it is a bond nobody can buy on a market. It also strips the key's vote for 30 days, which is the sentence the finality rule already hands out for equivocation. The cost: a false positive (a partition that makes an honest proof late) strips an honest voter; so the rule must use DAA time, a long deadline (the 120-s claim timeout of P9 decision, or longer), and a one-strike grace per 30 days. Per tier: a solo 8 GB miner below dust has no weight and so cannot take external jobs at all under this rule (it can still prove shards, which carry no bond); a pool user's jobs are the pool's and the pool's weight is at risk, which is what a pool operator wants priced. Gate: on the phase 4 devnet, 1,000 jobs with a 10 percent injected late rate: every injected fault stripped, zero honest keys stripped across a 60-s partition.\n")

# ---------------------------------------------------------------- 4. burn bounty
def burn_bounty():
    print("\n## 4. Idea 6: audits paid from the burn, by 60 percent signal, no standing address\n")
    full_day = v("base_fee_full_day_ign")
    header("Chain traffic (fraction of full blocks)", "Base fee burned per day, IGN", "7-day redirect, IGN", "30-day redirect, IGN", "USD at 0.02 (7 d / 30 d)", "USD at 0.10 (7 d / 30 d)")
    for frac in (0.01, 0.1, 0.5, 1.0):
        d = full_day * frac
        row(f"{frac:.2f}", f"{d:,.0f}", f"{7*d:,.0f}", f"{30*d:,.0f}", f"{7*d*0.02:,.0f} / {30*d*0.02:,.0f}", f"{7*d*0.10:,.0f} / {30*d*0.10:,.0f}")
    print("\nReading: at launch traffic (1 to 10 percent of full blocks) a 30-day redirect is USD 1,600 to 16,000 at 0.02 per IGN, under one Code4rena contest (base pricing from USD 6,500 before the 2025 zero-fee change; Immunefi's standard pays 10 percent of funds at risk). At half-full blocks it reaches a serious bounty (USD 78,000 for 30 days at 0.02). So the burn can fund audits only once the chain is used; before that the only money is the client's 1 percent dev fee and the founders' mined coins (litepaper: grants from founders' mined coins). The text gives the attack: this is a dev fund with a 60 percent veto and a per-event payee, which is exactly the switch spec 5.5 removed.\n")

# ---------------------------------------------------------------- 5. rental settlement
def rental_settlement():
    print("\n## 5. Idea 10: Igneum as the settlement layer for GPU rental\n")
    header("Card", "Vast.ai on-demand USD/h (cited)", "Platform take modelled", "Host loses USD per card-year", "Igneum settlement cost per rental (2 transfers at the floor), IGN", "At 0.02 and 0.10 USD per IGN", "Hours of rental to pay 1 USD of chain fees at 0.02")
    for name, price in (("RTX 5090", v("rtx5090_rent_usd_h")), ("RTX 4090", v("rtx4090_rent_usd_h"))):
        for take_name, take in (("Vast about 15 percent", v("vast_take")), ("RunPod about 7 percent", v("runpod_take"))):
            lost = price * take * 8766
            fee = 2 * v("plain_transfer_ign")
            row(name, f"{price:.2f}", take_name, f"{lost:,.0f}", f"{fee:.4f}", f"{fee*0.02:.5f} / {fee*0.10:.4f}", f"{1/(fee*0.02)/ (1/1):,.0f} rentals")
    print("\nReading: the chain's fee is three to five orders of magnitude under the platform take. The platform's take pays for what the chain cannot do: matching, trust, dispute, image hosting, and the verification of delivered work. The honest problem is the last one: a rented hour of general compute is unverifiable, so an on-chain escrow without a verifier is a trust-me payment with lower fees. What is verifiable on this chain today: ZK proving jobs (the precompile); what is verifiable with sampling: deterministic recompute checked on a sampled fraction (SPEX, arXiv 2503.18899; Render's result-quorum, approximate); what needs hardware the fleet does not have: TEE attestation (NVIDIA confidential computing is H100 and H200 class, phala.com; no consumer card has it).\n")

# ---------------------------------------------------------------- 6. beacon
def beacon():
    print("\n## 6. Idea 12: a randomness beacon from the checkpoint VDF\n")
    header("Beacon", "Period", "Latency to a value", "Unbiasability argument", "Verify cost", "Who runs it")
    row("drand quicknet (League of Entropy)", f"{v('drand_quicknet_period_s')} s", "about 3 s", "threshold BLS over H(round) with a 2/3 threshold of about 20 named organisations; unbiasable while under 1/3 collude; unchained", "one BLS verify", "a league, trusted set")
    row("Igneum epoch seed today", "3,600 s", f"{v('vdf_10min_s')} s (10-min VDF)", "a certified checkpoint 10 minutes before use; the VDF makes the last block producer's choice useless because it cannot see the output in time", "4.47 ms (516 B)", "nobody: any node evaluates")
    row("Proposed: a per-checkpoint VDF beacon", f"{v('checkpoint_period_s')} s", "30 to 60 s (a 30-s VDF of each certified checkpoint hash)", "the checkpoint is locked by 2/3 of 30-day weight before the VDF starts, so no single party chooses the input; a last-block grind costs a block's subsidy per try and buys one bit of influence only if the attacker can evaluate the VDF faster than the chain, which is the class-group ASIC question (Chia timelords)", "4.47 ms per value, 2,880 values a day", "nobody: the epoch pipeline already exists")
    print("\nReading: the chain already produces an unbiasable value once an hour with a 10-minute delay. A 30-s beacon is the same code at 120x the cadence, and its honest limit is the one Chia carries: the fastest class-group squarer sets the floor on 'delay', so a timelord-class ASIC owner can learn the value earlier than everyone else (Chia docs: timelords are software or ASIC). That earlier knowledge is a front-running edge, not a bias. The product: PREVRANDAO per block already comes from this pipeline (spec 7.1); the beacon makes it a 30-s value usable off-chain (lotteries, shuffles, timelock encryption as drand does).\n")

# ---------------------------------------------------------------- 7. proving income
def proving_income():
    print("\n## 7. Idea 14: proving other chains as the main income by 2030\n")
    eth_day = v("ethproofs_usd_per_block_sep2026") * v("eth_blocks_per_day")
    emission_day_ign = v("emission_ign_per_block") * 86400
    header("Income line", "USD per day", "Basis")
    row("Proving every Ethereum L1 block at the Sep 2026 tracker cost", f"{eth_day:,.0f}", "0.005 USD x 7,200 blocks; the price a buyer pays is above cost, call it 10x: 360")
    row("The same at the Dec 2025 cost (under 0.04)", f"{0.04*7200:,.0f}", "secondary")
    for p in (0.005, 0.02, 0.10):
        row(f"Igneum year-1 emission at {p} USD per IGN", f"{emission_day_ign*p:,.0f}", "31.688 IGN per block x 86,400")
    row("Rollup proving spend, all rollups (customer brief)", f"{3e6/365:,.0f} to {10e6/365:,.0f}", "low millions a year, approximate")
    row("Boundless trailing day in the explorer (4 Oct 2026)", f"{8.4*0.21:,.0f}", "8.4 T cycles at a 0.21 USD per B-cycle median, developer-adoption.md 2b, approximate")
    print("\nReading: the whole public proving market is three to four orders of magnitude under year-1 emission at any price input. For proving to be the main income by 2030, demand must grow about 1,000x while cost per proof keeps falling 3x to 30x a year, which pushes dollars per proof down as fast as volume rises. The arithmetic says never by 2030 for 'main income'; it says 'yes' for 'a second income that keeps cards on after the subsidy fades' (spec 5.10.2), which is the design's own claim.\n")

if __name__ == "__main__":
    print("# frontier_model.py output (Horizon lane 7), run on " + __import__("datetime").date.today().isoformat())
    print("\nInputs and labels:\n")
    header("Key", "Label", "Value", "Source")
    for k, (lab, val, src) in INPUTS.items():
        row(k, lab, val, src)
    predictions_2030()
    rental_tax()
    work_stake()
    burn_bounty()
    rental_settlement()
    beacon()
    proving_income()