diff --git a/research/prescribed-triple-decoder/AUDIT.json b/research/prescribed-triple-decoder/AUDIT.json new file mode 100644 index 0000000000..1fba0b93bf --- /dev/null +++ b/research/prescribed-triple-decoder/AUDIT.json @@ -0,0 +1,72 @@ +{ + "cases": [ + { + "group_elements": 8, + "labelled_target_triples": 4, + "orbits": 1, + "p": 2, + "ports": 4, + "retained_decoder_equations": 9 + }, + { + "group_elements": 48, + "labelled_target_triples": 220, + "orbits": 9, + "p": 3, + "ports": 12, + "retained_decoder_equations": 141 + }, + { + "group_elements": 384, + "labelled_target_triples": 2024, + "orbits": 16, + "p": 4, + "ports": 24, + "retained_decoder_equations": 537 + }, + { + "group_elements": 3840, + "labelled_target_triples": 9880, + "orbits": 18, + "p": 5, + "ports": 40, + "retained_decoder_equations": 1119 + }, + { + "group_elements": 46080, + "labelled_target_triples": 34220, + "orbits": 19, + "p": 6, + "ports": 60, + "retained_decoder_equations": 1941 + } + ], + "format": "pr966-targetwise-independent-audit-v1", + "independent_rref": [ + { + "p": 3, + "subspaces": 155, + "target_triples": 220 + }, + { + "p": 4, + "subspaces": 11811, + "target_triples": 2024 + } + ], + "negative_controls": [ + "source_sha256", + "zero_decoder", + "wrong_target_decoder", + "delete_target", + "nonport", + "duplicate_deletion", + "surviving_inventory", + "collapse_partition", + "port_inventory", + "histogram_preserving_target_swap_p3", + "histogram_preserving_target_swap_p4" + ], + "source_commit": "7eaf5665ac246310293fda06a3cf245fe72f6012", + "source_sha256": "ab75a0a3506f66053ad0b7f693738e45db06ff9befdeed4484b9dffaa7f687dc" +} diff --git a/research/prescribed-triple-decoder/README.md b/research/prescribed-triple-decoder/README.md new file mode 100644 index 0000000000..5ad1242df1 --- /dev/null +++ b/research/prescribed-triple-decoder/README.md @@ -0,0 +1,119 @@ +# Independent targetwise audit of PR #966 + +**Independent verification; no new kappa.** This package audits the exact +prescribed-triple certificate from [PR #966](https://github.com/CrocSwap/integer-mult-bounds/pull/966) +at `7eaf5665ac246310293fda06a3cf245fe72f6012`. It checks the identity of +every labelled target in the independent comparison, rather than comparing +only cost histograms. It also verifies the certificate's orbit multiplicities +by explicitly applying the matching automorphism group, without importing +the predecessor's first-occurrence canonicalization or verifier. + +The result is a positive audit of a concurrent contribution. PR #966 +published the same deletion theorem while this sprint was running, with +broader finite coverage than our initial experiment. We therefore changed +the deliverable to this independent certificate audit and credit that work. +The new evidence is a targetwise cross-check, an independent group-action +inventory and literal witness checks, with a histogram-preserving adverse +control. No new deletion theorem is claimed here. + +## Reproduce + +Python 3.9 or later, standard library only. From the repository root: + +```sh +python3 -I research/prescribed-triple-decoder/audit.py +``` + +Expected final line: + +```text +PASS PR966 targetwise audit: 46348 triples; 63 orbits; 59 witnesses; 2244 targetwise minima; 11 controls +``` + +The audit checks the committed [receipt](AUDIT.json) and all **46,348** labelled +target triples represented by the certificate at `p=2,...,6`, all **63** +matching orbits, and all **59** feasible orbit witnesses. At `p=3,4`, it +compares each of **2,244** labelled target budgets against **11,966** +independently enumerated rank-three cut-code subspaces. Run with `-O` +after `-I` to check optimized-mode failure detection. The replay is offline +and leaves the checkout unchanged. `--write` explicitly regenerates only +this package's deterministic audit receipt. + +## What is checked + +The port graph is `K_(2p)` with the `p` original matched edges removed. +For every certificate representative, `audit.py` explicitly permutes the +original pairs and flips their signs. The resulting set of labelled target +triples must have exactly the recorded multiplicity. Different orbit sets +must be disjoint and their union must equal all three-edge target sets. +This independently checks the geometric inventory instead of trusting +the predecessor's canonical keys or histogram totals. + +For every feasible orbit, the audit checks deletion membership, uniqueness, +count and target exclusion. It evaluates each published decoder vertex set +as a literal symmetric difference of incidence-star supports; after removing +deleted coordinates its support must be exactly the corresponding retained +target singleton. Every retained non-target input stays unrestricted. + +`independent_check.py` imports no predecessor or audit implementation. It +enumerates all RREF rank-three subspaces of the full binary cut code at +`p=3,4`, fixing the final vertex coefficient to zero to remove the constant +kernel. It computes an exact minimum for every labelled target triple, +including spaces with five through eight distinct vertex labels. The audit +compares each target individually to the expanded PR #966 certificate. + +The published PR #966 replay at this pin compares deletion histograms +between its partition and independent engines. A histogram alone does not +identify which target receives which budget. Our adverse control exchanges +an ordinary and exceptional target's budgets, preserving the histogram, +and requires the targetwise comparison to reject the exchange. This is a +test of the additional comparison's failure detection, not a reported +counterexample to PR #966's theorem or its own primary checks. + +At `p=2,5,6`, this audit verifies inventory and attaining witnesses. It does +not independently enumerate every cut subspace there. The unrestricted +optimality claim for those parameters remains with PR #966's written proof +and its own independent checks. This finite audit is not a formal proof of +the general deletion theorem or of integer multiplication. + +## Provenance and sprint scope + +Base: `007664306fff84fbb1c9a1b4053b69f439764034`. Seed **42**, drawn from OS +randomness at `2026-10-13T14:53:15.619448+00:00`, selected structural decoder +research. The initial three candidates were nonempty-star prescribed +triples, empty-allowed triangle targets, and prescribed targets in the +exceptional `k=4,q=2` cube. Seed modulo three selected the first. The +initial experiment completed all triples at `p=3,4,5`; refreshing overlap +then found concurrent PR #966, published at `15:07:03 UTC`. The one +evidence-driven pivot retained the exact same mathematical object and +added independent verification of that submission. + +A local claim records the initial scope and final result. The open issue +search found #650 and #913, neither a sprint coordination issue. PR #669 +was the only prescribed-triple submission found before selection. The +experiment has fixed exhaustive stopping domains, not a randomized search. + +The exact source pins are in [SOURCES.json](SOURCES.json). The vendored +certificate is byte-identical to its Git blob, checked by SHA-256 on each +run; its retained attribution is in [vendor/NOTICE.md](vendor/NOTICE.md). +Sam Sung's [PR #669](https://github.com/CrocSwap/integer-mult-bounds/pull/669) +at `7d526020fc368ce4157cd436995c2f4fcf683318` supplies the signed-port model +and selectable versus prescribed distinction. PR #966 credits that work, +Joel Pulikkan / GamingPuzzled, icekylinx and eumemic. Their credit is retained. + +The observation model is binary nonempty singleton stars at `k=2`, three +retained targets and unrestricted surviving non-target inputs. Empty-star +observations, higher `k`, other target counts and physical suppliers are +outside this audit. Source access, totals, helpers, frames, copies, +restoration, recursive children and assembly remain unpriced. + +Current main selects conditional PR #890 at +`kappa=1661957774647029/10^18`. We inspected its source manifest, certificate +and review and checked selected-record integrity. Its unrelated cold +construction was not rerun. No existing file, selected record or `upstream/` +file is changed. + +Contributor: Eva Ayala / ToikY, with substantial OpenAI Codex assistance, +including separate bounded workers for mathematical and implementation +checks. No independent human review is claimed. Apache-2.0, under the +repository's [license](../../LICENSE). diff --git a/research/prescribed-triple-decoder/SOURCES.json b/research/prescribed-triple-decoder/SOURCES.json new file mode 100644 index 0000000000..dff38c8104 --- /dev/null +++ b/research/prescribed-triple-decoder/SOURCES.json @@ -0,0 +1,40 @@ +{ + "base_commit": "007664306fff84fbb1c9a1b4053b69f439764034", + "source_role": "Independent audit of PR966's immutable certificate; no predecessor implementation is imported or executed", + "audited_submission": { + "pr": 966, + "repository": "woklerx/integer-mult-bounds", + "commit": "7eaf5665ac246310293fda06a3cf245fe72f6012", + "contributor": "woklerx, with substantial OpenAI Codex assistance", + "license": "Apache-2.0", + "certificate_path": "research/prescribed-three-port-decoders/CERTIFICATE.json", + "certificate_git_blob": "28d04184f1c7a4734ac14fdd577dd8429d29a716", + "certificate_sha256": "ab75a0a3506f66053ad0b7f693738e45db06ff9befdeed4484b9dffaa7f687dc", + "inspected_replay_path": "research/prescribed-three-port-decoders/reproduce.py", + "inspected_replay_git_blob": "a9b855caf33c4c49d519fd250402c111d8c6b7ee" + }, + "predecessor": { + "pr": 669, + "repository": "the-missionary-company/integer-mult-bounds", + "commit": "7d526020fc368ce4157cd436995c2f4fcf683318", + "contributor": "Sam Sung / the-missionary-company", + "license": "Apache-2.0", + "files": { + "research/asymmetric-hypercube-decoder/HIGHER-GRAPH.md": {"git_blob": "46f3857025f4d1e2e970ce8f2d7a2607d6007006", "sha256": "b1fab5e859209b983ca6374e11f41988e2146e3ab843e649a668b49c6443d739"}, + "research/asymmetric-hypercube-decoder/HIGHER-WEIGHTS.md": {"git_blob": "abf5be278d1bae25f131880ef1c49a894fb147e3", "sha256": "7dd0ea3eea0cb3f4ed4075da8a1648589aac995f4f7fda0674924368c5de40ff"}, + "research/asymmetric-hypercube-decoder/HIGHER-COST.md": {"git_blob": "a0fe1fcc4ed34f27a2434972d7c6e1d56f227a42", "sha256": "23a68e4dfd772244021f8cfcabb39a05bd4bec38415376c6bffd197b55e9a278"} + } + }, + "context_only": { + "selected_record": "certificates/selected-result.json", + "selected_pr": 890, + "selected_source_commit": "4b3bd8cbe8e3e81c44161017c9b72c905a8040a8", + "selected_kappa": "1661957774647029/1000000000000000000", + "selected_certificate": "research/community-frontier890-audit/ASSEMBLY.json", + "selected_certificate_sha256": "190110b509dc87d38b72ad37c3290efcc245ce26df4cae3d7e2d6dcf0bac2c43", + "review": "docs/research/community-frontier890-review.md", + "physical_construction_dependency": false + }, + "assignment": {"seed": 42, "track": "structural decoder research", "randomness": "OS randomness via Python secrets.randbelow", "generated_at_utc": "2026-10-13T14:53:15.619448+00:00"}, + "attribution": "Eva Ayala (GitHub ToikY), with substantial OpenAI Codex assistance; Apache-2.0" +} diff --git a/research/prescribed-triple-decoder/audit.py b/research/prescribed-triple-decoder/audit.py new file mode 100644 index 0000000000..7332d423cf --- /dev/null +++ b/research/prescribed-triple-decoder/audit.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python3 +"""Independent targetwise audit of PR966's pinned prescribed-triple certificate. + +Apache-2.0. Eva Ayala, with substantial OpenAI Codex assistance. +Only independent_check is imported; no predecessor or partition verifier is used. +""" +import argparse +from collections import Counter +import copy +import hashlib +from itertools import combinations, permutations, product +import json +from pathlib import Path +import sys + +ROOT = Path(__file__).resolve().parent +sys.path.insert(0, str(ROOT)) +from independent_check import check_p + +SOURCE_SHA256 = "ab75a0a3506f66053ad0b7f693738e45db06ff9befdeed4484b9dffaa7f687dc" +SOURCE_COMMIT = "7eaf5665ac246310293fda06a3cf245fe72f6012" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load_source(raw): + require(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "source SHA256 mismatch") + return json.loads(raw) + + +def graph(p): + return tuple((u, v) for u, v in combinations(range(2 * p), 2) + if u // 2 != v // 2) + + +def port_set(values, ports, message): + result = [tuple(edge) for edge in values] + require(all(edge in ports for edge in result), message + ": nonport") + require(len(result) == len(set(result)), message + ": duplicate") + return set(result) + + +def validate_witness(p, row): + ports = set(graph(p)) + targets = [tuple(edge) for edge in row["targets"]] + require(len(targets) == 3 and len(set(targets)) == 3 and set(targets) <= ports, + "invalid targets") + budget = row["minimum_deletions"] + if budget is None: + require(len(set(v for edge in targets for v in edge)) == 3, + "unproved nontriangle impossibility") + return 0 + witness = row["witness"] + deleted = port_set(witness["deleted_edges"], ports, "deleted edges") + require(not deleted & set(targets), "target deleted") + require(len(deleted) == budget, "wrong deletion count") + require(witness["surviving_inputs"] == len(ports) - len(deleted), + "surviving input inventory mismatch") + vertex_sets = witness["decoder_vertex_sets"] + require(len(vertex_sets) == 3, "wrong decoder count") + for target, vertices in zip(targets, vertex_sets): + require(len(vertices) == len(set(vertices)) and + all(isinstance(v, int) and 0 <= v < 2 * p for v in vertices), + "invalid decoder vertices") + chosen = set(vertices) + support = {edge for edge in ports if (edge[0] in chosen) != (edge[1] in chosen)} + require(support - deleted == {target}, "decoder support mismatch") + labels = witness["partition"] + require(len(labels) == 2 * p and set(labels) == {0, 1, 2, 3}, + "partition inventory mismatch") + bits = [tuple(v in vertices for vertices in vertex_sets) for v in range(2 * p)] + require(all((labels[u] == labels[v]) == (bits[u] == bits[v]) + for u, v in combinations(range(2 * p), 2)), + "partition does not describe decoder label blocks") + return 3 * (len(ports) - len(deleted)) + + +def validate_inventory(case): + p = case["p"] + ports = len(graph(p)) + triples = ports * (ports - 1) * (ports - 2) // 6 + require(case["ports"] == ports and case["triples_checked"] == triples, + "port or target inventory mismatch") + n = 2 * p + require(case["partitions_checked"] == (4 ** n - 4 * 3 ** n + 6 * 2 ** n - 4) // 24, + "partition inventory mismatch") + + +def expand_case(case): + validate_inventory(case) + p = case["p"] + ports = graph(p) + lookup = {} + class_counts = Counter() + equations = 0 + # Explicit full group, independent of first-occurrence canonicalization. + mappings = [tuple(2 * pair_map[v // 2] + ((v % 2) ^ flips[v // 2]) + for v in range(2 * p)) + for pair_map in permutations(range(p)) + for flips in product((0, 1), repeat=p)] + for row in case["orbits"]: + equations += validate_witness(p, row) + targets = [tuple(edge) for edge in row["targets"]] + orbit = {tuple(sorted(tuple(sorted((mapping[u], mapping[v]))) + for u, v in targets)) for mapping in mappings} + require(len(orbit) == row["multiplicity"], "orbit multiplicity mismatch") + require(not lookup.keys() & orbit, "orbit overlap") + class_counts[row["kind"]] += len(orbit) + lookup.update((target, row["minimum_deletions"]) for target in orbit) + require(set(lookup) == set(combinations(ports, 3)), "incomplete target coverage") + require(dict(class_counts) == case["class_counts"], "class inventory mismatch") + return lookup, {"p": p, "ports": len(ports), "labelled_target_triples": len(lookup), + "orbits": len(case["orbits"]), "group_elements": len(mappings), + "retained_decoder_equations": equations} + + +def compare_targetwise(p, lookup, independent): + ports = [tuple(edge) for edge in independent["edges"]] + require(ports == list(graph(p)), "independent graph mismatch") + for row in independent["targets"]: + target = tuple(ports[i] for i in row["edge_indices"]) + require(lookup[target] == row["minimum_deletions"], + "targetwise minimum mismatch: " + repr(target)) + + +def rejected(action, name): + try: + action() + except (ValueError, KeyError, IndexError, TypeError): + return name + raise ValueError("negative control was accepted: " + name) + + +def controls(raw, source, lookups, independent): + results = [rejected(lambda: load_source(raw + b" "), "source_sha256")] + case = source["cases"][0] + original = case["orbits"][0] + for name in ("zero_decoder", "wrong_target_decoder", "delete_target", "nonport", + "duplicate_deletion", "surviving_inventory", "collapse_partition"): + row = copy.deepcopy(original) + witness = row["witness"] + if name == "zero_decoder": + witness["decoder_vertex_sets"][0] = [] + elif name == "wrong_target_decoder": + witness["decoder_vertex_sets"][0] = witness["decoder_vertex_sets"][1] + elif name == "delete_target": + witness["deleted_edges"][0] = row["targets"][0] + elif name == "nonport": + witness["deleted_edges"][0] = [0, 1] + elif name == "duplicate_deletion": + witness["deleted_edges"].append(witness["deleted_edges"][0]) + elif name == "surviving_inventory": + witness["surviving_inputs"] += 1 + else: + witness["partition"] = [0] * (2 * case["p"]) + results.append(rejected(lambda row=row: validate_witness(case["p"], row), name)) + bad_case = copy.deepcopy(case) + bad_case["ports"] += 1 + results.append(rejected(lambda: validate_inventory(bad_case), "port_inventory")) + for p in (3, 4): + bad = dict(lookups[p]) + ordinary = next(target for target, value in bad.items() if value == 6 * p - 12) + exceptional = next(target for target, value in bad.items() if value == 6 * p - 11) + bad[ordinary], bad[exceptional] = bad[exceptional], bad[ordinary] + require(Counter(bad.values()) == Counter(lookups[p].values()), + "swap changed the histogram") + results.append(rejected(lambda p=p, bad=bad: compare_targetwise(p, bad, independent[p]), + "histogram_preserving_target_swap_p%d" % p)) + return results + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--source", type=Path, default=ROOT / "vendor" / "PR966-CERTIFICATE.json") + parser.add_argument("--write", action="store_true", help="write deterministic AUDIT.json receipt") + args = parser.parse_args() + raw = args.source.read_bytes() + source = load_source(raw) + require(source["schema"] == "prescribed-three-two-port-v1" and source["field"] == "F2" + and source["empty_star"] is False, "observation model mismatch") + require([case["p"] for case in source["cases"]] == [2, 3, 4, 5, 6], "case domain mismatch") + lookups, cases = {}, [] + for case in source["cases"]: + lookup, receipt = expand_case(case) + lookups[case["p"]] = lookup + cases.append(receipt) + independent = {} + for p in (3, 4): + independent[p] = check_p(p) + compare_targetwise(p, lookups[p], independent[p]) + receipt = {"format": "pr966-targetwise-independent-audit-v1", + "source_commit": SOURCE_COMMIT, "source_sha256": SOURCE_SHA256, + "cases": cases, + "independent_rref": [{"p": p, "subspaces": independent[p]["subspaces_checked"], + "target_triples": independent[p]["target_triples_checked"]} + for p in (3, 4)], + "negative_controls": controls(raw, source, lookups, independent)} + receipt_path = ROOT / "AUDIT.json" + if args.write: + receipt_path.write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + else: + require(json.loads(receipt_path.read_text()) == receipt, + "committed audit receipt differs from fresh replay") + print(json.dumps(receipt, sort_keys=True)) + print("PASS PR966 targetwise audit: %d triples; %d orbits; %d witnesses; %d targetwise minima; %d controls" % ( + sum(case["labelled_target_triples"] for case in cases), + sum(case["orbits"] for case in cases), + sum("witness" in row for case in source["cases"] for row in case["orbits"]), + sum(result["target_triples_checked"] for result in independent.values()), + len(receipt["negative_controls"]))) + + +if __name__ == "__main__": + main() diff --git a/research/prescribed-triple-decoder/independent_check.py b/research/prescribed-triple-decoder/independent_check.py new file mode 100644 index 0000000000..ee27c8c920 --- /dev/null +++ b/research/prescribed-triple-decoder/independent_check.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +"""Independently enumerate rank-three subspaces of a binary graph cut code. + +This uses RREF coefficient matrices, not partition enumeration. Vertices are +0,...,2p-1; the removed perfect matching is {(0,1),(2,3),...}. The last +vertex's cut coefficient is fixed to zero to remove the constant-vector kernel. +Only the proper, nonempty star span is checked. No claim about a paid supplier +or the integer multiplication exponent follows from this finite calculation. + +Apache-2.0. Eva Ayala, with substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +import itertools +import json +from pathlib import Path +import sys + + +def graph_edges(p): + """Construct the graph without using the partition verifier's helpers.""" + return [ + (u, v) + for u in range(2 * p) + for v in range(u + 1, 2 * p) + if u // 2 != v // 2 + ] + + +def rref_bases(columns): + """Yield every rank-three binary row space exactly once in RREF.""" + for pivots in itertools.combinations(range(columns), 3): + free = [ + (row, col) + for row, pivot in enumerate(pivots) + for col in range(pivot + 1, columns) + if col not in pivots + ] + for assignment in range(1 << len(free)): + rows = [1 << pivot for pivot in pivots] + for bit, (row, col) in enumerate(free): + if (assignment >> bit) & 1: + rows[row] |= 1 << col + yield tuple(rows) + + +def independent_columns(a, b, c): + """Rank three for three columns in GF(2)^3, by direct elimination.""" + pivots = [0, 0, 0] + rank = 0 + for column in (a, b, c): + for bit in range(2, -1, -1): + if not ((column >> bit) & 1): + continue + if pivots[bit]: + column ^= pivots[bit] + else: + pivots[bit] = column + rank += 1 + break + return rank == 3 + + +def check_p(p): + """Compute minimum support minus three for every prescribed target triple.""" + edges = graph_edges(p) + n_edges = len(edges) + triples = list(itertools.combinations(range(n_edges), 3)) + minima = {triple: None for triple in triples} + column_triples = [ + triple + for triple in itertools.combinations(range(1, 8), 3) + if independent_columns(*triple) + ] + spaces_checked = 0 + for basis in rref_bases(2 * p - 1): + spaces_checked += 1 + vertex_columns = [ + sum(((basis[row] >> v) & 1) << row for row in range(3)) + for v in range(2 * p - 1) + ] + [0] + by_column = [[] for _ in range(8)] + for edge_index, (u, v) in enumerate(edges): + by_column[vertex_columns[u] ^ vertex_columns[v]].append(edge_index) + support = n_edges - len(by_column[0]) + budget = support - 3 + for a, b, c in column_triples: + for first in by_column[a]: + for second in by_column[b]: + for third in by_column[c]: + target = tuple(sorted((first, second, third))) + previous = minima[target] + if previous is None or budget < previous: + minima[target] = budget + + dimension = 2 * p - 1 + expected_spaces = ( + ((1 << dimension) - 1) + * ((1 << dimension) - 2) + * ((1 << dimension) - 4) + // ((8 - 1) * (8 - 2) * (8 - 4)) + ) + if spaces_checked != expected_spaces: + raise RuntimeError("RREF count differs from the Gaussian binomial") + + # Independent negative control: an actual graph triangle's three edge + # differences sum to zero, so no three-dimensional subspace can decode it. + triangles = set() + index = {edge: i for i, edge in enumerate(edges)} + for u, v, w in itertools.combinations(range(2 * p), 3): + triangle_edges = ((u, v), (u, w), (v, w)) + if all(edge in index for edge in triangle_edges): + target = tuple(sorted(index[edge] for edge in triangle_edges)) + triangles.add(target) + if minima[target] is not None: + raise RuntimeError("a graph triangle was incorrectly decodable") + undecodable = {target for target, value in minima.items() if value is None} + if undecodable != triangles: + raise RuntimeError("undecodable target sets differ from graph triangles") + + histogram = Counter("null" if value is None else str(value) + for value in minima.values()) + return { + "p": p, + "vertices": 2 * p, + "edges": [list(edge) for edge in edges], + "subspaces_checked": spaces_checked, + "target_triples_checked": len(triples), + "undecodable_triangles": len(triangles), + "histogram": dict(sorted(histogram.items())), + "targets": [ + {"edge_indices": list(target), "minimum_deletions": minima[target]} + for target in triples + ], + } + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--p", type=int, choices=(3, 4), default=3) + parser.add_argument("--output", type=Path, + help="write the complete target table to this file") + parser.add_argument("--compare", type=Path, + help="compare every target with a prior table in this schema") + args = parser.parse_args(argv) + result = check_p(args.p) + if args.compare: + expected = json.loads(args.compare.read_text()) + for field in ("p", "edges", "targets"): + if expected.get(field) != result[field]: + raise RuntimeError("comparison mismatch in " + field) + if args.output: + args.output.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + summary = {key: value for key, value in result.items() + if key not in ("edges", "targets")} + summary["method"] = "all rank-three cut-code subspaces in RREF" + summary["comparison"] = "passed" if args.compare else "not requested" + print(json.dumps(summary, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/research/prescribed-triple-decoder/vendor/NOTICE.md b/research/prescribed-triple-decoder/vendor/NOTICE.md new file mode 100644 index 0000000000..1c3cf4dd8d --- /dev/null +++ b/research/prescribed-triple-decoder/vendor/NOTICE.md @@ -0,0 +1,16 @@ +# Retained certificate provenance + +`PR966-CERTIFICATE.json` is a byte-for-byte copy of +`research/prescribed-three-port-decoders/CERTIFICATE.json` from +woklerx/integer-mult-bounds at commit +`7eaf5665ac246310293fda06a3cf245fe72f6012`, Git blob +`28d04184f1c7a4734ac14fdd577dd8429d29a716`. + +Copyright 2026 woklerx. Apache-2.0, under the repository's root LICENSE. +Prepared with substantial OpenAI Codex assistance, as disclosed in +[PR #966](https://github.com/CrocSwap/integer-mult-bounds/pull/966). + +The original contribution credits Sam Sung / the-missionary-company +(PR #669), Joel Pulikkan / GamingPuzzled, icekylinx and eumemic. +This copy preserves the original certificate exactly; the audit code +is independently written and imports no original implementation. diff --git a/research/prescribed-triple-decoder/vendor/PR966-CERTIFICATE.json b/research/prescribed-triple-decoder/vendor/PR966-CERTIFICATE.json new file mode 100644 index 0000000000..28d04184f1 --- /dev/null +++ b/research/prescribed-triple-decoder/vendor/PR966-CERTIFICATE.json @@ -0,0 +1,7005 @@ +{ + "cases": [ + { + "class_counts": { + "two_pair_path": 4 + }, + "orbits": [ + { + "kind": "two_pair_path", + "minimum_deletions": 1, + "multiplicity": 4, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 1 + ] + ], + "deleted_edges": [ + [ + 1, + 3 + ] + ], + "partition": [ + 0, + 1, + 2, + 3 + ], + "surviving_inputs": 3 + } + } + ], + "p": 2, + "partitions_checked": 1, + "ports": 4, + "triples_checked": 4 + }, + { + "class_counts": { + "ordinary_forest": 200, + "triangle": 8, + "two_pair_path": 12 + }, + "orbits": [ + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 24, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 5 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 5 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "two_pair_path", + "minimum_deletions": 7, + "multiplicity": 12, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 1 + ] + ], + "deleted_edges": [ + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 2, + 3, + 0, + 0 + ], + "surviving_inputs": 5 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 24, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 48, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 2, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 48, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 3 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "triangle", + "minimum_deletions": null, + "multiplicity": 8, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 4 + ] + ] + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 24, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 5 + ], + [ + 1, + 3, + 4 + ], + [ + 5 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 1, + 2 + ], + [ + 1, + 5 + ], + [ + 2, + 4 + ], + [ + 3, + 5 + ] + ], + "partition": [ + 0, + 1, + 2, + 1, + 1, + 3 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 24, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 6, + "multiplicity": 8, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1 + ], + "surviving_inputs": 6 + } + } + ], + "p": 3, + "partitions_checked": 65, + "ports": 12, + "triples_checked": 220 + }, + { + "class_counts": { + "ordinary_forest": 1968, + "triangle": 32, + "two_pair_path": 24 + }, + "orbits": [ + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 96, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 5, + 6, + 7 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "two_pair_path", + "minimum_deletions": 13, + "multiplicity": 24, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 1 + ] + ], + "deleted_edges": [ + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ] + ], + "partition": [ + 0, + 1, + 2, + 3, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 11 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 96, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 192, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 2, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 96, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 64, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 0, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 192, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 3 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 192, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "triangle", + "minimum_deletions": null, + "multiplicity": 32, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 4 + ] + ] + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 96, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 5 + ], + [ + 1, + 3, + 4, + 6, + 7 + ], + [ + 5 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 2 + ], + [ + 1, + 5 + ], + [ + 2, + 4 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ] + ], + "partition": [ + 0, + 1, + 2, + 1, + 1, + 3, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 192, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 6 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 96, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 384, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 48, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 32, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 12 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 12, + "multiplicity": 192, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 5, + 6 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0 + ], + "surviving_inputs": 12 + } + } + ], + "p": 4, + "partitions_checked": 1701, + "ports": 24, + "triples_checked": 2024 + }, + { + "class_counts": { + "ordinary_forest": 9760, + "triangle": 80, + "two_pair_path": 40 + }, + "orbits": [ + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 240, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 5, + 6, + 7, + 8, + 9 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "two_pair_path", + "minimum_deletions": 19, + "multiplicity": 40, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 1 + ] + ], + "deleted_edges": [ + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ] + ], + "partition": [ + 0, + 1, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 21 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 240, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 2, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 320, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 0, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 3 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "triangle", + "minimum_deletions": null, + "multiplicity": 80, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 4 + ] + ] + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 240, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 5 + ], + [ + 1, + 3, + 4, + 6, + 7, + 8, + 9 + ], + [ + 5 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 2 + ], + [ + 1, + 5 + ], + [ + 2, + 4 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ] + ], + "partition": [ + 0, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 6 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 240, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 1920, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 6, + 8 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 8 + ] + ], + "deleted_edges": [ + [ + 0, + 8 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 8 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 8 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 8 + ], + [ + 7, + 8 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 240, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 80, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 22 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 18, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 6, + 8 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 8 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 8 + ], + [ + 1, + 2 + ], + [ + 1, + 8 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 3, + 4 + ], + [ + 3, + 8 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 5, + 8 + ], + [ + 7, + 8 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 0 + ], + "surviving_inputs": 22 + } + } + ], + "p": 5, + "partitions_checked": 34105, + "ports": 40, + "triples_checked": 9880 + }, + { + "class_counts": { + "ordinary_forest": 34000, + "triangle": 160, + "two_pair_path": 60 + }, + "orbits": [ + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "two_pair_path", + "minimum_deletions": 25, + "multiplicity": 60, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 1 + ] + ], + "deleted_edges": [ + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ] + ], + "partition": [ + 0, + 1, + 2, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 35 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 2, + 4 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 3 + ], + [ + 4 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 1440, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 0, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 3 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 2880, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 1, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "triangle", + "minimum_deletions": null, + "multiplicity": 160, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 4 + ] + ] + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 5 + ], + [ + 1, + 3, + 4, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 5 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 2 + ], + [ + 1, + 5 + ], + [ + 2, + 4 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ] + ], + "partition": [ + 0, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 2880, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 2, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2, + 6 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 480, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 5760, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 5760, + "targets": [ + [ + 0, + 2 + ], + [ + 0, + 4 + ], + [ + 6, + 8 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 8 + ] + ], + "deleted_edges": [ + [ + 0, + 8 + ], + [ + 1, + 2 + ], + [ + 1, + 4 + ], + [ + 1, + 8 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 8 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 720, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ], + [ + 4, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 3 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 6 + ], + [ + 2, + 6 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 1, + 1, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 160, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 5 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + [ + 4 + ], + [ + 3 + ] + ], + "deleted_edges": [ + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 1, + 3 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ] + ], + "partition": [ + 0, + 1, + 1, + 2, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 2880, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 6 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 6 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 6 + ], + [ + 1, + 2 + ], + [ + 1, + 6 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 6 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 3, + 0, + 0, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 5760, + "targets": [ + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 6, + 8 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 4 + ], + [ + 8 + ] + ], + "deleted_edges": [ + [ + 0, + 4 + ], + [ + 0, + 8 + ], + [ + 1, + 2 + ], + [ + 1, + 8 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 4 + ], + [ + 3, + 8 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 5, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 2, + 0, + 0, + 0, + 3, + 0, + 0, + 0 + ], + "surviving_inputs": 36 + } + }, + { + "kind": "ordinary_forest", + "minimum_deletions": 24, + "multiplicity": 960, + "targets": [ + [ + 0, + 2 + ], + [ + 4, + 6 + ], + [ + 8, + 10 + ] + ], + "witness": { + "decoder_vertex_sets": [ + [ + 2 + ], + [ + 6 + ], + [ + 10 + ] + ], + "deleted_edges": [ + [ + 0, + 6 + ], + [ + 0, + 10 + ], + [ + 1, + 2 + ], + [ + 1, + 6 + ], + [ + 1, + 10 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 3, + 6 + ], + [ + 3, + 10 + ], + [ + 4, + 10 + ], + [ + 5, + 6 + ], + [ + 5, + 10 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 7, + 10 + ], + [ + 9, + 10 + ] + ], + "partition": [ + 0, + 0, + 1, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 3, + 0 + ], + "surviving_inputs": 36 + } + } + ], + "p": 6, + "partitions_checked": 611501, + "ports": 60, + "triples_checked": 34220 + } + ], + "controls": [ + "omit_required_deletion", + "duplicate_deletion", + "delete_target", + "admit_nonport_mate_edge", + "zero_decoder", + "copy_wrong_target_decoder", + "collapse_partition", + "triangle_cut_rank_obstruction", + "empty_star_changes_model", + "extra_deletion_required" + ], + "domain": "all distinct target triples for p=2,...,6, modulo exact matched-pair symmetry", + "empty_star": false, + "field": "F2", + "schema": "prescribed-three-two-port-v1" +}