Q TOKENOMICS3,000,000,000 Q OWNERSHIP LEDGER.

#!/usr/bin/env python3
"""Q Nation Public Constitutional Tokenomics Model (v5, 12 Nov 2026):
Every constitutional figure in the public White Paper and Tokenomics Report is computed here and checked.
Any broken invariant throws immediately. Verifies the 3,000,000,000 Q fixed supply, the 85/15 rule,
the 10 public rounds (R1 $8M to R10 $4.096B) + 300,000,000 Q Strategic Founding Reserve inside the 25% Rounds Vault,
the V/10 two-quarter audited revenue gates, the 5 work-pool stages, the 7 daily halving pots,
the 39.9% blended contribution margin, and the 36-month D22 monthly cost cap."""
import json
from fractions import Fraction as F
from pathlib import Path

ROOT = Path(__file__).resolve().parent


class MissingInput(KeyError):
    """A figure the model needs is absent. It is never guessed and never read as zero."""


def need(value, name):
    if value is None:
        raise MissingInput(f'missing input: {name}')
    return value


def req(record, keys, where):
    if not isinstance(record, dict):
        raise MissingInput(f'{where}: expected a record, got {type(record).__name__}')
    for k in keys:
        if k not in record or record[k] is None:
            raise MissingInput(f'{where}: missing {k}')
    return [record[k] for k in keys]


def check(cond, msg):
    """An invariant that still throws under python -O."""
    if not cond:
        raise AssertionError(msg)

N = 3_000_000_000                       # Q = 100% of QUIT
SPLIT = {                                # MP-D5, 8 Nov 2026
    'rounds': F(25, 100), 'work': F(40, 100), 'builders': F(10, 100),
    'treasury': F(10, 100), 'founder': F(5, 100), 'team': F(10, 100)}  # MP-D46, 9 Nov: Founder 5%, team 10%
check(sum(SPLIT.values()) == 1, 'the six shares add to 100%')
ALLOC = {k: int(N * v) for k, v in SPLIT.items()}
PEOPLE = ALLOC['rounds'] + ALLOC['work'] + ALLOC['builders'] + ALLOC['treasury']
check(PEOPLE * 100 // N == 85, "the people's four blocks are 85%")

# Inside the 750,000,000 Q (25%) Rounds Vault: 300,000,000 Q Strategic Founding Reserve + 450,000,000 Q across 10 Public Rounds
FOUNDING_RESERVE_Q = 300_000_000
check(0 < FOUNDING_RESERVE_Q < ALLOC['rounds'], "the Strategic Founding Reserve sits inside the rounds' 25%")
# The people's public rounds: ten rounds of 45,000,000 Q following the 300,000,000 Q Strategic Founding Reserve, valuation doubling from $8M
ROUNDS = 10
PER_ROUND = (ALLOC['rounds'] - FOUNDING_RESERVE_Q) // ROUNDS
VALS = [8_000_000 * 2 ** i for i in range(ROUNDS)]
rounds = []
raised = 0
for i, v in enumerate(VALS, 1):
    price = F(v, N)
    raise_ = PER_ROUND * price
    raised += raise_
    rounds.append(dict(round=i, valuation=v, price=float(price), q_per_100=int(100 / price),
                       worth_if_sold_3b=int(100 / price), multiple_at_3b=float(F(3_000_000_000, v)),
                       round_raises=float(raise_), raised_so_far=float(raised)))
check(PER_ROUND == 45_000_000 and FOUNDING_RESERVE_Q + ROUNDS * PER_ROUND == ALLOC['rounds'],
      'the 300,000,000 Q Strategic Founding Reserve and ten public rounds of 45,000,000 Q fill the 750,000,000 Q Rounds Vault')
check(round(float(raised)) == 122_760_000, 'ten public rounds of 45,000,000 Q raise $122,760,000')
RAISE_MIN = float(raised) / 1.07       # every buy referred, 7% of Q goes to three referral levels

# Work and community: released as real members grow (stage, members at end of stage, share of the 1.2B)
STAGES = [(1, 100_000, F(10, 100)), (2, 1_000_000, F(20, 100)), (3, 10_000_000, F(30, 100)),
          (4, 100_000_000, F(25, 100)), (5, 1_000_000_000, F(15, 100))]
check(sum(s for _, _, s in STAGES) == 1, 'the five stage shares add to 100%')
stages, prev = [], 0
for n, upto, share in STAGES:
    q = int(ALLOC['work'] * share)
    stages.append(dict(stage=n, members_from=prev, members_to=upto, q=q,
                       q_per_new_member=float(F(q, upto - prev))))
    prev = upto
check(sum(s['q'] for s in stages) == ALLOC['work'], 'the five stages add to 1,200,000,000 Q')
POTS = {'job_board': F(30, 100), 'invites_and_creators': F(20, 100), 'holding_quit': F(20, 100),
        'games': F(10, 100), 'academy': F(10, 100), 'departments_and_cups': F(5, 100), 'reserve': F(5, 100)}
check(sum(POTS.values()) == 1, 'the seven pot shares add to 100%')

# Founder and team unlock with real members (MP-D6); all at a sale
UNLOCK = [(100_000, F(1, 4)), (1_000_000, F(1, 4)), (10_000_000, F(1, 4)), (100_000_000, F(1, 4))]
check(sum(s for _, s in UNLOCK) == 1, 'the four unlock steps add to 100%')

# What Q is worth at any QUIT value: value / N. The phase scenarios are assumptions, stated as such.
def q_value(valuation):
    return valuation / N
PHASES = [  # name, real members, revenue per member per year (assumption), revenue multiple (assumption)
    ('I. Launch', 100_000, 60, 10), ('II. Launchpad live', 1_000_000, 80, 10),
    ('III. AI workers for everyone', 10_000_000, 100, 10), ('IV. Global', 100_000_000, 120, 10),
    ('V. The people\'s economy', 1_000_000_000, 300, 10)]
phases = []
for name, m, arpu, mult in PHASES:
    rev = m * arpu; val = rev * mult
    phases.append(dict(phase=name, members=m, revenue_per_member=arpu, revenue=rev, multiple=mult,
                       valuation=val, q_value=q_value(val), q_for_1m=1_000_000 / q_value(val)))
check(abs(phases[-1]['valuation'] - 3e12) < 1 and abs(phases[-1]['q_value'] - 1000) < 1e-9, 'phase V: 1 Q = $1,000')

# Paths: Q earned by work in stage 1, at example rates set from the stage 1 pots (the live rates are set daily by each pot)
STAGE1_PER_MEMBER = stages[0]['q_per_new_member']                  # 1,200 Q per new real member in stage 1
INVITE_PER_MEMBER = STAGE1_PER_MEMBER * float(POTS['invites_and_creators'])   # 240 Q: 160 to the inviter, 80 to the newcomer
RATES = {'task': 50, 'raid_action': 10, 'event_hosted': 5_000, 'active_member_brought': 160,
         'creator_brought': 2_500, 'course_taught': 25_000, 'course_finished': 100}
NEWCOMER = 80
check(RATES['active_member_brought'] + NEWCOMER == INVITE_PER_MEMBER, 'invite pay: 160 + 80 = 240 Q')
POT_OF = {'task': 'job_board', 'raid_action': 'job_board', 'event_hosted': 'job_board',
          'active_member_brought': 'invites_and_creators', 'creator_brought': 'invites_and_creators',
          'course_taught': 'academy', 'course_finished': 'academy'}
PATHS = {
  'Network leader': {'active_member_brought': 5_000, 'event_hosted': 12, 'task': 100},
  'Marketer or blogger': {'creator_brought': 20, 'active_member_brought': 500, 'task': 200},
  'Illustrator who teaches': {'course_taught': 1, 'event_hosted': 4, 'task': 150, 'raid_action': 600, 'course_finished': 4},
  'Student or new starter': {'task': 150, 'raid_action': 400, 'active_member_brought': 10, 'course_finished': 6},
}
MIX = {'Network leader': 8, 'Marketer or blogger': 50, 'Illustrator who teaches': 200, 'Student or new starter': 2_000}
paths = []
for who, acts in PATHS.items():
    q = sum(RATES[a] * n for a, n in acts.items())
    paths.append(dict(who=who, actions=acts, q=q, at_300m=q * q_value(3e8), at_3b=q * q_value(3e9),
                      at_30b=q * q_value(3e10), at_3t=q * q_value(3e12)))
# Example-mix check (D08 renames the papers' "It all fits."): this one hand-picked mix of 2,258 earners (2.26% of stage 1's
# 100,000 real members) fits inside every stage 1 pot at the example rates and brings no more members than the stage
# holds. It does not test the whole stage population; population_check() further down does.
stage1 = stages[0]['q']
spend = {p: 0 for p in POTS}
brought = 0
for who, acts in PATHS.items():
    for a, n in acts.items():
        spend[POT_OF[a]] += RATES[a] * n * MIX[who]
        if a == 'active_member_brought':
            spend['invites_and_creators'] += NEWCOMER * n * MIX[who]
            brought += n * MIX[who]
for pot, used in spend.items():
    check(used <= stage1 * POTS[pot], (pot, used, stage1 * POTS[pot]))
check(brought <= stages[0]['members_to'], brought)
mix_need = sum(spend.values())


# Proof-gated rounds (MP-D14, kept by MP-D130): public round N >= 5 opens at a yearly revenue run rate of one tenth of
# its valuation
for r in rounds:
    r['revenue_gate'] = None if r['round'] <= 4 else r['valuation'] / 10
check(rounds[4]['revenue_gate'] == 12_800_000 and rounds[9]['revenue_gate'] == 409_600_000,
      'gates: round 5 $12.8M, round 10 $409.6M')
OPEN_NOW_RAISE = sum(r['round_raises'] for r in rounds[:4])
check(round(OPEN_NOW_RAISE) == 1_800_000, 'public rounds 1 to 4 raise $1,800,000')

# The 85/15 rule (MP-D13, split changed by MP-D46): at any sale, Founder <= 5%, team <= 10%, every issued Q paid the same, the people's
# unissued value paid to real members as a people's dividend. Check the review's early-sale scenario.
# T4 (audit A19, A10): the shares are now computed from the Q each holder is paid, every one of the 3,000,000,000 Q
# exactly once at the same price, so the check can fail. the Founder is paid on his 150,000,000 Q (all unlock at a sale, MP-D6).
# The team is paid only on team Q granted to a named person and vested on the record date (D15); ungranted or unvested
# team Q joins the people's dividend. People's Q issued must lie between 0 and 2,550,000,000 and the dividend can never
# be negative. Every input is required.
def sale(price, issued_people_q, *, team_q_vested):
    need(price, 'sale price'); need(issued_people_q, "people's Q issued"); need(team_q_vested, 'team Q granted and vested')
    check(price > 0, f'sale price must be above 0: {price}')
    check(0 <= issued_people_q <= PEOPLE, f"people's Q issued must lie between 0 and {PEOPLE:,}: {issued_people_q:,}")
    check(0 <= team_q_vested <= ALLOC['team'], f"team Q granted and vested must lie between 0 and {ALLOC['team']:,}")
    per_q = price / N
    q_paid = dict(founder=ALLOC['founder'], team=team_q_vested, people_q=issued_people_q,
                  dividend=PEOPLE - issued_people_q + ALLOC['team'] - team_q_vested)
    check(sum(q_paid.values()) == N, 'every Q is paid exactly once at a sale')
    usd = {k: q * per_q for k, q in q_paid.items()}
    check(usd['dividend'] >= 0, f"the people's dividend can never be negative: {usd['dividend']:,.0f}")
    people_share = (usd['people_q'] + usd['dividend']) / price
    founder_share, team_share = usd['founder'] / price, usd['team'] / price
    check(people_share >= 0.85 - 1e-12, f'the people get at least 85% at a sale: {people_share:.6f}')
    check(founder_share <= 0.05 + 1e-12, f'the Founder gets at most 5% at a sale: {founder_share:.6f}')
    check(team_share <= 0.10 + 1e-12, f'the team gets at most 10% at a sale: {team_share:.6f}')
    check(abs(sum(usd.values()) - price) <= 1e-9 * price, 'the sale price is paid out in full, no more')
    return dict(founder=usd['founder'], team=usd['team'], people_q=usd['people_q'], dividend=usd['dividend'],
                people_share=people_share, founder_share=founder_share, team_share=team_share, dividend_q=q_paid['dividend'],
                team_q_vested=team_q_vested)
early = sale(3e9, 460_000_000, team_q_vested=ALLOC['team'])     # the review's case: all team Q granted and vested
check(abs(early['people_share'] - 0.85) < 1e-9 and round(early['dividend']) == 2_090_000_000, 'the early sale: 85%, $2,090,000,000')
for issued in (0, 300_000_000, 1_000_000_000, 2_550_000_000):
    check(sale(3e9, issued, team_q_vested=ALLOC['team'])['people_share'] >= 0.85 - 1e-9, issued)
for bad in (-1, PEOPLE + 1, 2_900_000_000, 5_000_000_000):      # A19: these used to pass with a negative dividend
    try:
        sale(3e9, bad, team_q_vested=ALLOC['team'])
    except AssertionError:
        pass
    else:
        raise AssertionError(f"sale() accepted {bad:,} people's Q issued")

# Community milestones and the community value model (8 Nov 2026). Value per real member = revenue per member
# per year x 10, using the phase assumptions above until Open Books reports measured revenue per member.
def per_member_value(members):
    for name, upto, arpu, mult in PHASES:
        if members <= upto:
            return arpu * mult
    return PHASES[-1][2] * PHASES[-1][3]
UNLOCKS = {100_000: "Founder and team 25% unlock; work pool stage 2", 1_000_000: "Live launches open; Founder and team 50%; stage 3",
           10_000_000: "Founder and team 75%; stage 4", 100_000_000: "Founder and team 100%; stage 5",
           1_000_000_000: "One billion owners"}
MILESTONES = [10_000, 25_000, 50_000, 100_000, 250_000, 500_000, 1_000_000, 5_000_000, 10_000_000, 50_000_000,
              100_000_000, 1_000_000_000]
milestones = []
for m in MILESTONES:
    v = m * per_member_value(m)
    milestones.append(dict(members=m, value_per_member=per_member_value(m), community_value=v, q_value=v / N,
                           alex_12400_q=12_400 * v / N, unlock=UNLOCKS.get(m, '')))
vals = [x['community_value'] for x in milestones]
check(all(b > a for a, b in zip(vals, vals[1:])), 'the model value must rise at every milestone')
check(milestones[3]['community_value'] == 60_000_000 and milestones[-1]['q_value'] == 1000, 'milestones: $60M at 100,000; $1,000 a Q at 1B')


# ======================================================================================================================
# v3, 9 Nov 2026 (UTC): the economics audit fixes approved in MP-D56. ECONOMICS-AUDIT.md items in brackets.
# Inputs first. PLAN_INPUTS are the Founder's decisions; ASSUMPTIONS are figures the plan does not set, each with its basis.
# ======================================================================================================================
PLAN_INPUTS = {
    'founder_cap': (F(5, 100), 'MP-D46: the Founder gets at most 5% of any payout or sale'),
    'team_cap': (F(10, 100), 'MP-D46: the team gets at most 10%'),
    'payout_share_floor': (F(1, 2), 'MP-D9, kept by D23: at least 50% of distributable profit'),
    'payout_reserve_months': (6, 'D23: 6 months of operating costs kept in reserve before a payout'),
    'window_max_share_of_unpaid_profit': (F(1, 2), 'D25: at most half of the profit not paid out goes to the Window'),
    'window_account_cap_share': (F(2, 100), "D25: the per-account cap, 'for example 2% of the quarter's cap'"),
    'window_bought_months': (12, 'D25: bought Q can be offered after 12 months'),
    'window_earned_ready_months': (6, 'D25: earned Q can be offered after 6 months READY'),
    'window_open_business_days': (20, 'D25: the Window stays open 20 business days'),
    'reference_multiple': (10, 'D24: 10 times audited revenue over the last 12 months, divided by 3,000,000,000'),
    'even_release_days': (180, 'D18: each release into the MINING and games pots pays out evenly over 180 days'),
    'even_release_pots': (('holding_quit', 'games'), 'D18: the MINING (holding) and games pots'),
    'dividend_cap_x_median': (5, "D13: at most 5 times the median per person"),
    'meter_multiple': (10, 'D05: the dollar figure is 10 times audited revenue over the last 12 months'),
    'gate_quarters': (2, 'D26: the last two audited quarters, both above the gate'),
    'real_member_days': (30, 'WHITE-PAPER 4.1: a real action in the last 30 days'),
    'shop_cash_back_rate': (F(5, 100), 'TOKENOMICS-REPORT 12.1: 5% of every card payment in THE SHOP back in Q'),
    'wx_job_price': (150, 'MP-D33: the example job'),
    'wx_cut': (F(20, 100), 'MP-D33: QUIT keeps 20%'),
    'builder_rate_first_month': (F(40, 100), "WHITE-PAPER 4.2: 40% of the first month"),
    'builder_rate_after': (F(25, 100), 'WHITE-PAPER 4.2: 25% of every payment after that'),
    'builder_team_levels': (F(14, 100), 'WHITE-PAPER 4.2: 5, 3, 2, 1, 1, 1 and 1% over seven team levels'),
    'builder_cap': (F(45, 100), "D04: inside the Builders' 45% cap on field pay"),
    'stage1_target_members': (100_000, 'Stage 1 real verified members target by Dec 2027 (plan pace Q4)'),
    'q1_checkpoint_members': (10_000, 'Q1 Mar 2027 90-day checkpoint on the way to Stage 1 100,000 real members'),
    'launchpad_swap_fee': (
        dict(creator=F(60, 10000), inviter=F(30, 10000), level_2=F(10, 10000), level_3=F(5, 10000),
             quit_treasury=F(21, 10000), meteora=F(24, 10000)),
        'MP-D123 and MP-D134: 1.50% total launchpad swap fee on trades placed through QUIT'),
}
ASSUMPTIONS = {
    'card_fee_rate': (F(35, 1000), "card fee on a Work Exchange job; the higher of the audit's two figures "
                                   "(v6/audit/flow_checks.py; stress_model.py uses 2.9%)"),
    'card_fee_fixed': (F(30, 100), 'card fee per payment, both audit scripts'),
    'wx_ai_cost_per_job': (5, 'AI work on a $150 job (WHITE-PAPER 3.5, as stress_model.py reads it)'),
    'chargeback_reserve_rate': (F(1, 100), 'card disputes run for up to about 120 days (stress_model.py)'),
    'wx_builder_share': (F(1, 2), 'share of Work Exchange jobs from Builder-brought businesses'),
    'wx_first_month_share': (F(1, 12), "share of a Builder-brought business's jobs in its first month (a 12-month stay)"),
    'cs_plan_mix': ({'STARTER': F(60, 100), 'WEEKLY': F(30, 100), 'DAILY': F(8, 100), 'AGENCY': F(2, 100)},
                    'Creator Studio plan mix (stress_model.py)'),
    'cs_builder_sold_share': (F(1, 2), 'share of Creator Studio plans sold by Builders (stress_model.py)'),
    'cs_half_q_share': (F(1, 4), 'share of Creator Studio plans paid half with Q (stress_model.py)'),
    'revenue_mix': ({'creator_studio': F(1, 2), 'work_exchange': F(1, 2)},
                    'the two revenue lines with costed inputs; THE ACADEMY and data licences have none yet'),
    'fixed_cost_month': (200_000, 'planned fixed costs, the lean $2.4M a year (stress_model.py)'),
    'variable_cost_member_year': (2, 'hosting, help chat, CHECKS reviews, per real member (stress_model.py)'),
    'cost_cap_runway_months': (12, "D22's hard monthly cost cap: a month's costs at most 1/12 of cash on hand plus "
                                   "that month's contribution, so cash always covers 12 months at the current spend"),
    'refund_rate': (F(2, 100), 'revenue refunded'),
    'flagged_revenue_rate': (F(0), 'revenue from accounts CHECKS flags (left out of the D26 gate)'),
    'audit_lag_quarters': (1, 'an audited quarter lands one quarter after it ends'),
    'cash_plan_start': ((2027, 1), 'the first month after the issuer is named by 31 Dec 2026 (MP-D32); the rounds '
                                   "sell only once MP-D54's gates are met"),
    'cash_plan_months': (36, 'three years'),
    'member_paths': ({'plan pace': [10_000, 25_000, 50_000, 100_000, 150_000, 225_000, 340_000, 500_000, 650_000,
                                    800_000, 900_000, 1_000_000],
                      'slow growth': [4_000, 6_000, 9_000, 12_000, 15_000, 18_000, 21_000, 24_000, 27_000, 30_000,
                                      33_000, 36_000]},
                     'real members at each quarter end (stress_model.py)'),
    'cash_cases': ({'low': dict(path='slow growth', revenue_per_member=30, rounds_1_4_months=30),
                    'base': dict(path='plan pace', revenue_per_member=30, rounds_1_4_months=18),
                    'high': dict(path='plan pace', revenue_per_member=60, rounds_1_4_months=9)},
                   'revenue per real member a year at half the plan ($30) and at the plan ($60), as D27 asks; '
                   'rounds 1 to 4 sell evenly over the months shown'),
    'gated_round_months': (6, 'an open gated round sells its 45,000,000 Q evenly over 6 months'),
    'starting_operating_reserve_usd': (400_000, 'initial operating cash reserve at cash-plan start (Jan 2027) under the D22 1/12 monthly cap'),
    'cash_plan_window_share': (F(1, 2), 'the Window takes the most D25 allows, the hardest case for cash'),
    'growth_forecast_per_day': (300, 'new real members a day (the audit A14 example)'),
    'expected_actions_per_day': (1_000, 'paid actions a day on THE JOB BOARD (the audit A14 example)'),
    'pot_scenario_days': (300, 'days in the pot scenario, all inside stage 1'),
    'pot_scenario_viral_day': (240, 'the day 3,000 extra real members join at once (the audit A14 example)'),
    'pot_scenario_viral_extra': (3_000, 'the audit A14 example'),
    'mining_example_quit': (1_250_000, 'the example member Alex holds 1,250,000 $QUIT (OFFICE-V6, KIT-V6)'),
    'mining_example_multiplier': (2, 'Alex at 94 days held, the 2x step (D28)'),
    'mining_example_q_today': (180, "the frames' example day: '+180 Q MINED TODAY' (OFFICE-V6 6.7, proposed) and "
                                    "'+180 Q TODAY FROM HOLDING' (MM01, QU02)"),
    'participation_spreads': ({'the example mix': 'MIX',
                               '10% work like the student': {'Student or new starter': 10_000},
                               '50% work like the student': {'Student or new starter': 50_000},
                               '10%, in the example proportions': 10_000,
                               '25%, in the example proportions': 25_000},
                              'who works in stage 1 (100,000 real members); the rest earn only the 80 Q newcomer Q'),
    'dividend_example_population': ([
        dict(group='real members, light checked work', count=60_000, id_checked=True, real_on_record_date=True,
             checked_work_q_days=500 * 60),
        dict(group='real members, regular checked work', count=20_000, id_checked=True, real_on_record_date=True,
             checked_work_q_days=5_000 * 120),
        dict(group='real members, heavy checked work', count=5_000, id_checked=True, real_on_record_date=True,
             checked_work_q_days=50_000 * 200),
        dict(group='network leaders', count=50, id_checked=True, real_on_record_date=True,
             checked_work_q_days=865_000 * 300),
        dict(group='real members with no checked work', count=15_000, id_checked=True, real_on_record_date=True,
             checked_work_q_days=0),
        dict(group='scripted accounts active 330 days, no checked work', count=50_000, id_checked=False,
             real_on_record_date=True, checked_work_q_days=0),
        dict(group='checked work, no identity check', count=2_000, id_checked=False, real_on_record_date=True,
             checked_work_q_days=5_000 * 120)],
        'an illustrative record date at 100,000 real members; Q earned through checked work x days held'),
    'dividend_example_sale_price': (60_000_000, "the plan's own value at 100,000 real members (audit A04)"),
    'window_example': (dict(audited_revenue_12m=2_000_000, last_round=4, distributable=500_000, window_share=F(1, 2),
                            offers=[dict(who='bought Q, held 14 months', q=100_000, kind='bought', months=14,
                                         id_checked=True, count=1_000),
                                    dict(who='earned Q, 7 months READY', q=5_000, kind='earned', months=7,
                                         id_checked=True, count=2_000),
                                    dict(who='one large holder, held 13 months', q=5_000_000, kind='bought', months=13,
                                         id_checked=True, count=1),
                                    dict(who='bought Q, held 6 months', q=20_000, kind='bought', months=6,
                                         id_checked=True, count=500),
                                    dict(who='earned Q, no identity check', q=10_000, kind='earned', months=9,
                                         id_checked=False, count=300)]),
                       'an illustrative quarter; none of these figures is a forecast'),
    'card_function_test': (dict(spend={'groceries': 400, 'fuel': 150, 'cash_like': 300}, interchange_rate=F(1, 100),
                                q_back_rate=F(1, 200), cap_usd_month=10),
                           'a test of the function only; D20 sets no rate until the card provider is chosen'),
    'quit_onchain_sinks': (
        dict(burned_quit=62_099_349, locked_quit=105_948_500, live_supply_quit=937_900_651),
        'Verifiable Solana on-chain $QUIT supply: 62.10M burned + 937.90M live = 1B launch supply; 105.95M locked in 12 Jupiter PDAs to Oct 2027'),
}


def P(name):
    if name not in PLAN_INPUTS:
        raise MissingInput(f'missing plan input: {name}')
    return PLAN_INPUTS[name][0]


def A(name):
    if name not in ASSUMPTIONS:
        raise MissingInput(f'missing assumption: {name}')
    return ASSUMPTIONS[name][0]


check(P('founder_cap') == SPLIT['founder'] and P('team_cap') == SPLIT['team'], 'payout caps follow the MP-D46 split')
PRICE = {r['round']: F(r['valuation'], N) for r in rounds}       # exact round prices


# ---- D26: the revenue gate reads the last two audited quarters (A16) ----------------------------------------------
def gate_states(round_no, audited_quarters):
    """State of a round after each audited quarter: OPEN, CLOSED (never opened) or PAUSED (opened, then fell below).
    Rounds 1 to 4 have no gate (MP-D14). A gated round opens when the last two audited quarters both run at or above
    its gate, net of refunds and leaving out revenue from accounts CHECKS flagged, and pauses when they do not."""
    gate = rounds[round_no - 1]['revenue_gate']
    if gate is None:
        return ['OPEN'] * len(audited_quarters)
    k, runs, states, opened = P('gate_quarters'), [], [], False
    for i, q in enumerate(audited_quarters):
        rev, refunds, flagged = req(q, ('revenue', 'refunds', 'flagged_revenue'), f'audited quarter {i + 1}')
        check(rev >= 0 and refunds >= 0 and flagged >= 0 and refunds + flagged <= rev, f'audited quarter {i + 1}')
        runs.append((rev - refunds - flagged) * 4)
        above = len(runs) >= k and all(x >= gate for x in runs[-k:])
        states.append('OPEN' if above else ('PAUSED' if opened else 'CLOSED'))
        opened = opened or above
    return states


def _qtr(run_rate, refunds=0, flagged=0):
    return dict(revenue=F(run_rate, 4) + refunds + flagged, refunds=refunds, flagged_revenue=flagged)


M = 1_600_000                    # round 5's gate / 8 (MP-D130): every test rate keeps its ratio to the gate
check(M * 8 == rounds[4]['revenue_gate'], 'the gate tests are set from round 5 gate')
gate_cases = {
    'one strong quarter': ([9 * M], ['CLOSED']),
    'two quarters above': ([9 * M, 9 * M], ['CLOSED', 'OPEN']),
    'then one below': ([9 * M, 9 * M, 7 * M], ['CLOSED', 'OPEN', 'PAUSED']),
    'one back above': ([9 * M, 9 * M, 7 * M, 9 * M], ['CLOSED', 'OPEN', 'PAUSED', 'PAUSED']),
    'two back above': ([9 * M, 9 * M, 7 * M, 9 * M, 9 * M], ['CLOSED', 'OPEN', 'PAUSED', 'PAUSED', 'OPEN']),
}
round_gate_cases = {}
for name, (runs, want) in gate_cases.items():
    got = gate_states(5, [_qtr(x) for x in runs])
    check(got == want, f'D26 gate, {name}: {got}')
    round_gate_cases[name] = dict(round=5, gate=rounds[4]['revenue_gate'], yearly_run_rates=runs, states=got,
                                  old_rule_state='OPEN' if any(x >= rounds[4]['revenue_gate'] for x in runs) else 'CLOSED')
flag_case = gate_states(5, [_qtr(8 * M, flagged=M // 10), _qtr(8 * M, flagged=M // 10)])
check(flag_case == ['CLOSED', 'OPEN'], 'flagged revenue is left out before the gate is read')
flag_case = gate_states(5, [_qtr(76 * M // 10, flagged=M // 10), _qtr(76 * M // 10, flagged=M // 10)])
check(flag_case == ['CLOSED', 'CLOSED'], 'revenue from flagged accounts never opens a round')
check(gate_states(2, [_qtr(0)]) == ['OPEN'], 'rounds 1 to 4 have no gate (MP-D14)')


# ---- T5: the work pool releases on the highest audited count ever reached; recycled Q has its own account (A09) ----
def released(m):
    """Work-pool Q released at m real members: each stage releases its Q evenly across its member range."""
    need(m, 'member count')
    check(m >= 0, f'member count below zero: {m}')
    total = F(0)
    for s in stages:
        lo, hi = s['members_from'], s['members_to']
        total += s['q'] * min(F(1), max(F(0), F(m - lo, hi - lo)))
    return total


check(released(0) == 0 and released(1_000_000_000) == ALLOC['work'], 'the release runs from 0 to 1,200,000,000 Q')
check(released(100_000) == stages[0]['q'], 'stage 1 releases 120,000,000 Q by 100,000 real members')


def stage_index(m):
    for i, s in enumerate(stages):
        if s['members_from'] <= m < s['members_to']:
            return i
    return len(stages) - 1


class QLedger:
    """One ledger over all 3,000,000,000 Q (T5). The work pool releases into the seven pots on the highest audited
    real-member count ever reached, so a dip releases nothing and takes nothing back. Q spent in THE SHOP and Q bought
    back by THE QUIT WINDOW go to their own account, 'recycled', and are paid out again from it, outside the release
    check. Every move is checked."""

    def __init__(self):
        self.bal = {'rounds_unsold': F(ALLOC['rounds']), 'work_unreleased': F(ALLOC['work']), 'recycled': F(0),
                    'members': F(0), 'builders': F(ALLOC['builders']), 'treasury': F(ALLOC['treasury']),
                    'founder': F(ALLOC['founder']), 'team': F(ALLOC['team'])}
        self.bal.update({f'pot:{p}': F(0) for p in POTS})
        self.best, self.paid_from_release, self.recycled_in, self.recycled_out = 0, F(0), F(0), F(0)

    def _move(self, a, b, q):
        check(q >= 0, f'a move is never negative: {q}')
        check(self.bal[a] >= q, f'{a} holds {float(self.bal[a]):,.0f} Q and cannot pay {float(q):,.0f} Q')
        self.bal[a] -= q
        self.bal[b] += q

    def audited_count(self, count):
        need(count, 'audited real-member count')
        best = max(self.best, count)
        add = released(best) - released(self.best)
        for p, s in POTS.items():
            self._move('work_unreleased', f'pot:{p}', add * s)
        self.best = best
        self.verify()

    def round_buy(self, q):
        self._move('rounds_unsold', 'members', q)
        self.verify()

    def pay_from_pot(self, pot, q):
        self._move(f'pot:{pot}', 'members', q)
        self.paid_from_release += q
        self.verify()

    def to_recycled(self, q):                      # Q spent in THE SHOP, or bought back by THE QUIT WINDOW
        self._move('members', 'recycled', q)
        self.recycled_in += q
        self.verify()

    def pay_from_recycled(self, q):
        self._move('recycled', 'members', q)
        self.recycled_out += q
        self.verify()

    def verify(self):
        check(sum(self.bal.values()) == N, 'the ledger holds exactly 3,000,000,000 Q')
        check(all(v >= 0 for v in self.bal.values()), 'no ledger account below zero')
        check(self.paid_from_release <= released(self.best), 'the pots paid more than the release allows')
        check(self.recycled_out <= self.recycled_in, 'recycled Q paid out is never more than recycled Q received')


L = QLedger()
L.round_buy(10_000_000)
L.audited_count(120_000)
for p in POTS:
    L.pay_from_pot(p, L.bal[f'pot:{p}'])            # the hardest case: every released Q already paid
paid_at_peak = L.paid_from_release
L.audited_count(90_000)                             # a dip: nothing is released and nothing is taken back
check(L.best == 120_000 and L.paid_from_release <= released(L.best), 'T5: a dip leaves the release check true')
old_rule_fails = paid_at_peak > released(90_000)
check(old_rule_fails, 'on the old rule (release on the current count) this valid history fails the ledger check')
L.to_recycled(1_000_000)                            # spent in THE SHOP
L.to_recycled(2_000_000)                            # bought back by THE QUIT WINDOW
L.pay_from_recycled(2_500_000)
try:
    L.pay_from_recycled(1_000_000)                  # only 500,000 recycled Q left
except AssertionError:
    pass
else:
    raise AssertionError('the recycled account paid more than it received')
release_ratchet = dict(
    audited_counts=[120_000, 90_000], counted=L.best, released_at_peak=float(released(120_000)),
    released_at_dip_old_rule=float(released(90_000)), paid_before_dip=float(paid_at_peak),
    old_rule_check_fails=old_rule_fails, recycled_in=float(L.recycled_in), recycled_paid=float(L.recycled_out),
    balances={k: float(v) for k, v in L.bal.items()})


# ---- D18 and T6: what each pot pays each day (A11, A14) -----------------------------------------------------------
def pot_days(daily_counts, days_left, start_count=0):
    """Each day: the release follows the highest audited count (T5) and splits into the seven pots. The MINING
    (holding) and games pots pay each day's release evenly over the next 180 days (D18). Every other pot has a daily
    budget (T6): what it holds plus what the rest of the stage will add, over the expected days left in the stage, and
    never more than it holds. days_left is a forecast and an input; a missing or non-positive value throws."""
    check(len(daily_counts) == len(days_left), 'one forecast per day')
    even, even_pots = P('even_release_days'), P('even_release_pots')
    best = start_count
    bal = {p: F(0) for p in POTS}
    cum_in, cum_paid = {p: F(0) for p in POTS}, {p: F(0) for p in POTS}
    hist = {p: [] for p in even_pots}
    rows = []
    for t, (count, left) in enumerate(zip(daily_counts, days_left)):
        need(count, f'audited count, day {t}')
        need(left, f'expected days left in the stage, day {t}')
        check(left > 0, f'expected days left must be above 0, day {t}')
        nb = max(best, count)
        rel = released(nb) - released(best)
        best = nb
        stage_end = released(stages[stage_index(best)]['members_to'])
        row = dict(day=t, count=best, release=rel)
        for p, s in POTS.items():
            inflow = rel * s
            bal[p] += inflow
            cum_in[p] += inflow
            if p in even_pots:
                hist[p].append(inflow)
                pay = sum(hist[p][-even - 1:-1], F(0)) / even        # releases of the 180 days before today
            else:
                pay = min(bal[p], (bal[p] + s * (stage_end - released(best))) / left)
            check(pay <= bal[p], f'{p} cannot pay more than it holds, day {t}')
            bal[p] -= pay
            cum_paid[p] += pay
            check(cum_paid[p] <= cum_in[p], f'{p} paid more than it received, day {t}')
            row[p] = pay
        rows.append(row)
    return rows


days, viral, extra, rate = (A('pot_scenario_days'), A('pot_scenario_viral_day'), A('pot_scenario_viral_extra'),
                            A('growth_forecast_per_day'))
counts = [rate * (t + 1) + (extra if t >= viral else 0) for t in range(days)]
check(max(counts) < stages[0]['members_to'], 'the pot scenario stays inside stage 1')
forecast_left = [F(stages[0]['members_to'] - c, rate) for c in counts]
pot_rows = pot_days(counts, forecast_left)
steady_holding = rate * stages[0]['q_per_new_member'] * POTS['holding_quit']
check(pot_rows[viral - 1]['holding_quit'] == steady_holding, 'D18: 180 days of steady joins pay a steady MINING day')
actions = A('expected_actions_per_day')
jb_share = POTS['job_board']
pot_scenario = dict(
    new_members_a_day=rate, viral_day=viral, viral_extra_members=extra, expected_actions_a_day=actions,
    days={str(t): {k: float(v) for k, v in pot_rows[t].items()} for t in (viral - 1, viral, viral + 1, days - 1)},
    job_board_q_per_action={str(t): float(pot_rows[t]['job_board'] / actions) for t in (viral - 1, viral, viral + 1)},
    job_board_q_per_action_old_rule_viral_day=float((rate + extra) * stages[0]['q_per_new_member'] * jb_share
                                                    / actions))
check(pot_scenario['job_board_q_per_action'][str(viral)] < pot_scenario['job_board_q_per_action_old_rule_viral_day'] / 5,
      'T6: one viral day no longer pays several times the usual task')
pot_daily = []                                       # steady state: joins at a constant rate for 180 days or more
for s in stages[:3]:
    for per_day in (100, 300, 1_000):
        pot_daily.append(dict(stage=s['stage'], new_members_a_day=per_day,
                              **{p: float(per_day * s['q_per_new_member'] * sh) for p, sh in POTS.items()}))
mining_example = []
w = A('mining_example_quit') * A('mining_example_multiplier')
for row in pot_daily:
    mining_example.append(dict(stage=row['stage'], new_members_a_day=row['new_members_a_day'],
                               holding_q_a_day=row['holding_quit'],
                               total_weight_for_example=row['holding_quit'] * w / A('mining_example_q_today')))


def mining_today(holding_q_today, weight, total_weight):
    """D18: a member's MINING Q for the day is the day's holding amount times their weight over all weight."""
    need(holding_q_today, "the day's holding amount"); need(weight, 'member weight'); need(total_weight, 'all weight')
    check(0 <= weight <= total_weight and total_weight > 0, 'a weight is part of the total')
    return holding_q_today * weight / total_weight


check(abs(mining_today(72_000, w, 72_000 * w / 180) - 180) < 1e-9, 'MINING share arithmetic')


# ---- T7 and D05: the meter reads the rule-based real-member count (A03, A09) ----------------------------------------
REAL_ACTIONS = {   # the closed list (T5): only these keep a member real
    'checked_work_paid': 'paid work that passed its check: a job, task, raid, bounty or event',
    'purchase': 'a buy: Q in a round, $QUIT through QUIT, or a shop or plan payment',
    'course_passed': 'a course passed in THE ACADEMY'}
NOT_REAL_ACTIONS = {'sign_in', 'free_play', 'holding_only', 'invite_sent', 'profile_change', 'xp_or_badge'}


def is_real_member(record, today):
    """Real member: signed in, checked, not a team account, and a real action in the last 30 days. An action that is
    on neither list throws, so the list stays closed."""
    signed_in, checked, team, acts = req(record, ('signed_in', 'checked', 'team_account', 'actions'), 'member record')
    need(today, 'today')
    real = False
    for kind, day in acts:
        need(kind, 'action kind'); need(day, 'action day')
        if kind not in REAL_ACTIONS and kind not in NOT_REAL_ACTIONS:
            raise ValueError(f'action {kind!r} is on neither list of real and other actions')
        if kind in REAL_ACTIONS and 0 <= today - day < P('real_member_days'):
            real = True
    return bool(signed_in and checked and not team and real)


base_rec = dict(signed_in=True, checked=True, team_account=False)
check(is_real_member(dict(base_rec, actions=[('checked_work_paid', 90)]), 100), 'paid checked work 10 days ago')
check(not is_real_member(dict(base_rec, actions=[('sign_in', 99), ('free_play', 99)]), 100), 'sign-ins are not real')
check(not is_real_member(dict(base_rec, actions=[('holding_only', 99)]), 100), 'holding alone is not real')
check(not is_real_member(dict(base_rec, actions=[('purchase', 60)]), 100), 'a buy 40 days ago has lapsed')
check(not is_real_member(dict(base_rec, team_account=True, actions=[('purchase', 99)]), 100), 'team accounts never count')
try:
    is_real_member(dict(base_rec, actions=[('watched_film', 99)]), 100)
except ValueError:
    pass
else:
    raise AssertionError('an action off the closed list was accepted')
try:
    is_real_member(dict(signed_in=True, checked=True, actions=[]), 100)
except MissingInput:
    pass
else:
    raise AssertionError('a member record without team_account was accepted')


def meter(highest_count, live_count, audited_revenue_12m=None, revenue_as_of=None):
    """T7 and D05. The counts are the rule-based real-member count (is_real_member); None until the first count runs,
    and then the meter says CHECKING. The headline is the highest member milestone ever reached (shown from 10,000,
    MP-D30). A dollar figure appears only as 10 times audited revenue over the last 12 months, with its date."""
    if highest_count is None or live_count is None:
        return dict(state='CHECKING')
    check(0 <= live_count <= highest_count, 'the live count is never above the highest count ever reached')
    reached = max((m for m in MILESTONES if m <= highest_count), default=None)
    nxt = next((m for m in MILESTONES if m > highest_count), None)
    out_ = dict(state='LIVE', milestone_reached=reached, live_count=live_count, next_milestone=nxt, dollar_value=None,
                dollar_as_of=None)
    if audited_revenue_12m is not None:
        out_['dollar_value'] = P('meter_multiple') * audited_revenue_12m
        out_['dollar_as_of'] = need(revenue_as_of, 'date of the audited revenue')
    return out_


meter_cases = {
    'before the first count': meter(None, None),
    'below 10,000': meter(8_000, 7_900),
    'past 10,000, live count dips': meter(12_000, 9_500),
    'with 12 months of audited revenue': meter(12_000, 11_000, audited_revenue_12m=1_200_000,
                                               revenue_as_of='31 Dec 2027')}
check(meter_cases['before the first count'] == {'state': 'CHECKING'}, 'T7: CHECKING until the first count runs')
check(meter_cases['below 10,000']['milestone_reached'] is None, 'MP-D30: next step only below 10,000')
check(meter_cases['past 10,000, live count dips']['milestone_reached'] == 10_000, 'the headline never goes back')
check(meter_cases['past 10,000, live count dips']['dollar_value'] is None, 'D05: no dollar figure before OPEN BOOKS')
check(meter_cases['with 12 months of audited revenue']['dollar_value'] == 12_000_000, 'D05: 10 x audited revenue')
try:
    meter(12_000, 11_000, audited_revenue_12m=1_200_000)
except MissingInput:
    pass
else:
    raise AssertionError('a dollar figure without its date was accepted')


# ---- D23: profit payouts on distributable profit (A06, A19) --------------------------------------------------------
def payout_split(payout_usd, people_q, founder_unlocked_q, team_counted_q):
    """One payout under the 85/15 rule (MP-D46): every Q that counts is paid the same, the Founder at most 5% and the team at
    most 10%, anything above a cap to the people's Q. team_counted_q is team Q granted, vested and unlocked (D15)."""
    for v, n in ((payout_usd, 'payout'), (people_q, "people's Q held"), (founder_unlocked_q, "the Founder's unlocked Q"),
                 (team_counted_q, 'team Q that counts')):
        need(v, n)
        check(v >= 0, f'{n} is never negative')
    check(founder_unlocked_q <= ALLOC['founder'] and team_counted_q <= ALLOC['team'] and people_q <= PEOPLE, 'Q bounds')
    qc = people_q + founder_unlocked_q + team_counted_q
    check(qc > 0, 'no Q counts on this record date')
    d = F(payout_usd)
    founder = min(d * F(founder_unlocked_q, qc), P('founder_cap') * d)
    team = min(d * F(team_counted_q, qc), P('team_cap') * d)
    people = d - founder - team
    check(people >= F(85, 100) * d, 'the people get at least 85% of every payout')
    if people_q:
        per_people_q = people / people_q
        check(founder_unlocked_q == 0 or per_people_q >= founder / founder_unlocked_q, "a people's Q is never paid less than the Founder's")
        check(team_counted_q == 0 or per_people_q >= team / team_counted_q, "a people's Q is never paid less than the team's")
    return dict(payout=float(d), people=float(people), founder=float(founder), team=float(team),
                people_share=float(people / d) if d else None, founder_share=float(founder / d) if d else None,
                team_share=float(team / d) if d else None, per_people_q=float(people / people_q) if people_q else None)


def payout_schedule(quarters):
    """D23: each payout is at least 50% of distributable profit: audited profit since the last payout, after earlier
    losses are recovered and 6 months of operating costs are kept in reserve, measured before non-cash Q pay. The whole
    distributable amount is used each time: the payout, then THE QUIT WINDOW and growth (WHITE-PAPER 4.3)."""
    share, months = P('payout_share_floor'), P('payout_reserve_months')
    carried, rows = F(0), []
    for i, q in enumerate(quarters):
        profit, cost_m, cash = req(q, ('profit_before_q_pay', 'monthly_operating_cost', 'cash_before_payout'),
                                   f'quarter {i + 1}')
        check(cost_m >= 0, 'operating cost is never negative')
        carried += profit
        base = max(F(0), min(carried, F(cash) - months * F(cost_m)))
        carried -= base
        rows.append(dict(quarter=i + 1, profit_before_q_pay=profit, reserve=months * cost_m, distributable=float(base),
                         payout=float(share * base), carried_after=float(carried),
                         payout_as_mp_d9_was_written=float(share * max(0, profit))))
    return rows


rich = 10_000_000
volatile = payout_schedule([dict(profit_before_q_pay=p, monthly_operating_cost=100_000, cash_before_payout=rich)
                            for p in (-400_000, 400_000, -400_000, 400_000)])
check(sum(r['payout'] for r in volatile) == 0, 'D23: losses are recovered before anything is paid')
check(sum(r['payout_as_mp_d9_was_written'] for r in volatile) == 400_000, 'the audit A06 case as MP-D9 was written')
recovered = payout_schedule([dict(profit_before_q_pay=p, monthly_operating_cost=100_000, cash_before_payout=rich)
                             for p in (-300_000, 200_000, 500_000)])
check([r['payout'] for r in recovered] == [0, 0, 200_000], 'D23: pays on the profit left after earlier losses')
reserved = payout_schedule([dict(profit_before_q_pay=1_000_000, monthly_operating_cost=200_000,
                                 cash_before_payout=1_500_000)])
check(reserved[0]['distributable'] == 300_000 and reserved[0]['carried_after'] == 700_000, 'D23: the reserve comes first')
first_unlock = dict(people_q=460_000_000, founder_unlocked_q=ALLOC['founder'] // 4, team_counted_q=ALLOC['team'] // 4)
payout_cases = {
    'before the first unlock': payout_split(500_000, 300_000_000, 0, 0),
    'first unlock at 100,000, all team Q granted': payout_split(500_000, **first_unlock),
    'first unlock, half the team Q granted': payout_split(500_000, 460_000_000, ALLOC['founder'] // 4, ALLOC['team'] // 8),
    'first unlock, no team Q granted': payout_split(500_000, 460_000_000, ALLOC['founder'] // 4, 0),
    'full issuance': payout_split(500_000, PEOPLE, ALLOC['founder'], ALLOC['team'])}
c = payout_cases['first unlock at 100,000, all team Q granted']
check((c['people'], c['founder'], c['team']) == (425_000, 25_000, 50_000), 'per $1M of profit: 425,000 / 25,000 / 50,000')
check(payout_cases['before the first unlock']['people_share'] == 1, 'before the first unlock the people get it all')
c = payout_cases['full issuance']
check((c['people_share'], c['founder_share'], c['team_share']) == (0.85, 0.05, 0.10), 'full issuance pays 85/5/10')
for name, c in payout_cases.items():
    check(c['people_share'] >= 0.85 and c['founder_share'] <= 0.05 and c['team_share'] <= 0.10, name)


# ---- D24 and D25: the Q reference price and THE QUIT WINDOW (A07) ----------------------------------------------------
def reference_price(last_round_price, audited_revenue_12m):
    """D24: one published price a quarter, the lower of the last round's price and 10 times audited revenue over the
    last 12 months divided by 3,000,000,000. Both inputs are required."""
    need(last_round_price, "the last round's price"); need(audited_revenue_12m, 'audited revenue, last 12 months')
    check(last_round_price > 0 and audited_revenue_12m >= 0, 'reference price inputs')
    return min(F(last_round_price), P('reference_multiple') * F(audited_revenue_12m) / N)


def q_price_now(open_round_price, reference):
    """D24: the shop, cash back and statements use the open round's price, or the reference price when none is open."""
    if open_round_price is not None:
        return F(open_round_price)
    return F(need(reference, 'the Q reference price (no round is open, D24)'))


def window(profit_not_paid_out, window_share, price, reference, offers):
    """D25: THE QUIT WINDOW for one quarter. Its budget is the share THE BOARD sets of the profit not paid out, at most
    half. It buys at or below the reference price. Offers fill pro rata, each capped at 2% of the quarter's cap. Bought
    Q can be offered after 12 months, earned Q after 6 months READY, and only after the identity check."""
    need(profit_not_paid_out, 'profit not paid out'); need(window_share, "the Window's share"); need(price, 'price')
    need(reference, 'the Q reference price')
    check(0 <= window_share <= P('window_max_share_of_unpaid_profit'), 'D25: at most half of the profit not paid out')
    check(0 < price <= reference, 'D25: the Window buys at or below the reference price')
    check(P('window_open_business_days') >= 20, 'open at least 20 business days')
    if profit_not_paid_out <= 0:
        return dict(state='CLOSED', budget=0, q_bought=0, cash_paid=0)
    budget = F(window_share) * F(profit_not_paid_out)
    cap_q = budget / F(price)
    acct_cap = P('window_account_cap_share') * cap_q
    rows = []
    for i, o in enumerate(offers):
        q, kind, months, idc, count = req(o, ('q', 'kind', 'months', 'id_checked', 'count'), f'Window offer {i + 1}')
        check(kind in ('bought', 'earned'), f'Window offer {i + 1}: kind is bought or earned')
        wait = P('window_bought_months') if kind == 'bought' else P('window_earned_ready_months')
        rows.append(dict(o, eligible_q=min(F(q), acct_cap) if (idc and months >= wait) else F(0)))
    total = sum((r['eligible_q'] * r['count'] for r in rows), F(0))
    ratio = min(F(1), cap_q / total) if total else F(0)
    for r in rows:
        r['filled_q'] = r['eligible_q'] * ratio
        check(r['filled_q'] <= acct_cap, 'no account fills above its cap')
    bought = sum((r['filled_q'] * r['count'] for r in rows), F(0))
    cash = bought * F(price)
    check(bought <= cap_q and cash <= budget, "the Window never spends more than its budget")
    return dict(state='OPEN', budget=float(budget), price=float(price), cap_q=float(cap_q), account_cap_q=float(acct_cap),
                eligible_q=float(total), fill_ratio=float(ratio), q_bought=float(bought), cash_paid=float(cash),
                offers=[dict(who=r['who'], count=r['count'], offered_q=r['q'], eligible_q=float(r['eligible_q']),
                             filled_q=float(r['filled_q'])) for r in rows])


we = A('window_example')
ref = reference_price(PRICE[we['last_round']], we['audited_revenue_12m'])
check(ref == min(PRICE[4], F(10 * 2_000_000, N)), 'D24 reference price')
paid_out = P('payout_share_floor') * we['distributable']
window_example = window(we['distributable'] - paid_out, we['window_share'], ref, ref, we['offers'])
window_example.update(reference_price=float(ref), last_round_price=float(PRICE[we['last_round']]),
                      audited_revenue_12m=we['audited_revenue_12m'], distributable=we['distributable'],
                      payout=float(paid_out))
check(window(0, F(1, 2), ref, ref, we['offers'])['state'] == 'CLOSED', 'the Window buys only in a quarter with profit')
for bad in (dict(window_share=F(6, 10), price=ref), dict(window_share=F(1, 2), price=ref * 2)):
    try:
        window(250_000, bad['window_share'], bad['price'], ref, we['offers'])
    except AssertionError:
        pass
    else:
        raise AssertionError(f'the Window accepted {bad}')


# ---- D20: QUIT Card Q back, and THE SHOP's 5% back -----------------------------------------------------------------
def card_q_back(spend, cash_like, interchange_rate, q_back_rate, cap_usd_month, id_checked, q_price):
    """D20: one person's Q back for a month. Paid only from the interchange QUIT receives, at a rate below it, capped
    per verified person per month, cash-like merchants left out. Until a card provider is chosen there is no
    interchange figure, so interchange_rate=None throws."""
    need(spend, 'card spend'); need(cash_like, 'cash-like merchant list')
    need(interchange_rate, 'interchange QUIT receives (no card provider is chosen yet, D20)')
    need(q_back_rate, 'Q back rate'); need(cap_usd_month, 'monthly cap'); need(id_checked, 'identity check')
    need(q_price, 'Q price (open round or reference, D24)')
    check(0 < q_back_rate < interchange_rate, 'D20: the Q back rate is below the interchange QUIT receives')
    eligible = sum((F(v) for k, v in spend.items() if k not in cash_like), F(0))
    interchange = eligible * F(interchange_rate)
    usd = min(eligible * F(q_back_rate), F(cap_usd_month)) if id_checked else F(0)
    check(usd <= interchange, 'D20: Q back is paid only from interchange')
    return dict(eligible_spend=float(eligible), interchange=float(interchange), q_back_usd=float(usd),
                q=float(usd / F(q_price)))


try:
    card_q_back({'groceries': 100}, set(), None, F(1, 200), 10, True, PRICE[1])
except MissingInput:
    pass
else:
    raise AssertionError('card Q back ran without an interchange figure')
ct = A('card_function_test')
card_test = card_q_back(ct['spend'], {'cash_like'}, ct['interchange_rate'], ct['q_back_rate'], ct['cap_usd_month'],
                        True, PRICE[1])
check(card_test['q_back_usd'] == 2.75 and card_test['interchange'] == 5.5, 'card Q back function test')
check(card_q_back(ct['spend'], {'cash_like'}, ct['interchange_rate'], ct['q_back_rate'], ct['cap_usd_month'], False,
                  PRICE[1])['q'] == 0, 'D12 and D20: no Q back before the identity check')


def shop_cash_back(card_paid_usd, q_price):
    """THE SHOP: 5% of every card payment back in Q at the open round's price, or the reference price when no round is
    open (D24). D24 leaves cash-back Q out of a round's sold count; which account the Q is drawn from is not written
    yet (MODEL-CHANGES.md, open question), so this returns the Q owed and books nothing."""
    need(card_paid_usd, 'card payment'); need(q_price, 'Q price')
    return P('shop_cash_back_rate') * F(card_paid_usd) / F(q_price)


check(shop_cash_back(49, q_price_now(PRICE[1], None)) == F(3_675, 4), 'TOKENOMICS-REPORT 12.1: $49 with round 1 open, 918.75 Q')
try:
    q_price_now(None, None)
except MissingInput:
    pass
else:
    raise AssertionError('a Q price with no open round and no reference price was accepted')
cash_back = dict(
    shop_49_round_1_open=float(shop_cash_back(49, q_price_now(PRICE[1], None))),
    shop_49_no_round_open=float(shop_cash_back(49, q_price_now(None, ref))), reference_price_used=float(ref),
    card_q_back=dict(state='no rate until the card provider is chosen (D20)', function_test=card_test,
                     function_test_inputs={k: (float(v) if isinstance(v, F) else v) for k, v in ct.items()}))


# ---- D04 and the contribution margin of each revenue line (A01) ---------------------------------------------------
def wx_job(builder, first_month, related, commission_base):
    """One $150 Work Exchange job, QUIT's net after card fees, AI work, a chargeback reserve and Builder pay. D04 pays
    Builders on QUIT's share of the job. commission_base: 'cut' (QUIT's $30, as JB-1 and MK-2 print $12.00 and $7.50),
    'cut_after_fees' (QUIT's $30 after card fees, D04's words) or 'job_price' (the replaced rule)."""
    price, cut = P('wx_job_price'), P('wx_cut')
    keep = price * cut
    fee = price * A('card_fee_rate') + A('card_fee_fixed')
    base = {'cut': keep, 'cut_after_fees': keep - fee, 'job_price': F(price)}[commission_base]
    direct = P('builder_rate_first_month') if first_month else P('builder_rate_after')
    rate = F(0) if (not builder or related) else min(direct + P('builder_team_levels'), P('builder_cap'))
    field = rate * base
    net = keep - fee - A('wx_ai_cost_per_job') - A('chargeback_reserve_rate') * price - field
    return dict(job=price, quit_keeps=float(keep), card_fee=float(fee), ai=A('wx_ai_cost_per_job'),
                chargeback_reserve=float(A('chargeback_reserve_rate') * price), builder_pay=float(field),
                builder_rate=float(rate), quit_net=float(net), margin_on_kept=float(net / keep))


wx_rows = {
    'direct, no Builder': wx_job(False, False, False, 'cut'),
    "Builder-brought, first month, on QUIT's $30": wx_job(True, True, False, 'cut'),
    "Builder-brought, after, on QUIT's $30": wx_job(True, False, False, 'cut'),
    "Builder-brought, first month, on QUIT's $30 after card fees": wx_job(True, True, False, 'cut_after_fees'),
    "Builder-brought, after, on QUIT's $30 after card fees": wx_job(True, False, False, 'cut_after_fees'),
    'business, pilot and Builder related: no commission': wx_job(True, True, True, 'cut')}
for name, r in wx_rows.items():
    check(r['quit_net'] > 0, f'D04: QUIT keeps money on every Work Exchange job ({name})')
wx_replaced = {'replaced rule, first month, on the job price': wx_job(True, True, False, 'job_price'),
               'replaced rule, after, on the job price': wx_job(True, False, False, 'job_price')}
for name, r in wx_replaced.items():
    check(r['quit_net'] < 0, f'the replaced rule loses money ({name})')
direct_only = {k: float(P(k) * P('wx_job_price') * P('wx_cut')) for k in ('builder_rate_first_month', 'builder_rate_after')}
check(direct_only == {'builder_rate_first_month': 12.0, 'builder_rate_after': 7.5},
      "JB-1 and MK-2: the direct Builder's $12.00 and $7.50 on QUIT's $30")

CS = json.loads((ROOT / 'designs/v5-pages/creator_studio_model_out.json').read_text())
CS_CHANNELS = {'direct, card': 'full', 'direct, half Q': 'halfq', 'Builder-sold, card': 'builder',
               'Builder-sold, half Q': 'builder_halfq'}
CS_APPROVED_LOSSES = {('STARTER', 'Builder-sold, half Q'), ('WEEKLY', 'Builder-sold, half Q')}   # CREATOR-STUDIO-PLANS
                                                                    # 1.2 at full use, approved with the plans (MP-D38, MP-D41)
cs_cells, cs_losses = {}, set()
for plan in A('cs_plan_mix'):
    for ch, key in CS_CHANNELS.items():
        cell = req(req(CS, ('plans',), 'creator_studio_model_out.json')[0], (plan,), 'Creator Studio plans')[0]
        margin, card = req(cell[key], ('margin', 'card'), f'Creator Studio {plan} {key}')
        cs_cells[f'{plan}, {ch}'] = dict(margin=margin, card=card, cash_margin=margin / card)
        if margin < 0:
            cs_losses.add((plan, ch))
check(cs_losses <= CS_APPROVED_LOSSES, f'a Creator Studio cell loses money that the approved plans do not show: '
                                       f'{sorted(cs_losses - CS_APPROVED_LOSSES)}')
bs, hq = A('cs_builder_sold_share'), A('cs_half_q_share')
ch_w = {'direct, card': (1 - bs) * (1 - hq), 'direct, half Q': (1 - bs) * hq, 'Builder-sold, card': bs * (1 - hq),
        'Builder-sold, half Q': bs * hq}
cs_m = sum(float(A('cs_plan_mix')[p] * ch_w[ch]) * cs_cells[f'{p}, {ch}']['margin'] for p in A('cs_plan_mix') for ch in ch_w)
cs_c = sum(float(A('cs_plan_mix')[p] * ch_w[ch]) * cs_cells[f'{p}, {ch}']['card'] for p in A('cs_plan_mix') for ch in ch_w)
go_viral = {}
for k in ('go_viral', 'go_viral_plus'):               # ON LOCATION waits for a signed videographer (MP-D41)
    gm, bm = req(CS[k], ('gm', 'builder_margin'), k)
    check(gm > 0 and bm > 0, f'{k} keeps money direct and Builder-sold')
    go_viral[k] = dict(margin_direct=gm, margin_builder_sold=bm)
wx_bs, wx_fm = A('wx_builder_share'), A('wx_first_month_share')
wx_blend = (float(1 - wx_bs) * wx_rows['direct, no Builder']['margin_on_kept']
            + float(wx_bs * wx_fm) * wx_rows["Builder-brought, first month, on QUIT's $30"]['margin_on_kept']
            + float(wx_bs * (1 - wx_fm)) * wx_rows["Builder-brought, after, on QUIT's $30"]['margin_on_kept'])


def line_margin(price, cost_to_serve, card_fee, q_back, field_pay):
    """Contribution of one sale of a revenue line. Every input is required; THE ACADEMY and data licences have no
    price or cost in the plan yet, so they cannot be computed and are not counted."""
    for v, n in ((price, 'price'), (cost_to_serve, 'cost to serve'), (card_fee, 'card fee'), (q_back, 'Q back'),
                 (field_pay, 'field pay')):
        need(v, n)
    return price - cost_to_serve - card_fee - q_back - field_pay


try:
    line_margin(None, None, None, None, None)
except MissingInput:
    pass
else:
    raise AssertionError('a revenue line without inputs was computed')
margins = {
    'creator_studio': dict(cells=cs_cells, approved_losses=sorted(f'{p}, {c}' for p, c in CS_APPROVED_LOSSES),
                           blended_margin_a_month=cs_m, blended_cash=cs_c, blended_cash_margin=cs_m / cs_c,
                           go_viral=go_viral),
    'work_exchange': dict(jobs=wx_rows, replaced_rule=wx_replaced, blended_margin_on_kept=wx_blend,
                          direct_builder_pay_on_quit_cut=direct_only),
    'academy': dict(state='no price or cost in the plan; not counted in the cash plan'),
    'data_licences': dict(state="the dividend share is set before the first outside licence (WHITE-PAPER 3.5); "
                                "not counted in the cash plan")}
check(margins['creator_studio']['blended_cash_margin'] > 0 and wx_blend > 0, 'every costed revenue line keeps money')
check(sum(A('revenue_mix').values()) == 1, 'the revenue mix adds to 100%')
CM_BLEND = (float(A('revenue_mix')['creator_studio']) * margins['creator_studio']['blended_cash_margin']
            + float(A('revenue_mix')['work_exchange']) * wx_blend)
margins['blended_contribution_margin'] = CM_BLEND


# ---- A12 and D08: the whole stage 1 population, not one mix --------------------------------------------------------
def largest_remainder(weights, total):
    s = sum(weights.values())
    raw = {k: F(v * total, s) for k, v in weights.items()}
    out_ = {k: int(x) for k, x in raw.items()}
    for k in sorted(raw, key=lambda k: (-(raw[k] - out_[k]), k))[:total - sum(out_.values())]:
        out_[k] += 1
    return out_


def population_check(spread, stage=0):
    """Pay per action is Q left over actions expected, so a pot is never overdrawn: when the stage population asks for
    more than a pot holds, every action in that pot pays less. Members brought can never exceed the stage's members.
    Returns the pay as a share of the example rates, per pot, and the expected Q per path and per active member."""
    st = stages[stage]
    members = st['members_to'] - st['members_from']
    pot_q = {p: st['q'] * s for p, s in POTS.items()}
    earners = sum(spread.values())
    check(0 < earners <= members, 'the spread fits inside the stage')
    brought = sum(PATHS[w].get('active_member_brought', 0) * n for w, n in spread.items())
    bring = min(F(1), F(members, brought)) if brought else F(1)
    demand = {p: F(0) for p in POTS}
    for w, n in spread.items():
        for a, k in PATHS[w].items():
            scale = bring if a == 'active_member_brought' else 1
            demand[POT_OF[a]] += RATES[a] * k * n * scale
            if a == 'active_member_brought':
                demand['invites_and_creators'] += NEWCOMER * k * n * scale
    pay = {p: (min(F(1), pot_q[p] / demand[p]) if demand[p] else F(1)) for p in POTS}
    for p in POTS:
        check(demand[p] * pay[p] <= pot_q[p], f'{p} is never overdrawn')
    per_path = {}
    for w, n in spread.items():
        q = sum(RATES[a] * k * (bring if a == 'active_member_brought' else 1) * pay[POT_OF[a]]
                for a, k in PATHS[w].items())
        per_path[w] = dict(people=n, q_at_example_rates=sum(RATES[a] * k for a, k in PATHS[w].items()), q_expected=float(q))
    paid = sum(F(v['q_expected']) * v['people'] for v in per_path.values())
    return dict(earners=earners, participation=float(F(earners, members)), members_brought=float(brought * bring),
                pay_share_of_example={p: float(v) for p, v in pay.items() if demand[p]}, paths=per_path,
                expected_q_per_active_member=float(paid / earners))


population = {}
for name, spec in A('participation_spreads').items():
    spread = MIX if spec == 'MIX' else (largest_remainder(MIX, spec) if isinstance(spec, int) else spec)
    population[name] = population_check(spread)
check(all(v == 1 for v in population['the example mix']['pay_share_of_example'].values()),
      'the example mix is paid in full, as the example-mix check says')
check(abs(population['10% work like the student']['pay_share_of_example']['job_board'] - 36 / 115) < 1e-12,
      'audit A12: 10% working like the student cut task pay to 31% of the example')
check(abs(population['50% work like the student']['pay_share_of_example']['job_board'] - 36 / 575) < 1e-12,
      'audit A12: 50% cut it to 6.3%')


# ---- D13 and D12: the people's dividend split by checked work, capped, after the identity check (A04) --------------
def dividend_split(dividend_usd, groups):
    """D13: weight = Q earned through checked work times days held, days counted from the first checked job. Only
    identity-checked real members on the record date count (D12). Each weight is capped at 5 times the median weight,
    so no one is paid more than 5 times the median. groups: records with a count of identical accounts."""
    need(dividend_usd, 'dividend')
    rows = []
    for i, g in enumerate(groups):
        count, idc, real, qd = req(g, ('count', 'id_checked', 'real_on_record_date', 'checked_work_q_days'),
                                   f'dividend group {i + 1}')
        check(count >= 0 and qd >= 0, f'dividend group {i + 1}')
        rows.append(dict(g, weight=F(qd) if (idc and real and qd > 0) else F(0)))
    elig = sorted((r for r in rows if r['weight'] > 0), key=lambda r: r['weight'])
    n = sum(r['count'] for r in elig)
    check(n > 0, 'nobody qualifies for the dividend')
    half, seen, median = F(n + 1, 2), 0, None                     # median over accounts, not groups
    for r in elig:
        seen += r['count']
        if seen >= half:
            median = r['weight']
            break
    cap = P('dividend_cap_x_median') * median
    total_w = sum((min(r['weight'], cap) * r['count'] for r in rows), F(0))
    for r in rows:
        r['per_account'] = F(dividend_usd) * min(r['weight'], cap) / total_w
    paid = sum((r['per_account'] * r['count'] for r in rows), F(0))
    check(abs(paid - F(dividend_usd)) < F(1, 10 ** 6), 'the dividend is paid in full, no more')
    median_pay = F(dividend_usd) * median / total_w
    check(all(r['per_account'] <= P('dividend_cap_x_median') * median_pay for r in rows), 'D13: at most 5x the median')
    return dict(dividend=float(dividend_usd), eligible_accounts=n, median_weight=float(median),
                median_pay=float(median_pay),
                groups=[dict(group=r.get('group', ''), count=r['count'], per_account=float(r['per_account']),
                             total=float(r['per_account'] * r['count'])) for r in rows])


ex_sale = sale(A('dividend_example_sale_price'), 460_000_000, team_q_vested=ALLOC['team'])
dividend_example = dividend_split(ex_sale['dividend'], A('dividend_example_population'))
dividend_example['sale_price'] = A('dividend_example_sale_price')
for gr in dividend_example['groups']:
    if 'no checked work' in gr['group'] or 'no identity check' in gr['group']:
        check(gr['total'] == 0, f"A04: {gr['group']} receive $0")


# ---- A10 and D15: the sale with team grants at 0%, 50% and 100% of the pool ----------------------------------------
sale_cases = []
for price in (60_000_000, 3_000_000_000):
    for grants in (F(0), F(1, 2), F(1)):
        for issued in (0, 460_000_000, PEOPLE):
            s = sale(price, issued, team_q_vested=int(ALLOC['team'] * grants))
            check(s['people_share'] >= 0.85 - 1e-12 and s['founder_share'] <= 0.05 + 1e-12, 'A10: people >= 85%, Founder <= 5%')
            sale_cases.append(dict(price=price, team_granted_share=float(grants), people_q_issued=issued,
                                   people_share=s['people_share'], founder_share=s['founder_share'],
                                   team_share=s['team_share'], dividend=s['dividend']))


# ---- D22: a dated cash plan with a hard monthly cost cap (A05) ------------------------------------------------------
MONTH_NAMES = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']


def month_label(i):
    y, m = A('cash_plan_start')
    k = (m - 1) + (i - 1)
    return f'{MONTH_NAMES[k % 12]} {y + k // 12}'


def members_at(path, i):
    q, pos = (i - 1) // 3, (i - 1) % 3 + 1
    check(q < len(path), 'the member path is shorter than the cash plan')
    prev = 0 if q == 0 else path[q - 1]
    return prev + (path[q] - prev) * F(pos, 3)


def cash_plan(case, extra_start_cash=0):
    """Month by month from the cash plan start: rounds 1 to 4 sell at the case's pace; a gated round sells only while
    D26 reads OPEN on the audited quarters; contribution is revenue x the blended margin less variable costs; fixed
    costs are cut to the hard monthly cap (D22); payouts follow D23 and the Window takes the most D25 allows. Cash
    below zero throws."""
    c = A('cash_cases')[case]
    path, arpu, pace = A('member_paths')[c['path']], c['revenue_per_member'], c['rounds_1_4_months']
    runway, fixed, var = A('cost_cap_runway_months'), A('fixed_cost_month'), A('variable_cost_member_year')
    lag, refund, flag = A('audit_lag_quarters'), A('refund_rate'), A('flagged_revenue_rate')
    cm = F(CM_BLEND).limit_denominator(10 ** 9)
    sold = {k: F(0) for k in range(1, ROUNDS + 1)}
    start_reserve = A('starting_operating_reserve_usd')
    cash, carried, used_audits, rows, quarters = F(extra_start_cash) + start_reserve, F(0), 0, [], []
    acc = dict(revenue=F(0), refunds=F(0), flagged_revenue=F(0), profit=F(0), costs=F(0))
    opened = {}
    for i in range(1, A('cash_plan_months') + 1):
        members = members_at(path, i)
        gross = members * arpu / 12
        refunds, flagged = gross * refund, gross * flag
        margin = (gross - refunds) * cm
        variable = members * F(var, 12)
        round_cash, to_sell = F(0), (F(4 * PER_ROUND, pace) if i <= pace else F(0))
        for k in range(1, 5):
            take = min(to_sell, PER_ROUND - sold[k])
            sold[k] += take
            to_sell -= take
            round_cash += take * PRICE[k]
        audited = quarters[:max(0, len(quarters) - lag)]
        for k in range(5, ROUNDS + 1):
            if sold[k] < PER_ROUND:
                if all(sold[j] == PER_ROUND for j in range(1, k)) and audited and gate_states(k, audited)[-1] == 'OPEN':
                    take = min(F(PER_ROUND, A('gated_round_months')), PER_ROUND - sold[k])
                    sold[k] += take
                    round_cash += take * PRICE[k]
                    opened.setdefault(k, month_label(i))
                break
        cap = (cash + round_cash) / runway + max(F(0), margin)
        fixed_spend = max(F(0), min(F(fixed), cap - variable))
        check(variable + fixed_spend <= cap or fixed_spend == 0, 'D22: costs stay inside the monthly cap')
        cash += round_cash + margin - variable - fixed_spend
        acc['revenue'] += gross; acc['refunds'] += refunds; acc['flagged_revenue'] += flagged
        acc['profit'] += margin - variable - fixed_spend; acc['costs'] += variable + fixed_spend
        payout = window_paid = F(0)
        if i % 3 == 0:
            quarters.append(acc)
            acc = dict(revenue=F(0), refunds=F(0), flagged_revenue=F(0), profit=F(0), costs=F(0))
            ready = max(0, len(quarters) - lag)
            while used_audits < ready:
                carried += quarters[used_audits]['profit']
                used_audits += 1
            reserve = P('payout_reserve_months') * quarters[-1]['costs'] / 3
            base = max(F(0), min(carried, cash - reserve))
            carried -= base
            payout = P('payout_share_floor') * base
            window_paid = A('cash_plan_window_share') * (base - payout)
            check(window_paid <= P('window_max_share_of_unpaid_profit') * (base - payout), 'D25 budget')
            cash -= payout + window_paid
        check(cash >= 0, f'cash plan {case}: cash runs out in {month_label(i)}')
        rows.append(dict(month=month_label(i), members=float(members), revenue=float(gross - refunds),
                         round_cash=float(round_cash), spend=float(variable + fixed_spend), cap=float(cap),
                         cut=float(F(fixed) - fixed_spend), payout=float(payout), window=float(window_paid),
                         cash=float(cash)))
    check(all(0 <= sold[k] <= PER_ROUND for k in sold), f'no round sells more than its {PER_ROUND:,} Q')
    return rows, sold, opened


cash_plans = {}
for case in A('cash_cases'):
    rows, sold, opened = cash_plan(case)
    cut_months = [r['month'] for r in rows if r['cut'] > 0.005]
    lo, hi = 0.0, 100_000_000.0
    check(not any(r['cut'] > 0.005 for r in cash_plan(case, hi)[0]), f'cash plan {case}: the bridge search bound')
    for _ in range(50):                                      # the cash up front that runs planned costs uncut
        mid = (lo + hi) / 2
        if any(r['cut'] > 0.005 for r in cash_plan(case, mid)[0]):
            lo = mid
        else:
            hi = mid
    bridge = hi
    unsold_at_start = ALLOC['rounds'] - FOUNDING_RESERVE_Q   # the ten public rounds' Q
    cash_plans[case] = dict(
        inputs=A('cash_cases')[case], start=rows[0]['month'], end=rows[-1]['month'], rows=rows,
        round_q_sold={str(k): float(v) for k, v in sold.items() if v}, gated_rounds_opened=opened,
        round_cash=sum(r['round_cash'] for r in rows), months_cap_cuts_costs=len(cut_months),
        first_month_uncut=next((r['month'] for r in rows if r['cut'] <= 0.005), None),
        total_cuts=sum(r['cut'] for r in rows), payouts=sum(r['payout'] for r in rows),
        window=sum(r['window'] for r in rows), lowest_cash=min(r['cash'] for r in rows), end_cash=rows[-1]['cash'],
        first_payout=next((r['month'] for r in rows if r['payout'] > 0), None),
        bridge_to_run_planned_costs=bridge,
        bridge_q_at_round_1_price=bridge / float(PRICE[1]), bridge_q_at_round_4_price=bridge / float(PRICE[4]),
        bridge_fits_at_round_1_price=bridge / float(PRICE[1]) <= unsold_at_start,
        bridge_fits_at_round_4_price=bridge / float(PRICE[4]) <= (ROUNDS - 4) * PER_ROUND)



# ---- Public Ecosystem, Launchpad Fee & On-Chain $QUIT Supply Sink Invariants ----
lp_fee = P('launchpad_swap_fee')
check(sum(lp_fee.values()) == F(150, 10000), 'MP-D123 / MP-D134: launchpad swap fee sums to 1.50%')
check(lp_fee['creator'] + lp_fee['inviter'] + lp_fee['level_2'] + lp_fee['level_3'] == F(105, 10000),
      'Creator + 3-level invite shares sum to 1.05% (70% of the 1.50% swap fee)')

invite_q_per_friend = RATES['active_member_brought'] + NEWCOMER
check(invite_q_per_friend == 240, 'MP-D55: 160 Q inviter + 80 Q newcomer = 240 Q')
check(30_000 * invite_q_per_friend == 7_200_000 <= F(stage1) * POTS['invites_and_creators'],
      '30,000 verified Stage 1 invites (7,200,000 Q) fit cleanly inside Stage 1 invites_and_creators pot (24,000,000 Q)')

sinks = A('quit_onchain_sinks')
check(sinks['burned_quit'] + sinks['live_supply_quit'] == 1_000_000_000,
      'Verifiable burned $QUIT (62,099,349) + live $QUIT supply (937,900,651) equals 1,000,000,000 launch supply')
check(F(sinks['locked_quit'], sinks['live_supply_quit']) > F(11, 100),
      '105,948,500 $QUIT locked across 12 Jupiter Lock PDAs exceeds 11% of live supply')

if __name__ == '__main__':
    print('all public invariants hold')
    print(f'Supply: {N:,} Q | People share: {PEOPLE / N:.0%} | Public rounds raise up to: ${float(raised):,.0f}')
    print(f'Blended contribution margin: {CM_BLEND:.1%} (Work Exchange {wx_blend:.1%}, Creator Studio {margins["creator_studio"]["blended_cash_margin"]:.1%})')