#!/usr/bin/env python3
"""Create and execute the higher-deficit, rigidity, and budget demonstration."""
from __future__ import annotations
import json
import time
from pathlib import Path
import nbformat as nbf
from nbclient import NotebookClient

ROOT = Path(__file__).resolve().parents[1]


def main() -> None:
    nb = nbf.v4.new_notebook()
    nb.metadata.kernelspec = {'display_name':'Python 3', 'language':'python', 'name':'python3'}
    md, code = nbf.v4.new_markdown_cell, nbf.v4.new_code_cell
    nb.cells = [
        md('# AELYRION–NOÛLITH III: higher-deficit geometry and rigidity\n\nExecuted exact examples accompanying the written all-size proofs. The classified object is the **reduced** scalar resonance germ. No scheme-radicality, physical performance, external review, or worldwide-priority claim is inferred from these computations.'),
        code('''from pathlib import Path
import sys
from math import comb, ceil
import sympy as sp
root = Path.cwd()
if not (root / 'src').exists():
    root = root.parent
assert (root / 'src' / 'noulith').exists(), 'Run from the package or notebooks directory.'
sys.path.insert(0, str(root / 'src'))
from noulith.algebra import TwistedAlgebra
from noulith.third import (
    all_components, component_equations, component_membership, intersection_dimension,
    example_point, certify_scalar, direct_block_rank, predicted_rank,
    optimal_calibration_subfamily, calibration_classes, pairs, q_from_exponents,
)
sp.init_printing()
print('Exact reference library loaded from', root / 'src')'''),
        md('## 1. The 41-component six-channel arrangement\n\nSix stars have dimension five. Twenty triangles and fifteen twin-core components have dimension three. Only the reduced geometry is classified.'),
        code('''m = 6
components = all_components(m)
counts = {kind: sum(c[0] == kind for c in components)
          for kind in ('star', 'triangle', 'twin')}
assert counts == {'star': 6, 'triangle': 20, 'twin': 15}
assert len(components) == m + comb(m+1, 3) == 41
dimensions = {kind: comb(m,2) - component_equations(m, next(c for c in components if c[0] == kind)).rank()
              for kind in counts}
{'counts': counts, 'component_dimensions': dimensions, 'ambient_dimension': comb(m,2)}'''),
        md('## 2. Full-state ranks by an independent calculation\n\nThe rank computation below enumerates all complementary subsets and block possibilities, independently of membership in the geometric components. Scalar resonance is not the whole rank-failure locus.'),
        code('''kinds = ['origin','star','triangle','twin','uniform_star','star_twin','edge','double_star','generic']
ranks = {}
for kind in kinds:
    q = example_point(m, kind)
    direct = direct_block_rank(m, q, m-3)
    assert direct == predicted_rank(m, q)
    ranks[kind] = {'rank': direct, 'nullity': 2**m-direct}
assert ranks['twin']['rank'] == 60 and ranks['origin']['rank'] == 42
ranks'''),
        md('## 3. A returned witness is an actual nonzero algebra word\n\nThe certificate contains a nontrivial motif and singleton completion. Raw multiplication keeps the nonzero crossing factor rather than silently dropping it.'),
        code('''q = example_point(6, 'generic')
certificate = certify_scalar(6, q)
assert certificate.visible
model = TwistedAlgebra(6, q)
partition = certificate.full_partition(6)
raw = model.isolated_response(partition)
unit = model.isolated_unit(partition)
assert len(partition) == 3
assert raw == unit * certificate.normalized_response != 0
{'motif': certificate.motif, 'full_partition_bitmasks': partition,
 'raw_equals_unit_times_normalized': True, 'raw_response_nonzero': raw != 0}'''),
        md('## 4. Component incidence and the old elliptic locus\n\nTwo twins sharing an outlier meet in a uniform-star line. Disjoint outlier pairs meet only at the origin. The union of the uniform-star lines is the known elliptic m-fold point, not a new singularity claim.'),
        code('''checks = {
    'two_stars': ([('star',(0,)), ('star',(1,))], 1),
    'star_and_its_twin': ([('star',(0,)), ('twin',(0,1))], 2),
    'twins_sharing_an_outlier': ([('twin',(0,1)), ('twin',(0,2))], 1),
    'disjoint_twins': ([('twin',(0,1)), ('twin',(2,3))], 0),
}
results = {}
for name, (labels, expected) in checks.items():
    value = intersection_dimension(6, labels)
    assert value == expected
    results[name] = value
results'''),
        md('## 5. Sharp selected-component synchronization\n\nThis is a count of constraints requiring preservation of entire twin subspaces, **not** the number of scalar detector measurements. The construction uses four components for six channels. A star of five selected components nevertheless fails.'),
        code('''selected = optimal_calibration_subfamily(6)
assert len(selected) == ceil(2*(6-1)/3) == 4
assert len(calibration_classes(6, selected)) == 1
selected_star = tuple((0,j) for j in range(1,6))
assert len(calibration_classes(6, selected_star)) == 2
{
 'optimal_selected_pairs_zero_based': selected,
 'optimal_remaining_scale_classes': len(calibration_classes(6, selected)),
 'five_star_constraints_remaining_classes': len(calibration_classes(6, selected_star)),
 'budgets_m6_to_m12': {n: len(optimal_calibration_subfamily(n)) for n in range(6,13)},
}'''),
        md('## 6. Identical-interaction core capacity at different block budgets\n\nThe equality is generic within the core family, not asserted at every parameter value. The formula requires at least one block.'),
        code('''m, c = 6, 4
exponents = [[0]*m for _ in range(m)]
for i,j in pairs(m):
    if not (i < c and j < c):
        exponents[i][j], exponents[j][i] = 1, -1
q = q_from_exponents(exponents)
capacity = {}
for r in range(1,5):
    expected = 2**(m-c) * sum(comb(c,j) for j in range(min(c,r)+1))
    actual = direct_block_rank(m, q, r)
    assert actual == expected
    capacity[r] = actual
capacity'''),
        md('## 7. Why the classification starts at six channels\n\nA dense five-channel rational point can have every shuffle of degree at least three vanish. It is outside the listed star/triangle/twin support types but is invisible with two blocks.'),
        code('''m = 5
h = [sp.Rational(i,1000) for i in range(m)]
q = {(i,j): -1 + (h[j]-h[i])/(1-h[i]+h[i]*h[j]) for i,j in pairs(m)}
P = TwistedAlgebra(m,q).shuffle_table()
assert all(q[e] != -1 for e in pairs(m))
assert all(P[S] == 0 for S in range(1,1<<m) if S.bit_count() >= 3)
{'supported_edges': len(q), 'all_degree_at_least_three_shuffles_zero': True,
 'two_block_full_state_rank': direct_block_rank(m,q,2)}'''),
        md('## Interpretation\n\nThe all-size classification and rigidity rely on the written proofs. These finite exact examples test independent mechanisms and boundary cases. The minimal synchronization count concerns a specified geometric constraint model; it is not a claim that a physical instrument can learn its entire calibration from four samples. See the manuscript and `docs/NOVELTY_AUDIT.md` for antecedents and open priority questions.'),
    ]
    start = time.perf_counter()
    NotebookClient(nb, timeout=120, kernel_name='python3',
                   resources={'metadata': {'path': str(ROOT)}}).execute()
    path = ROOT / 'notebooks' / '02_third_deficit_and_rigidity.ipynb'
    nbf.write(nb, path)
    code_cells = [cell for cell in nb.cells if cell.cell_type == 'code']
    errors = [out for cell in code_cells for out in cell.get('outputs', [])
              if out.get('output_type') == 'error']
    report = {'notebook': str(path.relative_to(ROOT)), 'executed_code_cells': len(code_cells),
              'errors': len(errors), 'elapsed_seconds': round(time.perf_counter()-start,3)}
    (ROOT / 'validation' / 'notebook_v3_report.json').write_text(json.dumps(report,indent=2)+'\n')
    if errors:
        raise SystemExit('Notebook execution reported errors.')
    print(f'Executed {len(code_cells)} higher-deficit notebook code cells without errors.')

if __name__ == '__main__':
    main()