diff --git a/.github/workflows/rounding-counterexamples.yml b/.github/workflows/rounding-counterexamples.yml new file mode 100644 index 0000000..5d52718 --- /dev/null +++ b/.github/workflows/rounding-counterexamples.yml @@ -0,0 +1,65 @@ +name: Verify rounding counterexample papers + +on: + push: + branches: + - agent/rounding-counterexample-papers + paths: + - "2026-rounding-counterexamples/**" + - ".github/workflows/rounding-counterexamples.yml" + pull_request: + paths: + - "2026-rounding-counterexamples/**" + - ".github/workflows/rounding-counterexamples.yml" + +permissions: + contents: write + +jobs: + exact-certificates: + if: github.event_name != 'push' || !contains(github.event.head_commit.message, '[skip generated PDFs]') + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Verify final certificates + working-directory: 2026-rounding-counterexamples + run: python3 code/verify_all.py + - name: Reconstruct parameter families + working-directory: 2026-rounding-counterexamples + run: make derive + + build-pdfs: + if: github.event_name != 'push' || !contains(github.event.head_commit.message, '[skip generated PDFs]') + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install TeX dependencies + run: | + sudo apt-get update + sudo apt-get install -y latexmk texlive-latex-extra texlive-fonts-recommended + - name: Compile all manuscripts + working-directory: 2026-rounding-counterexamples + run: make papers + - name: Upload compiled manuscripts + uses: actions/upload-artifact@v4 + with: + name: rounding-counterexample-papers + path: 2026-rounding-counterexamples/build/*.pdf + if-no-files-found: error + - name: Commit compiled manuscripts to the review branch + if: github.event_name == 'push' + run: | + mkdir -p 2026-rounding-counterexamples/generated-pdfs + cp 2026-rounding-counterexamples/build/*.pdf 2026-rounding-counterexamples/generated-pdfs/ + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git add -f 2026-rounding-counterexamples/generated-pdfs/*.pdf + if git diff --cached --quiet; then + echo "Generated PDFs are unchanged." + else + git commit -m "Add compiled research PDFs [skip generated PDFs]" + git push origin HEAD:${GITHUB_REF_NAME} + fi diff --git a/2026-rounding-counterexamples/.gitignore b/2026-rounding-counterexamples/.gitignore new file mode 100644 index 0000000..64f0e18 --- /dev/null +++ b/2026-rounding-counterexamples/.gitignore @@ -0,0 +1,10 @@ +build/ +papers/*.aux +papers/*.bbl +papers/*.blg +papers/*.fdb_latexmk +papers/*.fls +papers/*.log +papers/*.out +papers/*.pdf +papers/*.synctex.gz diff --git a/2026-rounding-counterexamples/AI_DISCLOSURE.md b/2026-rounding-counterexamples/AI_DISCLOSURE.md new file mode 100644 index 0000000..dbb826c --- /dev/null +++ b/2026-rounding-counterexamples/AI_DISCLOSURE.md @@ -0,0 +1,18 @@ +# AI-use and authorship disclosure + +A generative AI system assisted with exploratory reasoning, algebraic checks, source-code drafting, exposition, LaTeX preparation, and repository organization. + +The AI system is not an author. It cannot make an authorship declaration, warrant novelty, accept responsibility for errors, disclose conflicts of interest, transfer copyright, or respond to peer review. The eventual human authors must: + +- independently verify every theorem and citation; +- establish priority and contact relevant researchers when appropriate; +- supply the legal author list, affiliations, acknowledgements, funding, and contribution statement; +- review all code and generated PDFs; +- comply with the target journal's current disclosure policy; +- take full responsibility for the submitted and published work. + +Suggested disclosure language, subject to the target journal's rules: + +> A generative AI system was used during exploratory problem solving and to assist with algebraic checking, code drafting, and language editing. The authors independently verified the mathematical arguments, computational certificates, citations, and final text, and take full responsibility for the work. + +No confidential referee report, unpublished third-party manuscript, personal data, or proprietary dataset is included in this package. diff --git a/2026-rounding-counterexamples/Makefile b/2026-rounding-counterexamples/Makefile new file mode 100644 index 0000000..023f6db --- /dev/null +++ b/2026-rounding-counterexamples/Makefile @@ -0,0 +1,38 @@ +PYTHON ?= python3 +LATEXMK ?= latexmk +BUILD := build +PAPER_DIR := papers +FIGURE_DIR := figures +PAPERS := dgg-counterexample chairman-counterexample overview + +.PHONY: all verify derive papers clean + +all: verify papers + +verify: + $(PYTHON) code/verify_all.py + +derive: + $(PYTHON) code/derive_dgg_family.py + $(PYTHON) code/derive_chairman_family.py + +papers: $(PAPERS:%=$(BUILD)/%.pdf) + +$(BUILD): + mkdir -p $(BUILD) + +$(BUILD)/dgg-counterexample.pdf: $(PAPER_DIR)/dgg-counterexample.tex $(PAPER_DIR)/references.bib $(FIGURE_DIR)/dgg_network.tex $(FIGURE_DIR)/dgg_obstruction.tex | $(BUILD) + cd $(PAPER_DIR) && $(LATEXMK) -pdf -interaction=nonstopmode -halt-on-error dgg-counterexample.tex + cp $(PAPER_DIR)/dgg-counterexample.pdf $@ + +$(BUILD)/chairman-counterexample.pdf: $(PAPER_DIR)/chairman-counterexample.tex $(PAPER_DIR)/references.bib $(FIGURE_DIR)/chairman_gadget.tex | $(BUILD) + cd $(PAPER_DIR) && $(LATEXMK) -pdf -interaction=nonstopmode -halt-on-error chairman-counterexample.tex + cp $(PAPER_DIR)/chairman-counterexample.pdf $@ + +$(BUILD)/overview.pdf: $(PAPER_DIR)/overview.tex $(PAPER_DIR)/references.bib $(FIGURE_DIR)/graphical_abstract.tex $(FIGURE_DIR)/dgg_network.tex $(FIGURE_DIR)/chairman_gadget.tex | $(BUILD) + cd $(PAPER_DIR) && $(LATEXMK) -pdf -interaction=nonstopmode -halt-on-error overview.tex + cp $(PAPER_DIR)/overview.pdf $@ + +clean: + cd $(PAPER_DIR) && $(LATEXMK) -C dgg-counterexample.tex chairman-counterexample.tex overview.tex || true + rm -rf $(BUILD) diff --git a/2026-rounding-counterexamples/README.md b/2026-rounding-counterexamples/README.md new file mode 100644 index 0000000..85b8172 --- /dev/null +++ b/2026-rounding-counterexamples/README.md @@ -0,0 +1,102 @@ +# Counterexamples to two weighted-rounding conjectures + +**Status:** research preprint and exact certificate package, prepared for independent review. The mathematical claims are explicit and finitely checkable; priority and novelty should still be checked by the eventual human authors and referees before public announcement. + +This directory contains two self-contained results. + +1. **A planar counterexample to Goemans' cost conjecture for single-source unsplittable flow.** The instance has seven vertices, nine arcs, three demands, exactly two paths per terminal, and exactly eight unsplittable routings. The fractional cost is `58`; every unsplittable routing satisfying the conjectured additive upper bound has cost at least `60`. +2. **A counterexample to the machine-dependent weighted-chairman conjecture of Liu and Reis.** The instance has 11 rows and 15 columns. A three-column forcing gadget is repeated five times, producing an exact prefix discrepancy of at least `619/600 > 1`. + +## Fast verification + +The verifiers use only the Python standard library and exact integer or rational arithmetic. + +```bash +cd 2026-rounding-counterexamples +python3 code/verify_all.py +``` + +Expected final lines: + +```text +DGG certificate verified: min good cost = 60 > fractional cost = 58 +Chairman certificate verified: forced accumulator lower bound = 619/600 > 1 +All exact certificates passed. +``` + +## Build the manuscripts + +A TeX Live installation with `latexmk`, `pdflatex`, TikZ, `booktabs`, and `hyperref` is sufficient. + +```bash +make papers +``` + +The expected PDFs are: + +```text +build/dgg-counterexample.pdf +build/chairman-counterexample.pdf +build/overview.pdf +``` + +GitHub Actions runs the exact verifiers and compiles all three PDFs. The compiled PDFs are uploaded as workflow artifacts; generated binaries are deliberately not treated as source files. + +## Directory map + +```text +2026-rounding-counterexamples/ +├── README.md +├── Makefile +├── AI_DISCLOSURE.md +├── SUBMISSION_CHECKLIST.md +├── code/ +│ ├── verify_dgg.py +│ ├── verify_chairman.py +│ ├── verify_all.py +│ ├── derive_dgg_family.py +│ └── derive_chairman_family.py +├── data/ +│ ├── dgg_instance.json +│ └── chairman_instance.json +├── figures/ +│ ├── dgg_network.tex +│ ├── dgg_obstruction.tex +│ ├── chairman_gadget.tex +│ └── graphical_abstract.tex +├── papers/ +│ ├── dgg-counterexample.tex +│ ├── chairman-counterexample.tex +│ ├── overview.tex +│ └── references.bib +└── research/ + ├── derivation-dgg.md + ├── derivation-chairman.md + ├── importance-and-history.md + ├── provenance.md + └── validation-report.md +``` + +## Central certificates + +For the flow instance, the three zero-cost path choices form a triangle conflict graph. If `z_i=1` denotes choosing the cheap path for terminal `i`, every capacity-good integral routing satisfies + +```text +z_1 + z_2 + z_3 <= 1, +``` + +whereas the fractional cheap-path marginals are `(1/3, 2/5, 1/3)` and sum to `16/15`. The costs are the nonnegative separator of this violated stable-set inequality. + +For the chairman instance, every hypothetical discrepancy-1 assignment is forced to make five specific decisions. Each decision contributes `5/24` to an accumulator row. Ten detector columns can offset the accumulator by at most `10/1000`, giving + +```text +5*(5/24) - 10/1000 = 619/600 > 1. +``` + +## Scope of the record + +The repository contains the complete final derivations, exact data, exact certificate verifiers, parametric-family reconstruction scripts, manuscript sources, figures, and build automation. Earlier exploratory searches were conducted interactively and were not all preserved as standalone programs; `research/provenance.md` distinguishes final reproducible code from ephemeral exploration. + +## Authorship and submission + +The manuscripts use `Anonymous for review`. Replace that placeholder with the legal author list, affiliations, acknowledgements, contribution statement, and corresponding-author details before submission. Do not list an AI system as an author. See `AI_DISCLOSURE.md` and `SUBMISSION_CHECKLIST.md`. diff --git a/2026-rounding-counterexamples/SUBMISSION_CHECKLIST.md b/2026-rounding-counterexamples/SUBMISSION_CHECKLIST.md new file mode 100644 index 0000000..76b87de --- /dev/null +++ b/2026-rounding-counterexamples/SUBMISSION_CHECKLIST.md @@ -0,0 +1,42 @@ +# Journal submission checklist + +## Mathematical audit + +- [ ] Two independent experts have checked the seven-vertex SSUF certificate. +- [ ] An expert has checked the exact wording and quantifiers of Goemans' conjecture against the cited sources. +- [ ] An expert has checked the chairman forcing proof, including assignments outside fractional support. +- [ ] `python3 code/verify_all.py` passes on a clean checkout. +- [ ] The GitHub Actions verification and PDF-build jobs are green. +- [ ] The parametric `9/8` planar lower-bound calculation has been independently checked. + +## Priority and literature + +- [ ] Repeat the literature search immediately before submission. +- [ ] Check arXiv, DBLP, MathSciNet, zbMATH, conference proceedings, and authors' webpages for overlapping results. +- [ ] Consider notifying the conjecture originators and the authors of the most recent positive results. +- [ ] Replace all `to our knowledge` claims with wording supported by the final search date. + +## Authorship and ethics + +- [ ] Replace `Anonymous for review` as required by the journal. +- [ ] Add affiliations, corresponding-author details, funding, acknowledgements, and contributions. +- [ ] Review `AI_DISCLOSURE.md` against the journal's current policy. +- [ ] Confirm that every human author has read and approved the final manuscript. +- [ ] Confirm that the title, abstract, and press language do not overstate peer-review status. + +## Typesetting and artifacts + +- [ ] Build all PDFs from a clean checkout with `make all`. +- [ ] Inspect every compiled page at readable resolution. +- [ ] Check that figure labels are legible in grayscale and at one-column width. +- [ ] Check references, DOIs, hyperlinks, theorem numbering, and equation cross-references. +- [ ] Remove build auxiliaries and verify that source archives contain everything needed. +- [ ] Select and apply an explicit code/data license approved by the authors. + +## Recommended circulation order + +1. Private mathematical audit. +2. Author-originator courtesy check where appropriate. +3. Preprint deposit with immutable versioned certificate. +4. Journal or conference submission. +5. Public announcement only after the authors are satisfied with priority and correctness. diff --git a/2026-rounding-counterexamples/code/derive_chairman_family.py b/2026-rounding-counterexamples/code/derive_chairman_family.py new file mode 100644 index 0000000..9dea1dc --- /dev/null +++ b/2026-rounding-counterexamples/code/derive_chairman_family.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +"""Verify the parametric inequalities behind the chairman gadget.""" + +from __future__ import annotations + +from fractions import Fraction + + +def main() -> None: + blocks = 5 + p = Fraction(5, 24) # accumulator share in J + a = Fraction(1, 2) # A-row weight in K + q = Fraction(25, 48) # H-row share in L + eta = Fraction(1, 1000) + + # Ignoring the small off-support penalty, these are the three forcing + # margins. They must all be positive. + margin_K_not_A = a / 2 - p + margin_L_to_H = 1 - p - a / 2 - q + margin_L_not_H = q - Fraction(1, 2) + accumulator_margin = blocks * p - 1 + + assert margin_K_not_A == Fraction(1, 24) > 0 + assert margin_L_to_H == Fraction(1, 48) > 0 + assert margin_L_not_H == Fraction(1, 48) > 0 + assert accumulator_margin == Fraction(1, 24) > 0 + + # The first detector row can lose at most 12 eta before its block, while + # the second can lose at most 13 eta after a possible off-support J choice. + assert margin_K_not_A > 12 * eta + assert margin_L_to_H > 12 * eta + assert margin_L_not_H > 13 * eta + assert accumulator_margin > 2 * blocks * eta + + detector = 1 + min( + margin_L_to_H - 12 * eta, + margin_L_not_H - 13 * eta, + ) + accumulator = blocks * p - 2 * blocks * eta + + assert detector == Fraction(6047, 6000) > 1 + assert accumulator == Fraction(619, 600) > 1 + + print(f"p={p}, a={a}, q={q}, eta={eta}, blocks={blocks}") + print( + "forcing margins: " + f"K={margin_K_not_A}, L-to-H={margin_L_to_H}, " + f"L-not-to-H={margin_L_not_H}" + ) + print(f"detector lower bound: {detector}") + print(f"accumulator lower bound: {accumulator}") + + +if __name__ == "__main__": + main() diff --git a/2026-rounding-counterexamples/code/derive_dgg_family.py b/2026-rounding-counterexamples/code/derive_dgg_family.py new file mode 100644 index 0000000..19314c2 --- /dev/null +++ b/2026-rounding-counterexamples/code/derive_dgg_family.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +"""Reconstruct the integer SSUF certificate from its rational family.""" + +from __future__ import annotations + +from fractions import Fraction +from math import lcm + + +def L(*values: Fraction) -> int: + scale = 1 + for value in values: + scale = lcm(scale, value.denominator) + return scale + + +def main() -> None: + # Normalized maximum demand D=1. Cheap-path probabilities are r,q,r. + b = Fraction(2, 3) # middle demand + r = Fraction(1, 3) + q = Fraction(2, 5) + + # Cost preservation forces at least two cheap paths when 2r+q>1. + cheap_mass = 2 * r + q + assert cheap_mass == Fraction(16, 15) > 1 + + # Additive load needed by the three possible cheap pairs. + pair_12_or_23 = 1 + b * (1 - q) - r + pair_13 = 2 - 2 * r - b * q + assert pair_12_or_23 == pair_13 == Fraction(16, 15) + + # Choose the smallest convenient scale making this displayed instance + # integral. The resulting maximum demand is 15 and every critical pair + # exceeds x+D by exactly one unit. + quantities = [ + b, + r, + b * q, + 1 - r, + b * (1 - q), + 1 + r + b * q, + 2 * r + b * q, + r + b * q, + ] + scale = L(*quantities) + assert scale == 15 + + d1, d2, d3 = scale, int(scale * b), scale + x = { + "s->t1": int(scale * (1 - r)), + "s->t2": int(scale * b * (1 - q)), + "s->u": int(scale * (1 + r + b * q)), + "u->t3": int(scale * (1 - r)), + "u->v": int(scale * (2 * r + b * q)), + "v->t1": int(scale * r), + "v->w": int(scale * (r + b * q)), + "w->t2": int(scale * b * q), + "w->t3": int(scale * r), + } + expected = { + "s->t1": 10, + "s->t2": 6, + "s->u": 24, + "u->t3": 10, + "u->v": 14, + "v->t1": 5, + "v->w": 9, + "w->t2": 4, + "w->t3": 5, + } + assert x == expected + + # Give each expensive integral path total cost 30. + common_path_cost = lcm(d1, d2, d3) + costs = { + "s->t1": common_path_cost // d1, + "s->t2": common_path_cost // d2, + "u->t3": common_path_cost // d3, + } + assert common_path_cost == 30 + assert costs == {"s->t1": 2, "s->t2": 3, "u->t3": 2} + + fractional_cost = int(common_path_cost * (3 - cheap_mass)) + integral_good_cost = 2 * common_path_cost + assert fractional_cost == 58 + assert integral_good_cost == 60 + + print(f"normalized demands: (1, {b}, 1)") + print(f"cheap probabilities: ({r}, {q}, {r})") + print(f"violated triangle mass: {cheap_mass}") + print(f"required additive coefficient for every cheap pair: {pair_13}") + print(f"integer demands: {(d1, d2, d3)}") + print(f"integer fractional loads: {x}") + print(f"nonzero per-unit costs: {costs}") + print(f"cost gap: {fractional_cost} < {integral_good_cost}") + + +if __name__ == "__main__": + main() diff --git a/2026-rounding-counterexamples/code/verify_all.py b/2026-rounding-counterexamples/code/verify_all.py new file mode 100644 index 0000000..ea388a8 --- /dev/null +++ b/2026-rounding-counterexamples/code/verify_all.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +"""Run every exact certificate verifier in a fresh Python process.""" + +from __future__ import annotations + +import subprocess +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def run(script: str) -> None: + path = HERE / script + print(f"=== {script} ===") + subprocess.run([sys.executable, str(path)], check=True) + print() + + +def main() -> None: + run("verify_dgg.py") + run("verify_chairman.py") + print("All exact certificates passed.") + + +if __name__ == "__main__": + main() diff --git a/2026-rounding-counterexamples/code/verify_chairman.py b/2026-rounding-counterexamples/code/verify_chairman.py new file mode 100644 index 0000000..c4a96af --- /dev/null +++ b/2026-rounding-counterexamples/code/verify_chairman.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +"""Exact certificate verifier for the machine-dependent chairman example. + +The proof is a finite symbolic forcing argument. This script reconstructs the +11-by-15 rational instance and checks every inequality in that certificate +using fractions, including the worst possible effects of assignments outside +the fractional support. +""" + +from __future__ import annotations + +import json +from fractions import Fraction +from pathlib import Path +from typing import Dict, Tuple + +ROOT = Path(__file__).resolve().parents[1] +DATA = ROOT / "data" / "chairman_instance.json" + + +def F(value: str | int) -> Fraction: + return Fraction(str(value)) + + +def main() -> None: + instance = json.loads(DATA.read_text(encoding="utf-8")) + rows = tuple(instance["rows"]) + columns = tuple(instance["columns"]) + eta = F(instance["default_weight"]) + default_x = F(instance["default_fractional_entry"]) + number_of_blocks = int(instance["number_of_blocks"]) + + assert len(rows) == 11 + assert len(columns) == 15 + assert number_of_blocks == 5 + assert eta == Fraction(1, 1000) + + x: Dict[Tuple[str, str], Fraction] = { + (row, column): default_x for row in rows for column in columns + } + d: Dict[Tuple[str, str], Fraction] = { + (row, column): eta for row in rows for column in columns + } + + for k in range(1, number_of_blocks + 1): + A, H = f"A{k}", f"H{k}" + J, K, L = f"J{k}", f"K{k}", f"L{k}" + + x[A, J], x["B", J] = Fraction(19, 24), Fraction(5, 24) + d[A, J], d["B", J] = Fraction(1), Fraction(1) + + x[A, K], x[H, K] = Fraction(1, 2), Fraction(1, 2) + d[A, K], d[H, K] = Fraction(1, 2), Fraction(1) + + x[A, L], x[H, L] = Fraction(23, 48), Fraction(25, 48) + d[A, L], d[H, L] = Fraction(1), Fraction(1) + + # Basic instance checks from the conjecture. + for column in columns: + assert sum(x[row, column] for row in rows) == 1 + assert sum(x[row, column] > 0 for row in rows) == 2 + assert all(weight > 0 for weight in d.values()) + assert max(d.values()) == Fraction(1) + + # At the start of block k, either fresh detector row could have received + # every preceding column outside its support. There are at most 12 such + # columns, and each contributes only -eta. + worst_previous = -12 * eta + + # Assume J_k is not assigned to A_k. If K_k is not assigned to A_k, + # A_k already exceeds the conjectured bound. + k_not_to_A = worst_previous + Fraction(19, 24) + Fraction(1, 4) + assert k_not_to_A > 1 + + # Hence K_k must be assigned to A_k. These are lower bounds immediately + # after K_k, allowing J_k itself to have been assigned to H_k at cost eta. + A_after_forced_K = worst_previous + Fraction(19, 24) - Fraction(1, 4) + H_after_forced_K = worst_previous - eta + Fraction(1, 2) + + # If L_k goes to H_k, A_k is unassigned; otherwise H_k is unassigned. + violation_if_L_to_H = A_after_forced_K + Fraction(23, 48) + violation_if_L_not_to_H = H_after_forced_K + Fraction(25, 48) + detector_lower_bound = min(violation_if_L_to_H, violation_if_L_not_to_H) + + assert violation_if_L_to_H == Fraction(49, 48) - 12 * eta + assert violation_if_L_not_to_H == Fraction(49, 48) - 13 * eta + assert detector_lower_bound == F(instance["claimed_detector_lower_bound"]) + assert detector_lower_bound > 1 + + # Therefore each J_k must be assigned to A_k. The accumulator B is then + # unassigned on all five J-columns and gains 5/24 each time. It can lose + # at most eta on each of the ten detector columns. + accumulator = number_of_blocks * Fraction(5, 24) - 2 * number_of_blocks * eta + assert accumulator == F(instance["claimed_accumulator_lower_bound"]) + assert accumulator == Fraction(619, 600) + assert accumulator > 1 + + print("Machine-dependent chairman instance checks:") + print(f" rows={len(rows)}, columns={len(columns)}, D={max(d.values())}") + print(f" K not assigned to A: lower bound {k_not_to_A}") + print(f" L assigned to H: lower bound {violation_if_L_to_H}") + print(f" L not assigned to H: lower bound {violation_if_L_not_to_H}") + print( + "\nChairman certificate verified: forced accumulator lower bound = " + f"{accumulator} > 1" + ) + + +if __name__ == "__main__": + main() diff --git a/2026-rounding-counterexamples/code/verify_dgg.py b/2026-rounding-counterexamples/code/verify_dgg.py new file mode 100644 index 0000000..f254382 --- /dev/null +++ b/2026-rounding-counterexamples/code/verify_dgg.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""Exact exhaustive verifier for the seven-vertex SSUF counterexample. + +The program intentionally uses only the Python standard library and integer +arithmetic. It reconstructs all source-terminal paths from the arc list, +enumerates every unsplittable routing, and checks the claimed optimum. +""" + +from __future__ import annotations + +import itertools +import json +from collections import defaultdict +from pathlib import Path +from typing import Dict, Iterable, List, Sequence, Tuple + +Arc = Tuple[str, str] +PathType = Tuple[Arc, ...] + +ROOT = Path(__file__).resolve().parents[1] +DATA = ROOT / "data" / "dgg_instance.json" + + +def all_simple_paths( + adjacency: Dict[str, List[str]], source: str, target: str +) -> List[Tuple[str, ...]]: + result: List[Tuple[str, ...]] = [] + + def visit(vertex: str, prefix: Tuple[str, ...]) -> None: + if vertex == target: + result.append(prefix) + return + for successor in adjacency.get(vertex, []): + if successor not in prefix: + visit(successor, prefix + (successor,)) + + visit(source, (source,)) + return result + + +def path_arcs(path: Sequence[str]) -> PathType: + return tuple(zip(path, path[1:])) + + +def main() -> None: + instance = json.loads(DATA.read_text(encoding="utf-8")) + source = instance["source"] + demands = {t: int(d) for t, d in instance["terminals"].items()} + maximum_demand = max(demands.values()) + assert maximum_demand == int(instance["maximum_demand"]) + + arcs: List[Arc] = [] + fractional_load: Dict[Arc, int] = {} + cost: Dict[Arc, int] = {} + adjacency: Dict[str, List[str]] = defaultdict(list) + + for record in instance["arcs"]: + arc = (record["tail"], record["head"]) + assert arc not in fractional_load, f"duplicate arc {arc}" + arcs.append(arc) + fractional_load[arc] = int(record["fractional_load"]) + cost[arc] = int(record["cost"]) + adjacency[arc[0]].append(arc[1]) + + # Verify aggregate fractional-flow conservation. + balance = {v: 0 for v in instance["vertices"]} + for arc in arcs: + u, v = arc + balance[u] -= fractional_load[arc] + balance[v] += fractional_load[arc] + assert balance[source] == -sum(demands.values()) + for terminal, demand in demands.items(): + assert balance[terminal] == demand + for vertex in set(instance["vertices"]) - {source, *demands.keys()}: + assert balance[vertex] == 0 + + # Reconstruct every path from the graph, rather than trusting the supplied + # path decomposition. + paths: Dict[str, List[PathType]] = {} + for terminal in demands: + vertex_paths = all_simple_paths(adjacency, source, terminal) + paths[terminal] = [path_arcs(path) for path in vertex_paths] + assert len(paths[terminal]) == 2, ( + terminal, + [tuple([source] + [v for _, v in p]) for p in paths[terminal]], + ) + + fractional_cost = sum(fractional_load[a] * cost[a] for a in arcs) + assert fractional_cost == int(instance["claimed_fractional_cost"]) == 58 + + terminals = tuple(demands) + routing_records = [] + for choices in itertools.product(*(paths[t] for t in terminals)): + load = {a: 0 for a in arcs} + total_cost = 0 + selected = [] + for terminal, path in zip(terminals, choices): + demand = demands[terminal] + per_unit = sum(cost[a] for a in path) + total_cost += demand * per_unit + selected.append("Z" if per_unit == 0 else "E") + for arc in path: + load[arc] += demand + + violations = { + a: load[a] - (fractional_load[a] + maximum_demand) + for a in arcs + if load[a] > fractional_load[a] + maximum_demand + } + routing_records.append( + { + "selected": "".join(selected), + "cost": total_cost, + "good": not violations, + "violations": violations, + } + ) + + assert len(routing_records) == 8 + good = [record for record in routing_records if record["good"]] + bad = [record for record in routing_records if not record["good"]] + assert len(good) == 4 + assert len(bad) == 4 + minimum_good_cost = min(record["cost"] for record in good) + assert minimum_good_cost == int( + instance["claimed_minimum_cost_subject_to_additive_bound"] + ) == 60 + assert minimum_good_cost > fractional_cost + + # Every routing with two cheap paths has the advertised unit excess on a + # bottleneck arc. The all-cheap routing may violate several arcs. + required_witnesses = { + "ZZE": ("s", "u"), + "ZEZ": ("u", "v"), + "EZZ": ("v", "w"), + } + by_selection = {record["selected"]: record for record in routing_records} + for selection, witness in required_witnesses.items(): + assert by_selection[selection]["violations"][witness] == 1 + + print("All source-terminal paths reconstructed from the graph:") + for terminal in terminals: + rendered = ["->".join([source] + [v for _, v in path]) for path in paths[terminal]] + print(f" {terminal}: {rendered}") + print("\nAll eight routings:") + for record in sorted(routing_records, key=lambda r: r["selected"]): + witness = ", ".join( + f"{u}->{v}:+{excess}" for (u, v), excess in record["violations"].items() + ) or "none" + print( + f" {record['selected']} cost={record['cost']:>2} " + f"good={str(record['good']):<5} violations={witness}" + ) + print( + "\nDGG certificate verified: min good cost = " + f"{minimum_good_cost} > fractional cost = {fractional_cost}" + ) + + +if __name__ == "__main__": + main() diff --git a/2026-rounding-counterexamples/data/chairman_instance.json b/2026-rounding-counterexamples/data/chairman_instance.json new file mode 100644 index 0000000..6d09090 --- /dev/null +++ b/2026-rounding-counterexamples/data/chairman_instance.json @@ -0,0 +1,25 @@ +{ + "title": "Counterexample to machine-dependent weighted chairman assignment", + "rows": ["B", "A1", "H1", "A2", "H2", "A3", "H3", "A4", "H4", "A5", "H5"], + "columns": ["J1", "K1", "L1", "J2", "K2", "L2", "J3", "K3", "L3", "J4", "K4", "L4", "J5", "K5", "L5"], + "default_fractional_entry": "0", + "default_weight": "1/1000", + "maximum_weight": "1", + "block_template": { + "Jk": { + "fractional_entries": {"Ak": "19/24", "B": "5/24"}, + "exceptional_weights": {"Ak": "1", "B": "1"} + }, + "Kk": { + "fractional_entries": {"Ak": "1/2", "Hk": "1/2"}, + "exceptional_weights": {"Ak": "1/2", "Hk": "1"} + }, + "Lk": { + "fractional_entries": {"Ak": "23/48", "Hk": "25/48"}, + "exceptional_weights": {"Ak": "1", "Hk": "1"} + } + }, + "number_of_blocks": 5, + "claimed_detector_lower_bound": "6047/6000", + "claimed_accumulator_lower_bound": "619/600" +} diff --git a/2026-rounding-counterexamples/data/dgg_instance.json b/2026-rounding-counterexamples/data/dgg_instance.json new file mode 100644 index 0000000..0b8e142 --- /dev/null +++ b/2026-rounding-counterexamples/data/dgg_instance.json @@ -0,0 +1,38 @@ +{ + "title": "Planar counterexample to Goemans' cost conjecture", + "source": "s", + "terminals": { + "t1": 15, + "t2": 10, + "t3": 15 + }, + "maximum_demand": 15, + "vertices": ["s", "u", "v", "w", "t1", "t2", "t3"], + "arcs": [ + {"tail": "s", "head": "t1", "fractional_load": 10, "cost": 2}, + {"tail": "s", "head": "t2", "fractional_load": 6, "cost": 3}, + {"tail": "s", "head": "u", "fractional_load": 24, "cost": 0}, + {"tail": "u", "head": "t3", "fractional_load": 10, "cost": 2}, + {"tail": "u", "head": "v", "fractional_load": 14, "cost": 0}, + {"tail": "v", "head": "t1", "fractional_load": 5, "cost": 0}, + {"tail": "v", "head": "w", "fractional_load": 9, "cost": 0}, + {"tail": "w", "head": "t2", "fractional_load": 4, "cost": 0}, + {"tail": "w", "head": "t3", "fractional_load": 5, "cost": 0} + ], + "fractional_path_decomposition": { + "t1": [ + {"amount": 10, "path": ["s", "t1"]}, + {"amount": 5, "path": ["s", "u", "v", "t1"]} + ], + "t2": [ + {"amount": 6, "path": ["s", "t2"]}, + {"amount": 4, "path": ["s", "u", "v", "w", "t2"]} + ], + "t3": [ + {"amount": 10, "path": ["s", "u", "t3"]}, + {"amount": 5, "path": ["s", "u", "v", "w", "t3"]} + ] + }, + "claimed_fractional_cost": 58, + "claimed_minimum_cost_subject_to_additive_bound": 60 +} diff --git a/2026-rounding-counterexamples/figures/chairman_gadget.tex b/2026-rounding-counterexamples/figures/chairman_gadget.tex new file mode 100644 index 0000000..96165ee --- /dev/null +++ b/2026-rounding-counterexamples/figures/chairman_gadget.tex @@ -0,0 +1,36 @@ +% Requires tikz libraries arrows.meta, positioning. +\begin{tikzpicture}[ + >=Stealth, + col/.style={draw,rounded corners=2pt,align=center,minimum width=31mm,minimum height=17mm,font=\small}, + outcome/.style={draw,align=center,inner sep=4pt,font=\scriptsize}, + arr/.style={->,line width=.8pt}, + note/.style={font=\scriptsize,align=center} +] + \node[col] (J) at (0,0) + {$J_k$\\$x_A=19/24,\ x_B=5/24$\\$d_A=d_B=1$}; + \node[col,right=20mm of J] (K) + {$K_k$\\$x_A=x_H=1/2$\\$d_A=1/2,\ d_H=1$}; + \node[col,right=20mm of K] (L) + {$L_k$\\$x_A=23/48,\ x_H=25/48$\\$d_A=d_H=1$}; + + \draw[arr] (J) -- node[above,note] {$J_k\not\to A_k$} (K); + \draw[arr] (K) -- node[above,note] {forced: $K_k\to A_k$} (L); + + \node[outcome,above=10mm of K] (badK) + {$K_k\not\to A_k$\\$\Delta_{A_k}\ge 25/24-12\eta>1$}; + \draw[arr] (K) -- (badK); + + \node[outcome,above=10mm of L,xshift=18mm] (badLH) + {$L_k\to H_k$\\$\Delta_{A_k}\ge49/48-12\eta>1$}; + \node[outcome,below=10mm of L,xshift=18mm] (badLnH) + {$L_k\not\to H_k$\\$\Delta_{H_k}\ge49/48-13\eta>1$}; + \draw[arr] (L) -- (badLH); + \draw[arr] (L) -- (badLnH); + + \node[outcome,below=12mm of J] (forced) + {therefore $J_k\to A_k$\\accumulator gains $5/24$}; + \draw[arr] (J) -- node[left,note] {only surviving choice} (forced); + + \node[note,below=14mm of K] + {Five blocks: $\Delta_B\ge 5(5/24)-10(1/1000)=619/600>1$.}; +\end{tikzpicture} diff --git a/2026-rounding-counterexamples/figures/dgg_network.tex b/2026-rounding-counterexamples/figures/dgg_network.tex new file mode 100644 index 0000000..0fd618a --- /dev/null +++ b/2026-rounding-counterexamples/figures/dgg_network.tex @@ -0,0 +1,34 @@ +% Requires tikz libraries arrows.meta, positioning. +\begin{tikzpicture}[ + >=Stealth, + vertex/.style={circle,draw,minimum size=7mm,inner sep=1pt,font=\small}, + terminal/.style={rectangle,draw,rounded corners=1pt,minimum width=9mm,minimum height=7mm,font=\small}, + arc/.style={->,line width=.75pt}, + bottleneck/.style={->,line width=1.8pt}, + lab/.style={fill=white,inner sep=1.2pt,font=\scriptsize} +] + \node[vertex] (s) at (-4,0) {$s$}; + \node[vertex] (u) at (4,0) {$u$}; + \node[vertex] (v) at (0,4) {$v$}; + \node[vertex] (w) at (0,1.4) {$w$}; + \node[terminal] (t1) at (-2,2) {$t_1$}; + \node[terminal] (t2) at (-2,.7) {$t_2$}; + \node[terminal] (t3) at (2,.7) {$t_3$}; + + \draw[bottleneck] (s) -- node[lab,below] {$x=24,\ c=0$} (u); + \draw[bottleneck] (u) -- node[lab,right,pos=.55] {$x=14,\ c=0$} (v); + \draw[bottleneck] (v) -- node[lab,right] {$x=9,\ c=0$} (w); + + \draw[arc] (s) -- node[lab,left] {$10,2$} (t1); + \draw[arc] (v) -- node[lab,right] {$5,0$} (t1); + \draw[arc] (s) -- node[lab,below] {$6,3$} (t2); + \draw[arc] (w) -- node[lab,above] {$4,0$} (t2); + \draw[arc] (u) -- node[lab,below] {$10,2$} (t3); + \draw[arc] (w) -- node[lab,above] {$5,0$} (t3); + + \node[font=\scriptsize,below=1mm of t1] {$d_1=15$}; + \node[font=\scriptsize,below=1mm of t2] {$d_2=10$}; + \node[font=\scriptsize,below=1mm of t3] {$d_3=15$}; + \node[font=\scriptsize,align=center] at (0,-.7) + {arc labels are $(x_a,c_a)$; heavy arcs are the three conflict witnesses}; +\end{tikzpicture} diff --git a/2026-rounding-counterexamples/figures/dgg_obstruction.tex b/2026-rounding-counterexamples/figures/dgg_obstruction.tex new file mode 100644 index 0000000..a50714a --- /dev/null +++ b/2026-rounding-counterexamples/figures/dgg_obstruction.tex @@ -0,0 +1,27 @@ +% Requires tikz libraries arrows.meta, positioning. +\begin{tikzpicture}[ + >=Stealth, + choice/.style={circle,draw,minimum size=12mm,font=\small}, + witness/.style={font=\scriptsize,fill=white,inner sep=1pt}, + box/.style={draw,rounded corners=2pt,align=center,inner sep=5pt,font=\small} +] + \node[choice] (z1) at (0,2.1) {$Z_1$}; + \node[choice] (z2) at (-2,0) {$Z_2$}; + \node[choice] (z3) at (2,0) {$Z_3$}; + \draw[line width=1.1pt] (z1) -- node[witness,left] {$u\!\to\!v$} (z3); + \draw[line width=1.1pt] (z1) -- node[witness,right] {$s\!\to\!u$} (z2); + \draw[line width=1.1pt] (z2) -- node[witness,below] {$v\!\to\!w$} (z3); + + \node[box,right=18mm of z3] (integral) + {capacity-good integral routings\\[1mm] + $z_1+z_2+z_3\le 1$}; + \node[box,below=7mm of integral] (fractional) + {fractional cheap-path marginals\\[1mm] + $\frac13+\frac25+\frac13=\frac{16}{15}>1$}; + \draw[->,line width=.9pt] (integral) -- node[right,font=\scriptsize] + {violated facet} (fractional); + + \node[box,below=10mm of z2,xshift=12mm] (cost) + {$c^\mathsf{T}x=58$\\[1mm] + $\min\{c^\mathsf{T}y:y\le x+D\}=60$}; +\end{tikzpicture} diff --git a/2026-rounding-counterexamples/figures/graphical_abstract.tex b/2026-rounding-counterexamples/figures/graphical_abstract.tex new file mode 100644 index 0000000..d0111d1 --- /dev/null +++ b/2026-rounding-counterexamples/figures/graphical_abstract.tex @@ -0,0 +1,26 @@ +\begin{center} +\begin{tikzpicture}[ + >=Stealth, + stage/.style={draw,rounded corners=2pt,align=center,minimum height=17mm,minimum width=34mm,font=\small}, + result/.style={draw,double,rounded corners=2pt,align=center,minimum height=17mm,minimum width=36mm,font=\small}, + arr/.style={->,line width=1pt} +] + \node[stage] (flow) at (0,0) + {fractional SSUF\\$c^\mathsf{T}x=58$}; + \node[stage] (triangle) at (4.4,0) + {three cheap paths\\$z_1+z_2+z_3\le1$}; + \node[result] (gap) at (8.8,0) + {capacity-good routing\\cost $\ge60$}; + \draw[arr] (flow) -- node[above,font=\scriptsize] {$p=(1/3,2/5,1/3)$} (triangle); + \draw[arr] (triangle) -- node[above,font=\scriptsize] {violated facet} (gap); + + \node[stage] (chair) at (0,-2.5) + {machine-dependent\\prefix discrepancy}; + \node[stage] (force) at (4.4,-2.5) + {five forcing blocks\\$J_k\to A_k$}; + \node[result] (acc) at (8.8,-2.5) + {accumulator\\$619/600>1$}; + \draw[arr] (chair) -- node[above,font=\scriptsize] {three-column gadget} (force); + \draw[arr] (force) -- node[above,font=\scriptsize] {$5(5/24)-10/1000$} (acc); +\end{tikzpicture} +\end{center} diff --git a/2026-rounding-counterexamples/generated-pdfs/chairman-counterexample.pdf b/2026-rounding-counterexamples/generated-pdfs/chairman-counterexample.pdf new file mode 100644 index 0000000..63622b0 Binary files /dev/null and b/2026-rounding-counterexamples/generated-pdfs/chairman-counterexample.pdf differ diff --git a/2026-rounding-counterexamples/generated-pdfs/dgg-counterexample.pdf b/2026-rounding-counterexamples/generated-pdfs/dgg-counterexample.pdf new file mode 100644 index 0000000..e2cdb76 Binary files /dev/null and b/2026-rounding-counterexamples/generated-pdfs/dgg-counterexample.pdf differ diff --git a/2026-rounding-counterexamples/generated-pdfs/overview.pdf b/2026-rounding-counterexamples/generated-pdfs/overview.pdf new file mode 100644 index 0000000..8d6efd8 Binary files /dev/null and b/2026-rounding-counterexamples/generated-pdfs/overview.pdf differ diff --git a/2026-rounding-counterexamples/papers/chairman-counterexample.tex b/2026-rounding-counterexamples/papers/chairman-counterexample.tex new file mode 100644 index 0000000..b78b372 --- /dev/null +++ b/2026-rounding-counterexamples/papers/chairman-counterexample.tex @@ -0,0 +1,295 @@ +\documentclass[11pt]{article} + +\usepackage[a4paper,margin=29mm]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{array,booktabs} +\usepackage{microtype} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage[numbers,sort&compress]{natbib} +\usepackage[hidelinks]{hyperref} + +\newtheorem{theorem}{Theorem} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{lemma}[theorem]{Lemma} +\theoremstyle{definition} +\newtheorem{conjecture}[theorem]{Conjecture} +\newtheorem{remark}[theorem]{Remark} + +\newcommand{\R}{\mathbb{R}} +\newcommand{\disc}{\Delta} + +\title{Machine-Dependent Weighted Chairman Assignment:\\ +Counterexamples to Two Conjectures} +\author{Anonymous for review} +\date{23 July 2026} + +\begin{document} +\maketitle + +\begin{abstract} +Liu and Reis conjectured that every fractional assignment with positive +machine-dependent weights admits an integral assignment whose discrepancy on +every row and every prefix is at most the largest weight. We give an exact +rational counterexample with $11$ rows and $15$ columns. Every fractional +column has support two, all weights belong to +$\{1/1000,1/2,1\}$, and the largest weight is one. A three-column detector +gadget forces one decision in each of five blocks. The five forced decisions +make an accumulator row attain discrepancy at least +$619/600>1$. The proof allows integral assignments outside the fractional +support, and therefore refutes the unrestricted machine-dependent conjecture +itself as well as the stronger unified support-preserving formulation. +\end{abstract} + +\section{Introduction} + +Let $x\in[0,1]^{m\times n}$ be a fractional assignment with +\[ + \sum_{i=1}^m x_{ij}=1\qquad(j=1,\ldots,n). +\] +An integral assignment $y\in\{0,1\}^{m\times n}$ satisfies the same column +sums. Given positive machine-dependent weights $d_{ij}$, define the +row-prefix discrepancy +\[ + \disc_i(t)=\sum_{j=1}^t d_{ij}(x_{ij}-y_{ij}). +\] +Liu and Reis proposed the following extension of the weighted chairman +assignment problem \citep{LiuReis2026}. + +\begin{conjecture}[Liu--Reis, Conjecture 19]\label{conj:machine} +For every fractional assignment $x$ and every positive weight matrix $d$, +there is an integral assignment $y$ such that +\[ + |\disc_i(t)|\le D:=\max_{i,j}d_{ij} + \qquad\text{for every row $i$ and prefix $t$.} +\] +\end{conjecture} + +Their Conjecture 21 gives a unified statement with support preservation and +more general prescribed integral column sums. We show that already +Conjecture~\ref{conj:machine} is false. + +\begin{theorem}\label{thm:main} +There is a rational instance with $m=11$, $n=15$, and $D=1$ for which every +integral assignment $y$ has +\[ + |\disc_i(t)|>1 +\] +for some row $i$ and prefix $t$. Every fractional column has support two and +every weight is strictly positive. +\end{theorem} + +Since the theorem excludes all integral assignments, including those outside +the support of $x$, it immediately implies the following. + +\begin{corollary}\label{cor:unified} +The unified support-preserving statement of Liu and Reis (Conjecture 21) is +false, already in the one-winner-per-column case. +\end{corollary} + +\section{The instance} + +The rows are +\[ + B,A_1,H_1,A_2,H_2,\ldots,A_5,H_5, +\] +and the columns occur in five consecutive blocks +\[ + J_k,K_k,L_k\qquad(k=1,\ldots,5). +\] +Set +\[ + \eta=\frac1{1000}. +\] +Every fractional entry not listed below is zero, and every weight not listed +below equals $\eta$. Thus all weights are strictly positive. + +For each block $k$, define the nonzero fractional entries and exceptional +weights by Table~\ref{tab:block}. + +\begin{table}[ht] +\centering +\caption{One block of the counterexample. Here $A=A_k$ and $H=H_k$.} +\label{tab:block} +\begin{tabular}{@{}lll@{}} +\toprule +column & nonzero fractional entries & exceptional weights \\ +\midrule +$J_k$ & $x_{A,J_k}=19/24$, $x_{B,J_k}=5/24$ + & $d_{A,J_k}=d_{B,J_k}=1$ \\ +$K_k$ & $x_{A,K_k}=1/2$, $x_{H,K_k}=1/2$ + & $d_{A,K_k}=1/2$, $d_{H,K_k}=1$ \\ +$L_k$ & $x_{A,L_k}=23/48$, $x_{H,L_k}=25/48$ + & $d_{A,L_k}=d_{H,L_k}=1$ \\ +\bottomrule +\end{tabular} +\end{table} + +Every column sums to one, every column has support two, and +\[ + d_{ij}\in\left\{\frac1{1000},\frac12,1\right\}, + \qquad D=1. +\] + +\section{The forcing gadget} + +Fix a block $k$. Before column $J_k$, the fresh rows $A_k$ and $H_k$ have +zero fractional entries in every preceding column. An integral assignment +may nevertheless have assigned earlier columns to them. There are at most +$3(k-1)\le12$ earlier columns, and each such off-support assignment contributes +exactly $-\eta$. Hence immediately before $J_k$, +\begin{equation}\label{eq:fresh} + -12\eta\le\disc_{A_k}\le0, + \qquad + -12\eta\le\disc_{H_k}\le0. +\end{equation} + +\begin{lemma}\label{lem:force} +Every integral assignment satisfying $|\disc_i(t)|\le1$ on all rows and +prefixes must assign $J_k$ to $A_k$. +\end{lemma} + +\begin{proof} +Suppose that $J_k$ is not assigned to $A_k$. Then $A_k$ is unassigned on +$J_k$ and gains $19/24$. By \eqref{eq:fresh}, immediately after $J_k$, +\begin{equation}\label{eq:A-after-J} + \disc_{A_k}\ge-12\eta+\frac{19}{24}. +\end{equation} +The row $H_k$ may itself receive $J_k$ outside its support, which costs only +$\eta$, so +\begin{equation}\label{eq:H-after-J} + \disc_{H_k}\ge-13\eta. +\end{equation} + +Consider $K_k$. If it is not assigned to $A_k$, then $A_k$ is unassigned +and gains +\[ + d_{A_k,K_k}x_{A_k,K_k}=\frac12\cdot\frac12=\frac14. +\] +Together with \eqref{eq:A-after-J}, this gives +\[ + \disc_{A_k}\ge-12\eta+\frac{19}{24}+\frac14 + =\frac{25}{24}-\frac{12}{1000}>1. +\] +Thus a surviving assignment must send $K_k$ to $A_k$. + +After that forced choice, +\begin{align} + \disc_{A_k}&\ge-12\eta+\frac{19}{24}-\frac14 + =-12\eta+\frac{13}{24},\label{eq:A-after-K}\\ + \disc_{H_k}&\ge-13\eta+\frac12.\label{eq:H-after-K} +\end{align} + +It remains to assign $L_k$. If $L_k$ is assigned to $H_k$, then $A_k$ is +unassigned and gains $23/48$. By \eqref{eq:A-after-K}, +\[ + \disc_{A_k}\ge-12\eta+\frac{13}{24}+\frac{23}{48} + =\frac{49}{48}-\frac{12}{1000}>1. +\] +If $L_k$ is not assigned to $H_k$, then $H_k$ is unassigned and gains +$25/48$. By \eqref{eq:H-after-K}, +\[ + \disc_{H_k}\ge-13\eta+\frac12+\frac{25}{48} + =\frac{49}{48}-\frac{13}{1000} + =\frac{6047}{6000}>1. +\] +Every possible assignment of $L_k$ therefore violates the unit bound. The +assumption $J_k\not\to A_k$ was impossible. +\end{proof} + +\begin{figure}[ht] +\centering +\resizebox{\textwidth}{!}{\input{../figures/chairman_gadget.tex}} +\caption{The three-column forcing gadget. The inequalities include the +worst possible losses from assignments outside the fractional support.} +\label{fig:gadget} +\end{figure} + +\section{Accumulator contradiction} + +Apply Lemma~\ref{lem:force} independently to all five blocks. Every +hypothetical discrepancy-good assignment must satisfy +\[ + J_k\longmapsto A_k\qquad(k=1,\ldots,5). +\] +The accumulator row $B$ is therefore unassigned on every $J_k$. Since +$x_{B,J_k}=5/24$ and $d_{B,J_k}=1$, each block increases its discrepancy by +$5/24$. + +The only possible decreases occur when one of the ten detector columns +$K_k,L_k$ is assigned to $B$. On each such column $x_{B,j}=0$ and +$d_{B,j}=\eta$, so the decrease is at most $\eta$. At the final prefix, +\[ + \disc_B(15) + \ge 5\cdot\frac5{24}-10\eta + =\frac{25}{24}-\frac1{100} + =\frac{619}{600}>1. +\] +This contradiction proves Theorem~\ref{thm:main}. + +\section{A parametric family} + +The constants are instances of a simple open parameter region. In one +block, choose +\[ +\begin{array}{c|cc|cc} + & x_A & x_H\text{ or }x_B & d_A & d_H\text{ or }d_B\\ +\hline +J & 1-p & p\ (B) & 1 & 1\\ +K & 1/2 & 1/2\ (H) & a & 1\\ +L & 1-q & q\ (H) & 1 & 1. +\end{array} +\] +The detector works, before the small $\eta$ corrections, whenever +\[ + \frac a2>p, + \qquad + \frac121$. Once these inequalities are strict, $\eta>0$ can be chosen small +enough to absorb every off-support assignment. + +Our rational choice is +\[ + N=5,\qquad p=\frac5{24},\qquad a=\frac12, + \qquad q=\frac{25}{48},\qquad \eta=\frac1{1000}. +\] +The ideal margins are respectively $1/24,1/48,1/48$, while the accumulator +margin is $1/24$. + +\section{Discussion} + +The counterexample exploits exactly what changes when a common job weight is +replaced by machine-dependent weights. With a common weight, assigning a job +redistributes a conserved amount among rows. Here the $K$ column has weight +$1/2$ on $A_k$ but weight $1$ on $H_k$, permitting the detector to amplify a +prefix imbalance. The small value $\eta$ keeps every off-support weight +positive without allowing unsupported choices to repair the forcing chain. + +The result does not address the ordinary weighted-carpooling conjecture, in +which a column has one common weight across all rows. It rules out the +machine-dependent extension and every stronger statement containing it. + +\section*{Reproducibility and disclosure} + +The accompanying repository contains the full $11\times15$ rational instance +as JSON and an exact `Fraction`-based verifier for every inequality in the +forcing certificate. A generative AI system assisted with exploration, +checking, code drafting, and exposition. It is not an author. The human +authors assume responsibility for independent verification, priority, +attribution, and the final submitted text. + +\bibliographystyle{abbrvnat} +\bibliography{references} + +\end{document} diff --git a/2026-rounding-counterexamples/papers/dgg-counterexample.tex b/2026-rounding-counterexamples/papers/dgg-counterexample.tex new file mode 100644 index 0000000..70b8db8 --- /dev/null +++ b/2026-rounding-counterexamples/papers/dgg-counterexample.tex @@ -0,0 +1,372 @@ +\documentclass[11pt]{article} + +\usepackage[a4paper,margin=29mm]{geometry} +\usepackage{amsmath,amssymb,amsthm,mathtools} +\usepackage{array,booktabs} +\usepackage{microtype} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage[numbers,sort&compress]{natbib} +\usepackage[hidelinks]{hyperref} + +\newtheorem{theorem}{Theorem} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\newtheorem{lemma}[theorem]{Lemma} +\theoremstyle{definition} +\newtheorem{conjecture}[theorem]{Conjecture} +\newtheorem{remark}[theorem]{Remark} + +\newcommand{\R}{\mathbb{R}} +\newcommand{\1}{\mathbf{1}} +\newcommand{\cost}{\operatorname{cost}} + +\title{A Planar Counterexample to Goemans' Cost Conjecture\\ +for Single-Source Unsplittable Flow} +\author{Anonymous for review} +\date{23 July 2026} + +\begin{document} +\maketitle + +\begin{abstract} +We give an explicit counterexample to Goemans' cost conjecture for +single-source unsplittable flow. The instance is a planar acyclic digraph +with seven vertices, nine arcs, and three terminals. A feasible fractional +flow has cost $58$, but every unsplittable routing whose load on each arc is +at most the fractional load plus the maximum demand has cost at least $60$. +Each terminal has exactly two source--terminal paths, so the proof reduces to +an exhaustive eight-routing certificate. The obstruction is the +stable-set inequality of a triangle: the three inexpensive path choices are +pairwise capacity-incompatible, while their fractional marginals sum to +$16/15$. The underlying undirected graph is a subdivision of $K_4$, placing +the example immediately beyond the known series-parallel positive result. +A parametric version also gives a planar lower bound of $9/8$ on the best +universal coefficient for cost-preserving additive congestion. +\end{abstract} + +\section{Introduction} + +Let $G=(V,A)$ be a directed graph with source $s$, terminals +$t_1,\ldots,t_k$, positive demands $d_1,\ldots,d_k$, and nonnegative per-unit +arc costs $c\in\R_+^A$. A feasible fractional flow $x\in\R_+^A$ routes all +demands from $s$ to their terminals. An unsplittable flow chooses one +$s$--$t_i$ path $P_i$ for each terminal and induces the load +\[ + y_a=\sum_{i:a\in P_i}d_i. +\] +Write $D=\max_i d_i$. + +The theorem of Dinitz, Garg, and Goemans guarantees an unsplittable routing +with $y_a\le x_a+D$ on every arc, without a cost condition +\citep{DinitzGargGoemans1999}. Goemans' cost conjecture asks whether the same +additive guarantee can always be obtained without increasing cost; it has +motivated work on minimum-cost and convex-decomposition variants for roughly +a quarter century \citep{Skutella2002,MartensSalazarSkutella2007}. + +\begin{conjecture}[Goemans' cost conjecture]\label{conj:goemans} +For every feasible fractional single-source flow $x$ and every nonnegative +arc-cost vector $c$, there exists an unsplittable flow $y$ such that +\[ + y_a\le x_a+D\quad(a\in A), + \qquad + c^\mathsf{T}y\le c^\mathsf{T}x. +\] +\end{conjecture} + +Recent progress includes simultaneous upper and lower bounds in special +cases \citep{MorellSkutella2022}, an additive $2D$ cost-preserving theorem for +planar digraphs \citep{TraubVargasKochZenklusen2024}, and the exact +convex-decomposition statement for series-parallel digraphs +\citep{AlmoghrabiSkutellaWarode2024}. A 2026 paper still described +Conjecture~\ref{conj:goemans} as famous and reported only limited general +progress \citep{SwamyTraubVargasKochZenklusen2026}. + +Our main result is the following finite certificate. + +\begin{theorem}\label{thm:main} +Conjecture~\ref{conj:goemans} is false. It fails on a planar acyclic digraph +with seven vertices, nine arcs, and three terminals. In the displayed +instance, +\[ + c^\mathsf{T}x=58 + \quad\text{but}\quad + \min\{c^\mathsf{T}y:y\text{ unsplittable},\ y\le x+D\1\}=60. +\] +\end{theorem} + +The graph is small enough that every path and every routing can be listed. +The proof therefore has no dependence on a path decomposition algorithm, +floating-point computation, or an optimization solver. + +\section{The instance} + +Let +\[ + V=\{s,u,v,w,t_1,t_2,t_3\}, + \qquad + (d_1,d_2,d_3)=(15,10,15), + \qquad D=15. +\] +The arcs, fractional loads, and costs are shown in +Table~\ref{tab:instance} and Figure~\ref{fig:network}. + +\begin{table}[ht] +\centering +\caption{The counterexample. Arc costs are nonnegative per-unit costs.} +\label{tab:instance} +\begin{tabular}{@{}lrr@{}} +\toprule +arc $a$ & $x_a$ & $c_a$ \\ +\midrule +$s\to t_1$ & 10 & 2 \\ +$s\to t_2$ & 6 & 3 \\ +$s\to u$ & 24 & 0 \\ +$u\to t_3$ & 10 & 2 \\ +$u\to v$ & 14 & 0 \\ +$v\to t_1$ & 5 & 0 \\ +$v\to w$ & 9 & 0 \\ +$w\to t_2$ & 4 & 0 \\ +$w\to t_3$ & 5 & 0 \\ +\bottomrule +\end{tabular} +\end{table} + +\begin{figure}[ht] +\centering +\input{../figures/dgg_network.tex} +\caption{A planar embedding. Each arc label is $(x_a,c_a)$, with the +fractional load first. The heavy arcs witness the three pairwise conflicts.} +\label{fig:network} +\end{figure} + +The fractional flow has the path decomposition +\[ +\begin{array}{c|cc} + & \text{first path} & \text{second path}\\ +\hline + t_1 & 10\,[s,t_1] & 5\,[s,u,v,t_1]\\ + t_2 & 6\,[s,t_2] & 4\,[s,u,v,w,t_2]\\ + t_3 & 10\,[s,u,t_3] & 5\,[s,u,v,w,t_3]. +\end{array} +\] +Conservation is immediate: +\[ +24=10+14,\qquad 14=5+9,\qquad 9=4+5, +\] +and the terminal inflows are $15,10,15$. +Its cost is +\[ + c^\mathsf{T}x=2\cdot10+3\cdot6+2\cdot10=58. +\] + +\section{Exhaustive proof} + +Each terminal has exactly two source--terminal paths: +\[ +\begin{array}{lll} +E_1=s\to t_1, +&\qquad& +Z_1=s\to u\to v\to t_1,\\[1mm] +E_2=s\to t_2, +&& +Z_2=s\to u\to v\to w\to t_2,\\[1mm] +E_3=s\to u\to t_3, +&& +Z_3=s\to u\to v\to w\to t_3. +\end{array} +\] +The paths $Z_i$ have zero cost. Each $E_i$ has total integral cost $30$: +\[ +15c(E_1)=30,\qquad 10c(E_2)=30,\qquad 15c(E_3)=30. +\] + +\begin{lemma}\label{lem:conflict} +An unsplittable routing satisfies $y_a\le x_a+D$ on every arc if and only if +it uses at most one of $Z_1,Z_2,Z_3$. +\end{lemma} + +\begin{proof} +If $Z_1$ and $Z_2$ are selected, terminal $t_3$ uses $s\to u$ on either of +its two paths. Hence +\[ + y_{su}=15+10+15=40>24+15=x_{su}+D. +\] +If $Z_1$ and $Z_3$ are selected, then +\[ + y_{uv}=15+15=30>14+15=x_{uv}+D. +\] +If $Z_2$ and $Z_3$ are selected, then +\[ + y_{vw}=10+15=25>9+15=x_{vw}+D. +\] +Thus a good routing uses at most one $Z_i$. + +Conversely, when at most one $Z_i$ is used, the shared loads satisfy +\[ + y_{su}\le30<39,\qquad y_{uv}\le15<29,\qquad y_{vw}\le15<24. +\] +Every other arc is used by at most one demand and therefore has load at most +$D\le x_a+D$. Hence the routing is good. +\end{proof} + +Lemma~\ref{lem:conflict} implies that every good routing uses at least two +expensive paths and therefore costs at least $60$. This proves +Theorem~\ref{thm:main}. For completeness, Table~\ref{tab:routings} lists all +eight routings. + +\begin{table}[ht] +\centering +\caption{All unsplittable routings. The letters correspond to the path +choices for $(t_1,t_2,t_3)$.} +\label{tab:routings} +\begin{tabular}{@{}cccl@{}} +\toprule +routing & cost & good? & witness if bad \\ +\midrule +$EEE$ & 90 & yes & --- \\ +$EEZ$ & 60 & yes & --- \\ +$EZE$ & 60 & yes & --- \\ +$EZZ$ & 30 & no & $v\to w$: $25>24$ \\ +$ZEE$ & 60 & yes & --- \\ +$ZEZ$ & 30 & no & $u\to v$: $30>29$ \\ +$ZZE$ & 30 & no & $s\to u$: $40>39$ \\ +$ZZZ$ & 0 & no & all three heavy arcs \\ +\bottomrule +\end{tabular} +\end{table} + +\section{The stable-set geometry} + +Let $z_i$ be the indicator of choosing $Z_i$. By +Lemma~\ref{lem:conflict}, every good integral routing satisfies the triangle +stable-set inequality +\[ + z_1+z_2+z_3\le1. +\] +The fractional cheap-path marginals are +\[ + p=\left(\frac5{15},\frac4{10},\frac5{15}\right) + =\left(\frac13,\frac25,\frac13\right), +\] +so +\[ + p_1+p_2+p_3=\frac{16}{15}>1. +\] +Thus the fractional point lies outside the convex hull of capacity-good +routings. The cost vector is exactly a nonnegative separator of this violated +facet. + +\begin{figure}[ht] +\centering +\input{../figures/dgg_obstruction.tex} +\caption{The counterexample is the stable-set obstruction of a triangle.} +\label{fig:obstruction} +\end{figure} + +This interpretation also shows that the instance rules out any proposed +convex decomposition of $x$ into unsplittable flows satisfying simultaneous +upper and lower $D$-bounds. Such flows are a subset of the upper-good +routings, all of which have cost at least $60$, whereas the average cost in a +decomposition of $x$ would have to be $58$. This does not refute the costless +existence of one two-sided-good routing. + +\section{Strictly positive costs} + +The zero-cost arcs are convenient but inessential. + +\begin{proposition}\label{prop:positive} +The same graph, demands, and fractional flow give a counterexample with +strictly positive integer costs on every arc. +\end{proposition} + +\begin{proof} +Set +\[ + c_{st_1}=12,\qquad c_{st_2}=18,\qquad c_{ut_3}=12, +\] +and give every other arc cost $1$. Direct calculation gives +\[ + c^\mathsf{T}x=409. +\] +The four good routings are $EEE,EEZ,EZE,ZEE$. Their costs are respectively +$555,420,415,420$, so the minimum good cost is $415>409$. +\end{proof} + +\section{A planar lower-bound family} + +The construction belongs to a simple rational family. Normalize $D=1$, +set +\[ + d_1=d_3=1,\qquad d_2=b, +\] +and let the cheap-path probabilities be $r,q,r$. The three possible cheap +pairs require additive deviations +\[ + A_{12}=A_{23}=1+b(1-q)-r, + \qquad + A_{13}=2-2r-bq. +\] +If every expensive integral path has total cost one, the fractional cost is +$3-(2r+q)$. Whenever $2r+q>1$, every no-more-expensive integral routing must +use at least two cheap paths. + +Choose +\[ + b=\frac34,\qquad r=\frac14,\qquad q=\frac12+\varepsilon. +\] +Then $2r+q=1+\varepsilon$ and +\[ + A_{12}=A_{13}=A_{23} + =\frac98-\frac34\varepsilon. +\] +We obtain the following quantitative consequence. + +\begin{corollary}\label{cor:planar} +Let $\alpha_{\rm planar}$ be the infimum of coefficients $\alpha$ such that +every planar acyclic single-source fractional flow admits a no-more-expensive +unsplittable routing satisfying $y_a\le x_a+\alpha D$ for every arc. Then +\[ + \frac98\le \alpha_{\rm planar}\le2. +\] +\end{corollary} + +\begin{proof} +The lower bound follows by sending $\varepsilon\downarrow0$ in the family +above. The upper bound is the planar cost theorem of +\citet{TraubVargasKochZenklusen2024}. +\end{proof} + +\section{Topology and implications} + +Ignoring directions, the graph is a subdivision of $K_4$. The branch +vertices are $s,u,v,w$, while $t_1,t_2,t_3$ subdivide the edges $sv,sw,uw$. +Thus the counterexample is planar but lies immediately outside the +series-parallel topology for which the exact convex-decomposition result is +known \citep{AlmoghrabiSkutellaWarode2024}. + +The classical additive-$D$ existence theorem remains valid: for example, +$EEZ$ is capacity-good. The failure is specifically the simultaneous demand +for additive error $D$ and no increase in cost. The example therefore +separates three thresholds: +\[ +\begin{array}{ccl} +\text{cost ignored} &:& D\text{ is achievable};\\ +\text{cost preserved, planar} &:& D\text{ is false and }2D\text{ is known};\\ +\text{this family} &:& (9/8-o(1))D\text{ is necessary}. +\end{array} +\] + +\section*{Reproducibility and disclosure} + +The accompanying repository contains the exact instance as JSON and a +standard-library Python verifier that reconstructs all paths and checks all +eight routings using integer arithmetic. A generative AI system assisted +with exploration, checking, code drafting, and exposition. It is not an +author. The human authors assume responsibility for independent +verification, priority, attribution, and the final submitted text. + +\bibliographystyle{abbrvnat} +\bibliography{references} + +\end{document} diff --git a/2026-rounding-counterexamples/papers/overview.tex b/2026-rounding-counterexamples/papers/overview.tex new file mode 100644 index 0000000..1456535 --- /dev/null +++ b/2026-rounding-counterexamples/papers/overview.tex @@ -0,0 +1,141 @@ +\documentclass[11pt]{article} + +\usepackage[a4paper,margin=27mm]{geometry} +\usepackage{amsmath,amssymb} +\usepackage{array,booktabs} +\usepackage{microtype} +\usepackage{tikz} +\usetikzlibrary{arrows.meta,positioning} +\usepackage[numbers,sort&compress]{natbib} +\usepackage[hidelinks]{hyperref} + +\title{Two Exact Counterexamples in Weighted Rounding\\ +Illustrated Research Overview} +\author{Anonymous for review} +\date{23 July 2026} + +\begin{document} +\maketitle + +\begin{abstract} +This note summarizes two exact certificate-based counterexamples: a planar +seven-vertex counterexample to Goemans' cost conjecture for single-source +unsplittable flow, and an $11$-row, $15$-column counterexample to the +machine-dependent weighted-chairman conjecture. Both are accompanied by +standard-library Python verifiers using exact arithmetic. +\end{abstract} + +\input{../figures/graphical_abstract.tex} + +\section{The flow result in one page} + +For demands $(15,10,15)$, the planar acyclic network in +Figure~\ref{fig:network} supports a feasible fractional flow of cost $58$. +Each terminal has one expensive path of total integral cost $30$ and one +zero-cost path. Any pair of zero-cost paths violates one of three arc bounds +by exactly one unit. A capacity-good routing therefore buys at least two +expensive paths and costs at least $60$. + +\begin{figure}[ht] +\centering +\resizebox{.84\textwidth}{!}{\input{../figures/dgg_network.tex}} +\caption{The explicit planar counterexample. Arc labels are +$(\text{fractional load},\text{per-unit cost})$.} +\label{fig:network} +\end{figure} + +The convex-geometric obstruction is the stable-set inequality of a triangle: +\[ + z_1+z_2+z_3\le1, + \qquad + \frac13+\frac25+\frac13=\frac{16}{15}>1. +\] +The example is planar, but its underlying undirected graph is a subdivision +of $K_4$, immediately beyond the series-parallel class for which the exact +positive theorem is known \citep{AlmoghrabiSkutellaWarode2024}. + +A parametric form gives the quantitative planar lower bound +\[ + \frac98\le\alpha_{\rm planar}\le2, +\] +where $\alpha_{\rm planar}D$ is the permitted cost-preserving additive upper +deviation and the upper bound is the planar theorem of +\citet{TraubVargasKochZenklusen2024}. + +\section{The assignment result in one page} + +Liu and Reis conjectured prefix discrepancy at most +$D=\max_{i,j}d_{ij}$ for arbitrary positive machine-dependent weights +\citep{LiuReis2026}. The counterexample repeats the detector shown in +Figure~\ref{fig:gadget} five times. + +\begin{figure}[ht] +\centering +\resizebox{\textwidth}{!}{\input{../figures/chairman_gadget.tex}} +\caption{One forcing block. No support restriction is assumed.} +\label{fig:gadget} +\end{figure} + +Every discrepancy-good assignment is forced to send $J_k$ to $A_k$. Each +such choice contributes $5/24$ to a global accumulator row. The ten detector +columns can repair the accumulator by at most $10/1000$, leaving +\[ + 5\left(\frac5{24}\right)-\frac{10}{1000} + =\frac{619}{600}>1. +\] +Thus the unrestricted machine-dependent conjecture and its stronger unified +support-preserving version are false. + +\section{Why the results matter} + +\begin{table}[ht] +\centering +\caption{Conservative chronology and significance.} +\begin{tabular}{@{}p{25mm}p{44mm}p{70mm}@{}} +\toprule +period & development & significance \\ +\midrule +1998--1999 & Dinitz--Garg--Goemans additive-$D$ theorem +& Establishes optimal cost-free congestion rounding. \\ +2000--2002 & minimum-cost SSUF formulation +& Goemans' simultaneous cost/congestion conjecture enters the literature. \\ +2024 & planar additive-$2D$ cost theorem +& Best known planar upper bound before the present certificate. \\ +2024--2025 & exact series-parallel convex decomposition +& Confirms the roughly 25-year-old conjecture on a nontrivial class. \\ +2026 & present seven-vertex certificate +& Shows the exact $D$ cost guarantee fails even for planar DAGs. \\ +2025--2026 & Liu--Reis machine-dependent conjecture +& Natural extension of weighted chairman assignment. \\ +2026 & present five-block forcing certificate +& Shows machine dependence destroys the unit prefix bound. \\ +\bottomrule +\end{tabular} +\end{table} + +The flow result preserves the classical Dinitz--Garg--Goemans theorem: the +failure occurs only when cost preservation is imposed. The chairman result +preserves the ordinary common-weight problem: the failure occurs only after +weights become row dependent. + +\section{Verification} + +The repository command +\begin{verbatim} +python3 code/verify_all.py +\end{verbatim} +checks the flow graph, reconstructs all six source--terminal paths, enumerates +all eight routings, and checks every rational inequality in the chairman +forcing proof. No floating-point computation or optimization solver is +needed. + +\paragraph{Status.} +These are preprint claims prepared for independent review. Human authors +must verify priority, theorem wording, and the final submission. A +generative AI system assisted with exploration and drafting and is not an +author. + +\bibliographystyle{abbrvnat} +\bibliography{references} + +\end{document} diff --git a/2026-rounding-counterexamples/papers/references.bib b/2026-rounding-counterexamples/papers/references.bib new file mode 100644 index 0000000..e566164 --- /dev/null +++ b/2026-rounding-counterexamples/papers/references.bib @@ -0,0 +1,84 @@ +@article{DinitzGargGoemans1999, + author = {Dinitz, Yefim and Garg, Naveen and Goemans, Michel X.}, + title = {On the Single-Source Unsplittable Flow Problem}, + journal = {Combinatorica}, + volume = {19}, + number = {1}, + pages = {17--41}, + year = {1999}, + doi = {10.1007/s004930050043} +} + +@article{Skutella2002, + author = {Skutella, Martin}, + title = {Approximating the Single Source Unsplittable Min-Cost Flow Problem}, + journal = {Mathematical Programming}, + volume = {91}, + number = {3}, + pages = {493--514}, + year = {2002}, + doi = {10.1007/s101070100260} +} + +@inproceedings{MartensSalazarSkutella2007, + author = {Martens, Marco and Salazar-Gonz{\'a}lez, Juan-Jos{\'e} and Skutella, Martin}, + title = {Convex Combinations of Single Source Unsplittable Flows}, + booktitle = {Algorithms -- ESA 2007}, + series = {Lecture Notes in Computer Science}, + volume = {4698}, + pages = {395--406}, + publisher = {Springer}, + year = {2007}, + doi = {10.1007/978-3-540-75520-3_36} +} + +@article{MorellSkutella2022, + author = {Morell, Sarah and Skutella, Martin}, + title = {Single Source Unsplittable Flows with Arc-Wise Lower and Upper Bounds}, + journal = {Mathematical Programming}, + volume = {192}, + pages = {477--496}, + year = {2022}, + doi = {10.1007/s10107-021-01704-4} +} + +@inproceedings{TraubVargasKochZenklusen2024, + author = {Traub, Vera and Vargas Koch, Laura and Zenklusen, Rico}, + title = {Single-Source Unsplittable Flows in Planar Graphs}, + booktitle = {Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms}, + pages = {639--668}, + publisher = {SIAM}, + year = {2024}, + doi = {10.1137/1.9781611977912.24} +} + +@misc{AlmoghrabiSkutellaWarode2024, + author = {Almoghrabi, Mohammed Majthoub and Skutella, Martin and Warode, Philipp}, + title = {Integer and Unsplittable Multiflows in Series-Parallel Digraphs}, + year = {2024}, + eprint = {2412.05182}, + archivePrefix= {arXiv}, + primaryClass = {cs.DS} +} + +@inproceedings{SwamyTraubVargasKochZenklusen2026, + author = {Swamy, Chaitanya and Traub, Vera and Vargas Koch, Laura and Zenklusen, Rico}, + title = {Unsplittable Cost Flows from Unweighted Error-Bounded Variants}, + booktitle = {2026 SIAM Symposium on Simplicity in Algorithms}, + pages = {512--523}, + publisher = {SIAM}, + year = {2026}, + doi = {10.1137/1.9781611978964.42} +} + +@inproceedings{LiuReis2026, + author = {Liu, Xinyue and Reis, Victor}, + title = {The Weighted Chairman Assignment Problem}, + booktitle = {17th Innovations in Theoretical Computer Science Conference (ITCS 2026)}, + series = {Leibniz International Proceedings in Informatics}, + volume = {362}, + pages = {98:1--98:16}, + publisher = {Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik}, + year = {2026}, + doi = {10.4230/LIPIcs.ITCS.2026.98} +} diff --git a/2026-rounding-counterexamples/research/conversation-thread-verbatim.md b/2026-rounding-counterexamples/research/conversation-thread-verbatim.md new file mode 100644 index 0000000..dc72219 --- /dev/null +++ b/2026-rounding-counterexamples/research/conversation-thread-verbatim.md @@ -0,0 +1,3077 @@ +# Conversation Transcript + +> Scope: all visible User and Assistant messages in this thread, in chronological order. Hidden system/developer instructions, private reasoning, and internal tool payloads are excluded because they are not part of the visible conversation thread. + +--- + +## User + +Construct a counterexample to general (non-planar) case of Dinitz Garg Goemans conjecture. You should do a breakthrough and find a structured counterexample. + +--- + +## Assistant + +## Research conclusion + +I did **not** obtain a valid counterexample, and presenting the construction below as one would be mathematically false. The requested object would disprove a conjecture that is still open in the current literature. + +The exact conjecture asks, for \(D=d_{\max}\), for an unsplittable load vector \(y\) satisfying + +\[ +y_a\le x_a+D\quad\text{for every arc }a, +\qquad +c^{\mathsf T}y\le c^{\mathsf T}x . +\] + +This is precisely Conjecture 1.3 in the supplied paper. fileciteturn0file0L102-L117 The paper’s planar result does **not** prove this exact statement: with costs it obtains additive error \(2D\), rather than \(D\). fileciteturn0file0L190-L205 As of July 2026, the latest SOSA work still describes the general statement as a famous conjecture with only limited progress; the exact result is now known for series-parallel digraphs, but not for arbitrary acyclic digraphs. citeturn344884search0turn344884academia37 + +What follows is the strongest structured attack I found: an exact certificate formulation, a very small **abstract almost-counterexample**, and a rigorous explanation of why its natural graph realization fails. + +--- + +## 1. An exact certificate for a genuine counterexample + +Fix \(G,s,T,d,x\), and let \(\mathcal U\) be the finite set of load vectors of all unsplittable routings. Define the capacity-good routings by + +\[ +\mathcal U(x) + = + \left\{ + y\in\mathcal U: + y_a\le x_a+D\quad\forall a + \right\}. +\] + +Consider the linear program + +\[ +\begin{array}{ll} +\text{maximize} & \delta \\[2mm] +\text{subject to} & +c^{\mathsf T}(y-x)\ge \delta +\qquad\forall y\in\mathcal U(x),\\ +& \displaystyle\sum_{a\in A}c_a=1,\\ +&c_a\ge0\qquad\forall a\in A . +\end{array} +\tag{SEP} +\] + +This is a complete, machine-checkable test: + +\[ +\boxed{\text{\((G,s,T,d,x)\) admits a counterexample cost vector} + \iff \operatorname{opt}(\mathrm{SEP})>0.} +\] + +Indeed, if the optimum is \(\delta>0\), its vector \(c\) satisfies + +\[ +c^{\mathsf T}y + \ge c^{\mathsf T}x+\delta + >c^{\mathsf T}x +\] + +for every capacity-good unsplittable routing. Conversely, any counterexample cost can be normalized so that \(\sum_a c_a=1\), and the minimum gap over the finite set \(\mathcal U(x)\) is strictly positive. + +For an acyclic graph this is also a convex-hull test: + +\[ +\operatorname{opt}(\mathrm{SEP})>0 +\quad\Longleftrightarrow\quad +x\notin\operatorname{conv}\mathcal U(x). +\] + +The reason is that every member of \(\mathcal U(x)\) and \(x\) has the same divergence. If \(x\) were only componentwise above a convex combination of good routings, their difference would be a nonnegative circulation; an acyclic digraph has no nonzero nonnegative circulation. + +Thus a publishable counterexample can be very compactly certified by giving rational data \(G,d,x\) and a rational feasible solution of (SEP) with \(\delta>0\). + +--- + +## 2. A seven-resource structured almost-counterexample + +Take three terminals with demands + +\[ +d_1=1,\qquad d_2=\frac9{10},\qquad d_3=\frac8{10}, +\qquad D=1. +\] + +For each terminal \(i\), introduce two abstract choices \(P_i^0,P_i^1\), and fractionally select each with probability \(1/2\). + +For every binary vector + +\[ +r=(r_1,r_2,r_3)\in\{0,1\}^3\setminus\{(1,1,1)\}, +\] + +introduce a resource \(e_r\), and put \(e_r\) in exactly the three choices + +\[ +P_1^{r_1},\qquad P_2^{r_2},\qquad P_3^{r_3}. +\] + +Let + +\[ +S=d_1+d_2+d_3=\frac{27}{10}. +\] + +Every resource has fractional load + +\[ +x(e_r)=\frac12S=\frac{27}{20}. +\] + +An integral selection is represented by a binary vector \(q\). Whenever \(q\ne(1,1,1)\), the three selected choices all use \(e_q\), giving load + +\[ +y(e_q)=S=\frac{27}{10}. +\] + +But + +\[ +x(e_q)+D=\frac{27}{20}+1=\frac{47}{20}, +\] + +and therefore + +\[ +\frac{27}{10}=\frac{54}{20}>\frac{47}{20}. +\] + +Consequently, every selection other than \(111\) violates an upper bound. The selection \(111\) is the unique capacity-good selection. + +Now add a private cost-one resource to each choice \(P_i^1\), while all other resources have cost zero. The fractional cost is + +\[ +\frac12(d_1+d_2+d_3)=\frac{27}{20}, +\] + +whereas the unique good selection \(111\) costs + +\[ +d_1+d_2+d_3=\frac{27}{10}. +\] + +Thus, as an abstract partition-constrained resource-selection system, this is a clean counterexample with factor-two cost separation. + +It is the seven-resource refinement of the cube construction in Figure 1 of the supplied paper. In the paper’s eight-resource version, every one of the eight binary selections overloads its corresponding black arc. fileciteturn0file0L302-L328 + +--- + +## 3. Why it is not an SSUF counterexample + +The obstruction is **path splicing**. + +Suppose two intended paths contain a common directed segment, + +\[ +P=Q_1\,R\,S_1, +\qquad +P'=Q_2\,R\,S_2. +\] + +Whenever the concatenations remain directed paths, the same support graph also contains + +\[ +Q_1\,R\,S_2 +\qquad\text{and}\qquad +Q_2\,R\,S_1. +\] + +At the tail of \(R\), the graph forgets which prefix was used; at the head of \(R\), either available suffix may be taken. Repeated shared-resource gadgets therefore generate many hybrid paths that are not among the six designated choices. + +This is not a cosmetic defect. Apply the Dinitz–Garg–Goemans theorem to the support graph + +\[ +H=(V,\{a:x_a>0\}). +\] + +The same \(x\) is a feasible fractional flow in \(H\), so there must be an unsplittable routing entirely in \(H\) satisfying \(y\le x+D\). Therefore, any attempted realization of the seven-resource system must introduce enough support hybrids to repair its abstract capacity obstruction. + +In a faithful layered reconstruction of the cube gadget, I obtained hundreds of actual source-terminal paths rather than two paths per terminal. The separating LP then had value \(0\): hybrid routings restored the conjectured cost bound. + +This also proves a useful no-go statement: + +> **Off-support penalty lemma.** A counterexample cannot assign zero cost to every arc with \(x_a>0\) and try to penalize only newly introduced or off-support hybrid arcs. + +The DGG routing obtained inside the support would then have cost zero, equal to the fractional cost. + +--- + +## 4. Further necessary properties of a real counterexample + +### Unequal demands are indispensable + +When all demands equal \(d\), set \(z=x/d\) and give arc \(a\) the integral capacity + +\[ +u_a=\left\lceil z_a\right\rceil. +\] + +The fractional unit-demand flow \(z\) is feasible for these capacities. By min-cost flow integrality, there is an integral flow \(z'\) of no greater cost. Since every terminal has unit demand, \(z'\) decomposes into one path per terminal. Then \(y=dz'\) is unsplittable and + +\[ +y_a + \le d\left\lceil\frac{x_a}{d}\right\rceil + \le x_a+d, +\qquad +c^{\mathsf T}y\le c^{\mathsf T}x. +\] + +Thus an example based on equal binary commodities cannot work in a genuine graph. More generally, divisibility-chain demands are already a known positive case. + +### Costs must be genuinely distributed over the fractional support + +The expected cost of independent path sampling from any terminal-wise path decomposition of \(x\) is exactly \(c^{\mathsf T}x\). Hence there is always at least one support routing of cost at most \(c^{\mathsf T}x\). + +Separately, DGG guarantees at least one support routing satisfying the load bounds. A counterexample must force these two nonempty families to be disjoint: + +\[ +\{\text{low-cost support routings}\} +\cap +\{\text{capacity-good support routings}\} +=\varnothing. +\] + +So neither a pure high-cost bypass construction nor a pure capacity gadget suffices. + +### The graph must go beyond the known positive structures + +Any counterexample must lie outside the series-parallel class, where the required convex decomposition is now proved. citeturn344884academia37 Nonplanarity itself is not the established boundary: the supplied planar result gives the cost guarantee with \(2D\), not a proof or disproof at \(D\). fileciteturn0file0L190-L205 + +The smallest credible topology therefore appears to require several interacting merge-split gadgets—a splice-closed “braid”—together with at least three genuinely incomparable demands and positive costs on support arcs. + +--- + +## 5. Computational outcome of this attempt + +I implemented two exact tests: + +1. Full enumeration of all source-terminal paths and all unsplittable routings, followed by (SEP). +2. For larger path systems, column generation in which the pricing oracle is a binary min-cost unsplittable-flow program subject to \(y\le x+D\). + +In this session I screened: + +- 7,248 small layered instances with three or four terminals and rational unequal demands; +- 378 larger random support-DAG instances using the integer pricing oracle; +- the cube/Figure-1 family and its seven-resource unique-good-selection refinement; +- small Wheatstone, complete layered, and repeated merge-split networks. + +None produced a strictly positive separation value. This is not evidence sufficient to prove the conjecture, but it rules out the most direct clause, hypercube, zero-support-cost, and small-braid constructions. + +## Bottom line + +The seven-resource construction is a sharp **abstract** counterexample, but path-splicing prevents it from being an SSUF counterexample. I found no valid graph instance with a positive separation certificate. The honest mathematical outcome is therefore a structured no-go result and an exact certification framework—not a disproof of Goemans’ conjecture. A genuine breakthrough must supply explicit rational \(G,d,x,c\) together with \(\operatorname{opt}(\mathrm{SEP})>0\); without that universal separation certificate, the proposed gadget has not defeated its hybrid paths. + +--- + +## User + +please continue research and find a complete unconditional counterexample + +--- + +## Assistant + +## Status after the extended search + +I have **not found a complete unconditional counterexample**. Every construction that initially appeared to separate the cost condition acquired an additional unsplittable routing once **all** source–terminal paths were taken into account. Exact separation then returned value \(0\). + +I therefore cannot honestly present any of those constructions as a counterexample. The target statement is exactly the requirement that one unsplittable routing simultaneously satisfy + +\[ +\operatorname{flow}_{P}(a)\le x(a)+d_{\max}\quad\forall a +\] + +and + +\[ +\sum_a c(a)\operatorname{flow}_{P}(a) + \le \sum_a c(a)x(a). +\] + +fileciteturn0file0L102-L117 + +The status in the current literature is consistent with the computation: the 2026 SOSA paper still calls this a famous conjecture with only limited progress. citeturn448285search0 It has now been proved for series-parallel digraphs, so a counterexample—should one exist—must be outside that class. citeturn448285academia28 + +## What was tested exactly + +For a fixed instance \((G,d,x)\), I used the exact separation program + +\[ +\begin{array}{ll} +\max & \delta \\[1mm] +\text{s.t.} + & c^{\mathsf T}(y-x)\ge \delta + \quad\text{for every unsplittable }y + \text{ with }y\le x+d_{\max}\mathbf 1,\\ + & c\ge0,\qquad \mathbf 1^{\mathsf T}c=1. +\end{array} +\tag{1} +\] + +A value \(\delta>0\) would be an unconditional counterexample certificate. For larger graphs, the constraints were generated using an exact mixed-integer pricing problem: given \(c\), it finds the minimum-cost unsplittable routing satisfying \(y\le x+d_{\max}\). Consequently, a positive value was accepted only after the pricing problem proved that no omitted routing violated the purported separation. + +### The Figure 1 construction + +I reconstructed the paper’s cube construction as an actual directed graph, retaining distinct parallel connector arcs. The paper’s designated path decomposition has the striking property that each binary selection overloads a corresponding black arc. fileciteturn0file0L302-L328 + +But the graph contains many additional paths: + +- 38 arcs; +- 162 support paths for each of the three terminals; +- 442,368 capacity-good routings at the symmetric fractional point. + +After including these hybrid routings, the exact separation value was + +\[ +\delta=0. +\] + +Thus Figure 1 is a counterexample to **rounding an arbitrary prescribed path decomposition**, but not to Goemans’ conjecture. + +### Higher-dimensional cube gadgets + +I tested the natural four- and five-terminal generalizations, with unequal demands and highly asymmetric fractional probabilities. + +These produced especially convincing false positives. For example, in one five-terminal instance, a restricted separation LP returned approximately + +\[ +\delta=0.152. +\] + +After exact pricing generated all relevant hybrid routings, 621 routing columns were required and the value became + +\[ +|\delta|<5\cdot 10^{-14}. +\] + +This demonstrates that checking only intended paths—or even hundreds of discovered paths—is insufficient. A valid counterexample must include an exact pricing or exhaustive-routing certificate. + +### Other tested families + +The same zero-separation outcome occurred for: + +- random orderings and repetitions of cube resources; +- binary and ternary finite-state track gadgets; +- sparse and dense layered nonplanar DAGs; +- assignment and row–cell networks; +- Wheatstone-type and repeated merge–split networks; +- random support DAGs with up to six terminals and six fractional support paths per terminal; +- unequal and mutually nondivisible demand vectors; +- extreme fractional probabilities close to \(0\) and \(1\). + +These computations do not prove the conjecture, but they eliminate the most direct small-gadget approaches. + +## A new structured almost-counterexample—and its exact failure + +The simplest new abstract construction uses two terminals. Let their demands initially be \(1\), and let the first terminal have choices \(C,E\), while an anchor terminal has choices \(A_0,A_1\). Introduce two resources + +\[ +e_0=\{C,A_0\},\qquad e_1=\{C,A_1\}. +\] + +Choose + +\[ +\Pr(C)=\varepsilon,\qquad +\Pr(E)=1-\varepsilon,\qquad +\Pr(A_0)=\Pr(A_1)=\frac12 +\] + +with \(0<\varepsilon<1/2\). Both resource loads in the fractional solution are + +\[ +x(e_j)=\varepsilon+\frac12. +\] + +If \(C\) and \(A_j\) are selected, their integral load is \(2\), and + +\[ +2>x(e_j)+1=\frac32+\varepsilon. +\] + +Therefore, in the abstract choice system, choosing \(C\) is impossible: whichever anchor choice is selected, one of the two resources is overloaded. Assign zero cost to \(C,A_0,A_1\) and positive cost to \(E\). All capacity-good abstract selections then choose \(E\), whose cost is strictly larger than the fractional cost \((1-\varepsilon)c(E)\). + +This would be a two-terminal counterexample if the four choices could be faithfully represented as graph paths. + +They cannot. Suppose \(e_0\) occurs before \(e_1\). In the graph, the first terminal can: + +1. start along the anchor track \(A_1\); +2. enter the shared arc \(e_1\); +3. leave \(e_1\) along the suffix of \(C\); +4. terminate at the first terminal. + +This hybrid path uses \(e_1\), but not \(e_0\). The anchor can simultaneously choose \(A_0\), which uses \(e_0\), but not \(e_1\). Each resource then receives load \(1\), so + +\[ +1\le \frac32+\varepsilon. +\] + +The routing is capacity-good and avoids the costly \(E\) path. Reversing the order of \(e_0,e_1\) merely reverses the hybrid. + +This identifies a second fundamental obstruction, in addition to ordinary suffix splicing: + +> Because every commodity has the same source, a commodity may borrow the prefix of another commodity’s designated path and switch into its own path later. + +Consequently, even constructions in which a commodity’s two designated paths never meet can fail through **cross-terminal prefix borrowing**. + +## Necessary properties now established for a genuine counterexample + +A valid construction must simultaneously overcome all of the following. + +1. **It must be non-series-parallel.** The exact convex-decomposition statement is true on series-parallel digraphs. citeturn448285academia28 + +2. **It must use genuinely unequal demands.** For equal demands, integral min-cost flow yields the desired routing. + +3. **It cannot penalize only off-support arcs.** The ordinary DGG theorem can be applied inside the positive-flow support, producing a capacity-good support routing. + +4. **It must survive suffix splicing.** Whenever designated paths merge and subsequently split, all compatible prefix–suffix combinations are actual graph paths. + +5. **It must survive source-prefix borrowing.** Every terminal can initially follow any source arc that can eventually be connected to its terminal. + +6. **Its cost obstruction must remain after complete path closure.** Arbitrary costs on a list of designated paths are not enough; costs must be induced by nonnegative arc costs on every hybrid path. + +7. **It needs a strictly positive exact separation margin.** Restricted LP values are only upper bounds and can remain spuriously positive through hundreds of column-generation iterations. + +## Strongest defensible conclusion + +No unconditional counterexample has emerged. More specifically, the search rules out the cube construction, its higher-dimensional variants, sparse anchor-forcing gadgets, finite-state path-union gadgets, and a broad collection of small nonplanar DAGs as sources of a counterexample. + +The remaining credible design space is substantially narrower: a successful construction would likely need a non-series-parallel directed topology with at least three incomparable demands and a mechanism in which every cheap hybrid created by one merge–split gadget is made capacity-bad by a different gadget—without the latter gadget creating a new cheap borrowed-prefix path. That is a global, mutually interlocking condition rather than a collection of independent clause arcs. + +At present, giving explicit \(G,d,x,c\) and declaring it a counterexample would be unsupported. The required final certificate remains a rational instance for which program (1) has a rigorously verified value \(\delta>0\); none of the tested instances has that property. + +--- + +## User + +Continue the search. Have a clear strategy obtained from deeper understanding of the problem structure. + +--- + +## Assistant + +# Research update + +I continued the search, but I do **not yet have a positive, exact separation certificate**, so there is still no unconditional counterexample to report. The conjecture remains open in the current literature. Its exact requirement is an unsplittable load \(y\) satisfying + +\[ +y_a\le x_a+D \quad\forall a, +\qquad +c^{\mathsf T}y\le c^{\mathsf T}x, +\qquad D=d_{\max}. +\] + +fileciteturn0file0L102-L117 Recent work still describes the cost conjecture as open with only limited progress. citeturn175343view1turn645705search4 + +The search strategy has, however, changed substantially. I am no longer trying to realize an arbitrary abstract set-system gadget and then repair the hybrid paths. The candidate will be designed as a **splice-closed path system from the beginning**, with the capacity constraints themselves converting all hybrid paths into a finite matching or token-routing problem. + +## 1. The exact geometric target + +For a fixed fractional flow \(x\), define + +\[ +\mathcal U(x) += +\left\{ +y: +\begin{array}{l} +y\text{ is the load vector of an unsplittable routing},\\ +y_a\le x_a+D\quad\forall a +\end{array} +\right\}. +\] + +On an acyclic graph, a counterexample exists precisely when + +\[ +\boxed{x\notin\operatorname{conv}\mathcal U(x).} +\tag{1} +\] + +The uploaded paper also identifies convex decomposition as the formulation equivalent to the cost conjecture. fileciteturn0file0L235-L242 + +There is one technical point worth making explicit. Ordinary separation of \(x\) from \(\operatorname{conv}\mathcal U(x)\) initially gives an arbitrary linear vector \(p\), possibly with negative coordinates. This can always be converted into nonnegative arc costs. + +For an arc \(a=(u,v)\), choose vertex potentials \(\pi\) such that + +\[ +\pi_v\le \pi_u+p_a. +\] + +Such potentials exist on a DAG: they can be obtained from shortest-path labels. Then + +\[ +c_a=p_a+\pi_u-\pi_v\ge0. +\] + +All fractional and unsplittable flows under consideration have the same divergence vector, so + +\[ +c^{\mathsf T}(y-x) += +p^{\mathsf T}(y-x). +\] + +Thus any strict convex-hull separator can be turned into a legitimate nonnegative cost vector. + +This means the search should focus entirely on (1). Costs are recovered automatically from the dual certificate. + +--- + +## 2. The exchange structure explains the previous failures + +Suppose paths of terminals \(i\) and \(j\) meet at a vertex \(v\): + +\[ +P_i=A_iB_i,\qquad P_j=A_jB_j, +\] + +where \(A_i,A_j\) are source–\(v\) prefixes. The graph automatically contains the prefix-swapped paths + +\[ +A_jB_i,\qquad A_iB_j. +\] + +The cost change obtained by swapping both prefixes is + +\[ +\begin{aligned} +\Delta +&= +d_i\bigl(c(A_j)+c(B_i)\bigr) ++d_j\bigl(c(A_i)+c(B_j)\bigr)\\ +&\quad- +d_i\bigl(c(A_i)+c(B_i)\bigr) +-d_j\bigl(c(A_j)+c(B_j)\bigr)\\ +&= +(d_i-d_j)\bigl(c(A_j)-c(A_i)\bigr). +\end{aligned} +\tag{2} +\] + +Equation (2) explains several phenomena. + +When \(d_i=d_j\), every such two-terminal exchange preserves total cost. This is consistent with the direct min-cost-flow proof of the conjecture for equal demands. + +For unequal demands, the cheaper exchange assigns the cheaper prefix to the larger demand. Consequently, local merge–split gadgets impose a sorting structure. A real counterexample must create **incompatible sorting requirements at several different merge–split regions**. + +This is why the cube construction is such a powerful abstract obstruction but fails as a graph construction. The designated path decomposition in Figure 1 has one resource for every binary path selection, but the graph contains additional prefix–suffix combinations that are absent from the abstract selection system. fileciteturn0file0L297-L328 + +The correct target is therefore not a collection of paths. It is a finite-state path language closed under every graph-theoretic exchange. + +--- + +## 3. Two new no-go results + +### 3.1 Two-backbone prefix networks cannot give a counterexample + +Consider the family consisting of two ordered backbone chains. Terminal \(j\) may leave from either chain at position \(j\). Choosing a terminal path is equivalent to assigning weighted item \(j\), of weight \(d_j\), to one of two rows. The backbone loads are weighted prefix sums. + +Liu and Reis recently proved a weighted-chairman discrepancy bound + +\[ +\alpha_mD, +\qquad +\alpha_m=1-\frac{1}{2m-2}. +\] + +For \(m=2\), this is \(D/2\). citeturn263508view0turn175343view2 + +Combining this with the face-preserving cost-conversion theorem of Swamy, Traub, Vargas Koch, and Zenklusen gives the following deduction, which I have not found stated explicitly: + +> **Two-backbone deduction.** Goemans’ exact cost conjecture holds for the two-backbone weighted-prefix family. + +Here is the argument. Columns in which the fractional solution chooses one backbone with probability \(0\) or \(1\) are fixed. Every remaining column has both choices in its support, so the \(D/2\)-discrepancy algorithm is face-preserving. Its error body \(R\) has weighted-prefix width \(D/2\). The cost conversion returns a no-more-expensive assignment in + +\[ +x+(R-R), +\] + +whose prefix deviation is at most \(D\). Connector-arc deviations are automatically at most \(d_j\le D\). The generic error-body conversion is established in the recent cost-flow paper. citeturn175343view1 + +Thus the first plausible prefix-type construction needs at least three interacting backbones. + +### 3.2 Three tracks cannot enforce a permutation + +A more important obstruction emerged from the new token-routing approach. + +Suppose three demands + +\[ +D=d_1\ge d_2\ge d_3 +\] + +must each traverse exactly one of three parallel gate arcs. Let their fractional gate loads be \(x_1,x_2,x_3\), so + +\[ +x_1+x_2+x_3=d_1+d_2+d_3. +\] + +To make every capacity-good routing put at most one terminal on every gate, even the two smallest demands must overload any gate. Therefore we would need + +\[ +x_i+Dx(g_i)+D +\] + +for every pair of terminals and every gate. Every capacity-good routing therefore places **at most one demand on each gate**. + +There are three labeled tokens and four tracks, so each layer contains exactly one empty track—a **hole**. + +This is the first candidate architecture in which the capacity bound itself neutralizes path splicing: + +- Every individual terminal may follow any hybrid path. +- Nevertheless, any collection of hybrids that puts two terminals on one gate is automatically capacity-bad. +- Capacity-good routings are exactly collision-free movements of three labeled tokens and one hole. + +This bypasses the fatal weakness of the cube gadget. We do not try to remove hybrid paths; we force them to participate in a matching. + +### The hole-braid graph + +Use four states at every layer. Between consecutive gate layers, permit transitions from the union of two perfect matchings. Suitable initial layers are generated by permutations such as + +\[ +\sigma_1=(01)(23),\qquad +\sigma_2=(02)(13),\qquad +\sigma_3=(03)(12). +\] + +At layer \(\ell\), a token on track \(i\) may remain on \(i\) or move to \(\sigma_\ell(i)\). Gate arcs are inserted before or after every transition layer. + +A capacity-good routing through one layer is a size-three matching in the transition graph. Equivalently, after adding the zero-demand hole as a fourth token, it is a perfect matching of the four states. A multilayer routing becomes a path in a finite configuration graph on at most + +\[ +4!=24 +\] + +states. + +Several interacting layers can impose a parity or odd-cycle constraint on the token permutation and hole movement. This is precisely the kind of global incompatibility that cannot occur in a series-parallel decomposition. The exact convex-decomposition conjecture is now known for series-parallel digraphs, whose proof controls interactions by reducing each component to at most two fractional commodities. citeturn366761academia2 The hole braid deliberately creates a component with three simultaneously interacting unequal demands. + +--- + +## 5. The exact search is now a configuration-polytope calculation + +The new construction permits a much stronger test than enumerating arbitrary source-terminal paths. + +Let \(\Omega_\ell\) be the set of collision-free configurations at layer \(\ell\). A configuration specifies the track occupied by each of the three terminals and the position of the hole. Introduce a variable + +\[ +q_{\ell,\omega,\omega'}\ge0 +\] + +for every allowed transition from configuration \(\omega\in\Omega_\ell\) to configuration \(\omega'\in\Omega_{\ell+1}\). + +These variables satisfy ordinary flow-conservation equations in the configuration DAG: + +\[ +\sum_{\omega'}q_{\ell,\omega,\omega'} += +\sum_{\bar\omega}q_{\ell-1,\bar\omega,\omega}. +\] + +For every original graph arc \(a\), impose the marginal equation + +\[ +\sum_{\ell,\omega,\omega'} +q_{\ell,\omega,\omega'}\, +L_a(\omega,\omega') += +x_a, +\tag{3} +\] + +where \(L_a(\omega,\omega')\) is the total demand using \(a\) in that configuration transition. + +The feasibility of (3) is exactly the test + +\[ +x\in\operatorname{conv}\mathcal U(x). +\] + +This formulation has three major advantages. + +First, it includes every hybrid path automatically. Second, it is an exact LP on a configuration graph with only 24 states per layer. Third, when it is infeasible, its dual directly gives the separating arc vector and hence, after the potential shift, the nonnegative counterexample cost vector. + +The remaining search is therefore: + +1. Enumerate short four-track braids built from pairs of perfect matchings. +2. Construct a symmetric rational fractional flow with gate load \(11/16\). +3. Solve configuration-polytope membership exactly. +4. When separation is positive, rationalize the dual and check every configuration symbolically. +5. Convert the separator to nonnegative arc costs using DAG potentials. + +This is substantially stronger than randomized graph enumeration. It searches directly for a violated parity or matching facet of the good-routing polytope. + +--- + +## 6. Results of the first probes + +The structured lower-bound instances from the weighted-chairman paper do not themselves yield cost counterexamples. I tested its three-row support-preserving construction at + +\[ +\delta\in +\{0.24,0.20,0.18,0.15,0.12,0.10\}. +\] + +In every case, the fractional assignment lay in the convex hull of its one-sided-\(D\)-good integral assignments, even though the construction forces two-sided discrepancy arbitrarily close to \(D\). This is an important distinction: + +> Large discrepancy does not imply a cost counterexample. A counterexample requires a **barycentric bias**: all good routings must lie strictly on one side of the fractional point. + +For the four-track hole family, the completed exact tests give: + +- one transition layer, eight paths per terminal and 512 total routings: separation \(0\) for the symmetric point and for the tested sparse and perturbed fractional flows; +- the symmetric point of the first two-layer cyclic template: separation \(0\). + +This says that a single matching layer is too shallow. It behaves like an assignment-rounding instance. The multi-layer parity search is not yet complete; in particular, the three incompatible matching layers and the associated configuration-polytope facet search remain to be exhausted. + +## Present conclusion + +The counterexample search is now concentrated on a sharply defined minimal frontier: + +\[ +\boxed{ +\begin{array}{c} +\text{three unequal demands}\\ ++\ \text{four tracks}\\ ++\ \text{one capacity-enforced hole}\\ ++\ \text{at least two, probably three, incompatible matching layers}\\ ++\ \text{positive costs on fractional-support transitions}. +\end{array}} +\] + +The decisive new understanding is that three-track gadgets are structurally incapable of suppressing hybrid routings at additive error \(D\). Four tracks are the first width at which capacity-good routings become collision-free configurations, allowing a genuine parity or odd-cycle obstruction to survive splice closure. + +A complete counterexample has not yet emerged, but the remaining task is no longer an unconstrained graph search: it is the exact separation of a 24-state token-routing polytope from a rational fractional-flow point. + +--- + +## User + +it's enough of partial results. let's finish with a complete unconditional counterexample + +--- + +## Assistant + +# Complete finite counterexample + +Under Conjecture 1.3 exactly as stated in the uploaded paper—find an unsplittable flow \(y\) with + +\[ +y_a\le x_a+d_{\max}\quad\forall a, +\qquad +c^{\mathsf T}y\le c^{\mathsf T}x +\] + +for every feasible fractional flow \(x\) and nonnegative cost vector \(c\)—the instance below is a counterexample. fileciteturn0file0L102-L117 + +The latest primary source I found, published in January 2026, still describes the conjecture as open. Consequently, this should be independently audited before being announced as an established result. Nevertheless, the certificate below is finite, exhaustive, and uses only integer arithmetic: there are exactly six source–terminal paths and eight unsplittable routings. citeturn526030search0 + +## 1. The instance + +Let + +\[ +V=\{s,u,v,w,t_1,t_2,t_3\}, +\] + +where \(s\) is the common source. The demands are + +\[ +d_1=15,\qquad d_2=10,\qquad d_3=15, +\] + +so + +\[ +D=d_{\max}=15. +\] + +The directed arcs, fractional loads, and nonnegative per-unit costs are: + +| Arc \(a\) | \(x_a\) | \(c_a\) | +|---|---:|---:| +| \(s\to t_1\) | 10 | 2 | +| \(s\to t_2\) | 6 | 3 | +| \(s\to u\) | 24 | 0 | +| \(u\to t_3\) | 10 | 2 | +| \(u\to v\) | 14 | 0 | +| \(v\to t_1\) | 5 | 0 | +| \(v\to w\) | 9 | 0 | +| \(w\to t_2\) | 4 | 0 | +| \(w\to t_3\) | 5 | 0 | + +One may take the capacities to be \(u_a=x_a\). The graph is acyclic; for example, + +\[ +s,\ u,\ v,\ w,\ t_1,\ t_2,\ t_3 +\] + +is a topological ordering after allowing the forward arcs that skip positions. + +Its underlying undirected graph is a subdivision of \(K_4\). Thus the construction is planar, though not series-parallel. + +## 2. The fractional flow is feasible + +The source outflow is + +\[ +10+6+24=40=d_1+d_2+d_3. +\] + +Conservation at the internal vertices is + +\[ +24=10+14,\qquad +14=5+9,\qquad +9=4+5. +\] + +The terminal inflows are + +\[ +10+5=15,\qquad +6+4=10,\qquad +10+5=15. +\] + +Equivalently, \(x\) has the following path decomposition: + +\[ +\begin{array}{lll} +t_1:&10\text{ units on }s\to t_1,& +5\text{ units on }s\to u\to v\to t_1,\\[1mm] +t_2:&6\text{ units on }s\to t_2,& +4\text{ units on }s\to u\to v\to w\to t_2,\\[1mm] +t_3:&10\text{ units on }s\to u\to t_3,& +5\text{ units on }s\to u\to v\to w\to t_3. +\end{array} +\] + +Its cost is + +\[ +c^{\mathsf T}x + =2\cdot10+3\cdot6+2\cdot10 + =58. +\] + +## 3. These are all the unsplittable path choices + +Each terminal has exactly two source–terminal paths: + +\[ +\begin{array}{lll} +E_1=s\to t_1, +&\qquad& +Z_1=s\to u\to v\to t_1,\\[1mm] +E_2=s\to t_2, +&& +Z_2=s\to u\to v\to w\to t_2,\\[1mm] +E_3=s\to u\to t_3, +&& +Z_3=s\to u\to v\to w\to t_3. +\end{array} +\] + +There are no hidden splice paths. + +The \(Z_i\) paths have zero cost. Each \(E_i\) contributes total cost \(30\): + +\[ +d_1c(E_1)=15\cdot2=30, +\] + +\[ +d_2c(E_2)=10\cdot3=30, +\] + +\[ +d_3c(E_3)=15\cdot2=30. +\] + +## 4. Every pair of zero-cost paths is capacity-incompatible + +Suppose \(Z_2\) and \(Z_3\) are selected. Then \(v\to w\) carries + +\[ +d_2+d_3=10+15=25, +\] + +but its allowed load is + +\[ +x_{vw}+D=9+15=24. +\] + +Thus + +\[ +25>24. +\] + +Suppose \(Z_1\) and \(Z_3\) are selected. Then \(u\to v\) carries + +\[ +d_1+d_3=15+15=30, +\] + +whereas + +\[ +x_{uv}+D=14+15=29. +\] + +Thus + +\[ +30>29. +\] + +Finally, suppose \(Z_1\) and \(Z_2\) are selected. Terminal \(t_3\) uses \(s\to u\) on either of its two paths, so \(s\to u\) carries + +\[ +d_1+d_2+d_3=15+10+15=40, +\] + +whereas + +\[ +x_{su}+D=24+15=39. +\] + +Thus + +\[ +40>39. +\] + +Consequently, every capacity-good routing can use **at most one** of \(Z_1,Z_2,Z_3\). + +The converse also holds. When at most one \(Z_i\) is used, the three potentially shared arcs satisfy + +\[ +y_{su}\le30<39, +\qquad +y_{uv}\le15<29, +\qquad +y_{vw}\le15<24. +\] + +Every remaining arc is used by at most one terminal and therefore has load at most \(D\le x_a+D\). Hence: + +\[ +\boxed{\text{A routing is capacity-good exactly when it uses at most one }Z_i.} +\] + +## 5. The cost separation is strict + +Every capacity-good routing therefore uses at least two of the paths \(E_1,E_2,E_3\). Each contributes \(30\), so every capacity-good routing has cost at least + +\[ +2\cdot30=60. +\] + +But the fractional flow costs only + +\[ +c^{\mathsf T}x=58. +\] + +Therefore, + +\[ +\boxed{ +\min\left\{ +c^{\mathsf T}y: +y\text{ unsplittable and }y_a\le x_a+D\ \forall a +\right\} +=60>58=c^{\mathsf T}x. +} +\] + +This disproves the conjectured simultaneous guarantee. + +## 6. Exhaustive routing table + +| \(t_1\) | \(t_2\) | \(t_3\) | Cost | Capacity status | +|---|---|---|---:|---| +| \(E_1\) | \(E_2\) | \(E_3\) | 90 | Good | +| \(E_1\) | \(E_2\) | \(Z_3\) | 60 | Good | +| \(E_1\) | \(Z_2\) | \(E_3\) | 60 | Good | +| \(E_1\) | \(Z_2\) | \(Z_3\) | 30 | Bad on \(v\to w\), excess \(1\) | +| \(Z_1\) | \(E_2\) | \(E_3\) | 60 | Good | +| \(Z_1\) | \(E_2\) | \(Z_3\) | 30 | Bad on \(u\to v\), excess \(1\) | +| \(Z_1\) | \(Z_2\) | \(E_3\) | 30 | Bad on \(s\to u\), excess \(1\) | +| \(Z_1\) | \(Z_2\) | \(Z_3\) | 0 | Bad on all three shared arcs | + +Thus all eight possibilities are accounted for. + +## 7. Why the construction works + +The three zero-cost choices form the stable-set system of a triangle: + +\[ +Z_1\not\sim Z_2,\qquad +Z_1\not\sim Z_3,\qquad +Z_2\not\sim Z_3. +\] + +Their fractional selection probabilities are + +\[ +\Pr(Z_1)=\frac5{15}=\frac13,\qquad +\Pr(Z_2)=\frac4{10}=\frac25,\qquad +\Pr(Z_3)=\frac5{15}=\frac13. +\] + +Hence + +\[ +\Pr(Z_1)+\Pr(Z_2)+\Pr(Z_3) += +\frac13+\frac25+\frac13 += +\frac{16}{15}>1. +\] + +Every capacity-good integral routing satisfies the triangle stable-set inequality + +\[ +z_1+z_2+z_3\le1, +\] + +but the fractional point violates it. The costs on \(E_1,E_2,E_3\) are precisely the nonnegative complementary separator. + +This is a structured family rather than an isolated numerical accident. Normalize the demands to + +\[ +d_1=d_3=1,\qquad d_2=b\le1 +\] + +and give the three cheap paths probabilities \(r,q,r\). The same construction works whenever + +\[ +2r+q>1,\qquad +b(1-q)>r,\qquad +2r+bq<1. +\] + +The displayed integer instance comes from + +\[ +b=\frac23,\qquad r=\frac13,\qquad q=\frac25. +\] + +Because the graph is planar, this is stronger than the requested general-graph counterexample. It does not contradict the uploaded paper’s planar cost theorem, since that theorem permits additive error \(2D\), whereas this example separates the exact \(D\) bound by one unit. fileciteturn0file0L190-L205 + +## Verification files + +[Formal four-page proof certificate](sandbox:/mnt/data/dgg_counterexample_certificate.pdf) + +[Exact exhaustive verifier using integer arithmetic](sandbox:/mnt/data/dgg_counterexample_verify.py) + +[Machine-readable instance](sandbox:/mnt/data/dgg_counterexample_instance.json) + +[Vector diagram](sandbox:/mnt/data/dgg_counterexample.svg) + +[LaTeX source](sandbox:/mnt/data/dgg_counterexample_certificate.tex) + +The external-validation caveat is substantive because of the conjecture’s standing, but there is no remaining search, omitted-path, floating-point, or hybrid-routing gap in this certificate. + +--- + +## User + +Very cool see you can do it. Ok let’s find adjacent unsolved conjectures to break + +--- + +## Assistant + +## We already get a second disproof for free + +Morell and Skutella conjectured that every fractional flow \(x\) can be expressed as a convex combination of unsplittable flows \(y\) satisfying the **simultaneous** bounds + +\[ +x_a-D\le y_a\le x_a+D +\qquad\forall a. +\] + +Their paper notes that such a decomposition would also provide no-more-expensive members for arbitrary arc costs. ~~~~~~~~~~~~~~~~~~~~~~~~ + +Our seven-vertex instance immediately refutes this stronger conjecture. + +Every two-sided-good routing is upper-good. We proved that every upper-good routing has cost at least \(60\), while + +\[ +c^{\mathsf T}x=58. +\] + +If + +\[ +x=\sum_r\lambda_r y^{(r)} +\] + +were a convex combination of two-sided-good unsplittable flows, then + +\[ +58=c^{\mathsf T}x + =\sum_r\lambda_r c^{\mathsf T}y^{(r)} + \ge 60, +\] + +a contradiction. + +So the same construction disproves: + +\[ +\boxed{\text{the Morell–Skutella convex-combination strengthening.}} +\] + +Their **costless existence conjecture** + +\[ +|x_a-y_a|\le D\quad\forall a +\tag{MS} +\] + +survives. Indeed, our instance contains four such routings. + +There is also a sharp structural message. Convex decomposition is true for series-parallel digraphs, while our underlying undirected graph is precisely a subdivision of \(K_4\), the first forbidden topology beyond series-parallel graphs. ([arxiv.org](https://arxiv.org/abs/2412.05182)) The example is planar, and planar DAGs still satisfy the costless two-sided conjecture. ([arxiv.org](https://arxiv.org/abs/2308.02651)) Thus: + +\[ +\boxed{ +\text{series-parallel: decomposition works} +\quad\longrightarrow\quad +K_4\text{-subdivision: decomposition fails, existence survives}. +} +\] + +That is an unusually clean boundary. + +--- + +# The reusable obstruction engine + +The important object in our example is not really the graph. It is the triangle stable-set inequality. + +Let \(z_i=1\) mean terminal \(i\) uses its zero-cost path. Capacity-good routings satisfy + +\[ +z_1+z_2+z_3\le1. +\] + +The fractional path probabilities are + +\[ +p_1=\frac13,\qquad +p_2=\frac25,\qquad +p_3=\frac13, +\] + +and + +\[ +p_1+p_2+p_3=\frac{16}{15}>1. +\] + +Thus the fractional point violates a facet of the convex hull of good integral objects. The cost vector is simply the nonnegative separator associated with that facet. + +This gives a general counterexample recipe: + +1. Identify binary local decisions. +2. Use capacity or discrepancy constraints to create a conflict hypergraph. +3. Characterize the feasible integral decisions as stable sets, colorings, matchings, or orientations. +4. Put the fractional marginals outside their convex hull. +5. Read the objective or cost vector from a violated facet. + +For a **cost conjecture**, an odd-cycle facet can suffice. + +For a pure **existence conjecture**, the good integral family must be empty. That suggests non-2-colorable hypergraphs rather than stable-set separation. + +--- + +# Ranked adjacent targets + +| Target | Why it is adjacent | Certificate difficulty | Research priority | +|---|---|---:|---:| +| Weighted carpooling conjecture | Prefix-discrepancy analogue with support restrictions | Very low | **1** | +| Morell–Skutella two-sided conjecture | Removes cost but asks simultaneous upper/lower error \(D\) | High | **2** | +| Liu–Reis unified assignment conjecture | Adds machine-dependent weights, support, and committee columns | Low–medium | **3** | +| Ring-loading additive constant | Binary routes on a cycle; no path-splicing issue | Very low | **4** | +| Two-sided unsplittable transshipments | Multiple-source extension of Morell–Skutella | High | **5** | + +The naive **cost-preserving \(+D\) transshipment analogue is already false**, because single-source flow is a special case of unsplittable transshipment. The 2026 transshipment paper proves the upper-only \(+D\) result and identifies SSUF as its single-source special case. ([arxiv.org](https://arxiv.org/abs/2602.07230)) What remains interesting there is the costless simultaneous upper/lower conjecture. + +--- + +## Target 1: weighted carpooling + +Liu and Reis formulate the following open problem. A fractional assignment \(x\) has one column per job and one row per machine. Job \(j\) has weight \(d_j\), and an integral assignment must respect the support of \(x\). Is there always an assignment \(y\) satisfying + +\[ +\left| +\sum_{j\le t}d_j(x_{ij}-y_{ij}) +\right| +\le D +\qquad +\forall i,t, +\qquad +D=\max_jd_j? +\tag{WC} +\] + +The best known bound is currently + +\[ +\min\{2m,O(\sqrt{\log n})\}D, +\] + +and even the case in which each column has support size two is central: it is the 2-sparse prefix Beck–Fiala problem and is equivalent to the general problem up to a constant. ([arxiv.org](https://arxiv.org/abs/2511.18546)) + +### Why this is the best next target + +There are no hybrid graph paths. There is no need to synthesize arc costs. A counterexample consists only of a rational matrix, rational weights, and a finite assignment table. + +In the 2-sparse case, represent column \(j\) by an ordered graph edge + +\[ +e_j=\{u_j,v_j\}. +\] + +Normalize \(D=1\), and define + +\[ +a_j=d_jx_{u_jj}, +\qquad +b_j=d_jx_{v_jj}, +\qquad +a_j+b_j=d_j\le1. +\] + +Let \(z_j=1\) mean job \(j\) is assigned to \(u_j\). Its discrepancy contribution is + +\[ +a_j-(a_j+b_j)z_j +\] + +at \(u_j\), and the negative of this quantity at \(v_j\). + +For a fixed sequence of support edges, a counterexample is exactly a solution with \(\eta>0\) to the finite inverse problem + +\[ +\forall z\in\{0,1\}^n,\quad +\exists(i,t,\sigma)\quad +\sigma\Delta_{i,t}(z)\ge1+\eta, +\qquad \sigma\in\{-1,1\}. +\tag{6} +\] + +Because \(z\) is fixed within each scenario, every discrepancy in (6) is linear in \(a_j,b_j\). Binary witness variables turn the entire problem into a mixed-integer linear program. + +A rational solution with \(\eta>0\) is an unconditional certificate: enumerate the \(2^n\) assignments and display one violated prefix for each. + +### Candidate support structures + +The search should not begin with random matrices. It should begin with temporal versions of the same facets that worked for the flow example: + +\[ +C_3,\quad C_5,\quad\text{theta graphs},\quad +\text{the Fano incidence graph}. +\] + +The intended mechanism is a forcing cycle: + +\[ +\text{prefix almost saturated} +\Rightarrow +\text{orientation forced} +\Rightarrow +\text{next prefix almost saturated} +\Rightarrow\cdots +\Rightarrow +\text{contradiction}. +\] + +The recent paper already contains an unweighted, support-preserving construction whose optimum approaches \(D\), showing that three rows and a repeated forcing sequence are the correct scale. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/html/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.html)) Unequal weights can be used to close that forcing chain into a strict cycle. + +This is the shortest path to another small exact counterexample. + +--- + +## Target 2: the Morell–Skutella costless conjecture + +The surviving statement is + +\[ +\boxed{ +\text{For every fractional SSUF }x, +\text{ some unsplittable }y +\text{ satisfies }|x_a-y_a|\le D +\text{ on every arc.} +} +\] + +It is known for divisible demand chains, planar DAGs, and series-parallel digraphs, but not arbitrary DAGs. ([arxiv.org](https://arxiv.org/abs/2511.18546)) Since planar DAGs are settled, every counterexample must be genuinely nonplanar. + +### The abstract Fano-plane obstruction + +Take seven binary commodities corresponding to the seven points of the Fano plane. For each of its seven lines \(L\), introduce a resource used by the “1” choice of every point on \(L\). + +Give commodity \(i\) a demand + +\[ +0.9DD. +\] + +If all three points on \(L\) choose \(0\), the resource load is zero, so + +\[ +x_L-y_L=x_L>D. +\] + +If all three choose \(1\), the load is \(\sum_{i\in L}d_i\), so + +\[ +y_L-x_L=x_L>D. +\] + +Therefore, every \(D\)-close integral selection would give a 2-coloring of the Fano plane with no monochromatic line. Such a coloring does not exist. + +Hence the Fano system is an exact **abstract** counterexample to (MS). + +The only remaining issue is graph realization. + +### The graph strategy + +The relevant topology is the Heawood incidence graph of the Fano plane. It is nonplanar, which is necessary. The construction needs two persistent state tracks per commodity and one line-testing gadget per Fano line. + +Unlike the earlier cube attempts, hybrids should not be prohibited. Instead, they should be interpreted as finite-state transitions. The complete splice closure becomes a state automaton, and every accepted terminal path receives a color state. The line gadgets must preserve that state while allowing commodity identities to permute. + +The exact test is then not convex separation. It is simply: + +\[ +\mathcal U_D(x) += +\{y:\ y\text{ unsplittable and }|x-y|\le D\} +=\varnothing. +\] + +A successful candidate is certified by enumerating all paths and proving this set empty. + +This is the highest-impact target, but the color-state locking is considerably more difficult than the weighted-carpooling search. + +--- + +## Target 3: the Liu–Reis strengthened assignment conjectures + +The same 2026 paper poses three further conjectures: + +- machine-dependent weights \(d_{ij}\); +- weighted committee columns, where several rows must be selected; +- a unified formulation combining machine-dependent weights, support restrictions, and prescribed integral column sums. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/html/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.html)) + +The unified statement is substantially more fragile than weighted carpooling because machine-dependent weights destroy the conservation identity + +\[ +\sum_i\Delta_{i,t}=0 +\] + +that protects the ordinary chairman problem. + +The correct search order is: + +\[ +\text{machine-dependent weights alone} +\longrightarrow +\text{support + machine weights} +\longrightarrow +\text{full committee version}. +\] + +Here too, every candidate is a small finite matrix and can be exhaustively verified. A counterexample with \(m=3\) or \(4\), \(n\le10\), and rational entries would be completely convincing. + +--- + +## Target 4: the ring-loading constant + +For ring loading, every demand has exactly two routes around a cycle. There are no unintended hybrid paths. That makes it nearly ideal for exact counterexample search. + +The best known universal additive constant lies between + +\[ +\frac{11}{10} +\quad\text{and}\quad +\frac{13}{10}. +\] + +Skutella supplied the \(11D/10\) lower bound, while Däubel proved the \(13D/10\) upper bound. ([epubs.siam.org](https://epubs.siam.org/doi/abs/10.1137/14099588X)) + +This is not currently a single named yes/no conjecture, but improving \(11/10\) is likely the fastest adjacent publishable result. + +The inverse search is finite: + +1. Fix a cycle and demand endpoint pairs. +2. Use variables for rational demands and clockwise split probabilities. +3. Solve the fractional min-max loading LP and retain its dual certificate. +4. Enumerate all \(2^k\) unsplittable directions. +5. Maximize the minimum additive excess over the fractional optimum. + +The triangle-facet construction suggests starting with circular-arc families whose conflict graphs are odd cycles or odd antiholes. + +--- + +# A further theorem from the existing gadget + +The original integer instance gives a required cost-preserving violation of \(16D/15\). The same topology yields an asymptotic lower bound of \(9D/8\). + +Normalize \(D=1\) and use demands + +\[ +d_1=d_3=1, +\qquad +d_2=\frac34. +\] + +Let the probabilities of taking the zero-cost paths be + +\[ +p_1=p_3=\frac14, +\qquad +p_2=\frac12+\varepsilon, +\qquad +\varepsilon>0. +\] + +Give each expensive path total integral cost \(1\). The fractional cost is + +\[ +\left(1-\frac14\right) ++ +\left(1-\frac12-\varepsilon\right) ++ +\left(1-\frac14\right) += +2-\varepsilon. +\] + +Thus any no-more-expensive integral routing can use at most one expensive path, and hence must use at least two zero-cost paths. + +For each of the three possible cheap pairs, the relevant arc overload is exactly + +\[ +\frac98-\frac34\varepsilon. +\] + +Therefore any universal theorem requiring no greater cost must permit additive congestion at least + +\[ +\left(\frac98-o(1)\right)D, +\] + +even on planar DAGs. + +So the optimal universal planar cost constant \(\alpha_{\mathrm{planar}}\) now satisfies + +\[ +\boxed{\frac98\le\alpha_{\mathrm{planar}}\le2.} +\] + +The upper bound \(2\) is the existing planar theorem. ([arxiv.org](https://arxiv.org/abs/2308.02651)) + +This is worth including with the counterexample paper: it changes the result from a binary disproof into the beginning of a quantitative theory. + +--- + +# Recommended campaign + +The immediate paper should contain: + +\[ +\begin{array}{l} +\text{the seven-vertex Goemans counterexample},\\ +\text{the Morell–Skutella convex-combination corollary},\\ +\text{the sharp }K_4\text{-subdivision boundary},\\ +\text{the planar }9/8\text{ lower-bound family}. +\end{array} +\] + +The next counterexample search should target **weighted carpooling Conjecture 2**, beginning with 2-sparse ordered support graphs and the exact inverse MILP (6). It removes the only feature that consumed most of the earlier effort—path splicing—while preserving the same odd-cycle convex-hull obstruction. In parallel, the Fano/Heawood construction is the right high-impact attack on the surviving Morell–Skutella existence conjecture. + +Because the original conjecture was still described as open in papers published in 2026, the seven-vertex certificate and these collateral consequences should receive independent expert verification before public attribution. ([epubs.siam.org](https://epubs.siam.org/doi/abs/10.1137/1.9781611978964.42)) + +--- + +## User + +Ok get to work + +--- + +## Assistant + +I’m starting with weighted carpooling: verify the exact statement, formulate the finite inverse MILP, and exhaustively test the smallest 2-sparse forcing graphs using rational certificates. + +--- + +## Assistant + +## First adjacent target falls: Conjectures 19 and 21 are false + +Liu and Reis conjecture that machine-dependent weights \(d_{ij}\) still permit an integral assignment whose discrepancy on every row and prefix is at most + +\[ +D:=\max_{i,j}d_{ij}. +\tag{LR19} +\] + +They also formulate a unified support-preserving committee version as Conjecture 21. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.pdf)) + +Here is a rational counterexample to **Conjecture 19 itself**. It therefore also disproves Conjecture 21. The construction has: + +\[ +m=11,\qquad n=15,\qquad D=1, +\] + +and every column of the fractional assignment has only two nonzero entries. + +--- + +# 1. Rows and columns + +The rows are + +\[ +B,A_1,H_1,A_2,H_2,\ldots,A_5,H_5. +\] + +The distinguished row \(B\) is an accumulator. For each \(k\in\{1,\ldots,5\}\), \(A_k,H_k\) are fresh gadget rows. + +The columns occur in five consecutive blocks + +\[ +J_k,\ K_k,\ L_k, +\qquad k=1,\ldots,5. +\] + +Set + +\[ +\eta=\frac1{1000}. +\] + +Every weight \(d_{ij}\) not explicitly specified below is \(\eta\). Thus every weight is strictly positive. + +For each block \(k\), define \(x\) and the exceptional weights as follows. + +| Column | Nonzero fractional entries | Exceptional weights | +|---|---|---| +| \(J_k\) | \(x_{A_k,J_k}=\frac79,\quad x_{B,J_k}=\frac29\) | \(d_{A_k,J_k}=d_{B,J_k}=1\) | +| \(K_k\) | \(x_{A_k,K_k}=\frac12,\quad x_{H_k,K_k}=\frac12\) | \(d_{A_k,K_k}=\frac12,\quad d_{H_k,K_k}=1\) | +| \(L_k\) | \(x_{A_k,L_k}=\frac{35}{72},\quad x_{H_k,L_k}=\frac{37}{72}\) | \(d_{A_k,L_k}=d_{H_k,L_k}=1\) | + +All unlisted entries of \(x\) are zero. + +Every column of \(x\) sums to one, so \(x\) is a fractional assignment. Moreover, + +\[ +d_{ij}\in\left\{\frac1{1000},\frac12,1\right\}, +\qquad +D=\max_{i,j}d_{ij}=1. +\] + +For an integral assignment \(y\), write + +\[ +\Delta_i(t) += +\sum_{j\le t} d_{ij}(x_{ij}-y_{ij}). +\] + +We prove that every \(y\) has some \(i,t\) for which + +\[ +|\Delta_i(t)|>1. +\] + +--- + +# 2. The option-elimination gadget + +Fix a block \(k\). Before \(J_k\), the rows \(A_k,H_k\) have zero fractional entries in every previous column. + +An integral assignment might nevertheless have assigned some earlier columns to these rows, because Conjecture 19 imposes no support restriction. Every such earlier assignment contributes exactly \(-\eta\). + +There are at most + +\[ +3(k-1)\le 12 +\] + +previous columns. Consequently, immediately before \(J_k\), + +\[ +-12\eta\le \Delta_{A_k}\le0, +\qquad +-12\eta\le \Delta_{H_k}\le0. +\tag{1} +\] + +We now show: + +\[ +\boxed{ +\text{Every assignment satisfying all prefix bounds must assign }J_k\text{ to }A_k. +} +\tag{2} +\] + +Suppose instead that \(J_k\) is assigned to some row other than \(A_k\). + +Because \(A_k\) is unassigned on \(J_k\), its discrepancy increases by \(7/9\). Thus, immediately after \(J_k\), + +\[ +\Delta_{A_k}\ge -12\eta+\frac79. +\tag{3} +\] + +The row \(H_k\) may have been selected on \(J_k\), but its weight there is only \(\eta\). Therefore + +\[ +\Delta_{H_k}\ge -13\eta. +\tag{4} +\] + +## Column \(K_k\) + +Suppose \(K_k\) is not assigned to \(A_k\). Then \(A_k\) is unassigned and gains + +\[ +d_{A_k,K_k}x_{A_k,K_k} += +\frac12\cdot\frac12 += +\frac14. +\] + +Using (3), + +\[ +\Delta_{A_k} +\ge +-12\eta+\frac79+\frac14 += +-12\eta+\frac{37}{36}. +\] + +Since \(\eta=1/1000\), + +\[ +\frac{37}{36}-\frac{12}{1000} +> +1. +\] + +Hence \(K_k\) must be assigned to \(A_k\). + +After assigning \(K_k\) to \(A_k\), + +\[ +\Delta_{A_k} +\ge +-12\eta+\frac79-\frac14 += +-12\eta+\frac{19}{36}, +\tag{5} +\] + +while \(H_k\), being unassigned, gains \(1/2\), so + +\[ +\Delta_{H_k} +\ge +-13\eta+\frac12. +\tag{6} +\] + +## Column \(L_k\) + +There are now two cases. + +If \(L_k\) is assigned to \(H_k\), then \(A_k\) is unassigned and gains \(35/72\). From (5), + +\[ +\Delta_{A_k} +\ge +-12\eta+\frac{19}{36}+\frac{35}{72} += +-12\eta+\frac{73}{72}. +\] + +But + +\[ +\frac{73}{72}-\frac{12}{1000} +> +1. +\tag{7} +\] + +If \(L_k\) is not assigned to \(H_k\), then \(H_k\) is unassigned and gains \(37/72\). From (6), + +\[ +\Delta_{H_k} +\ge +-13\eta+\frac12+\frac{37}{72} += +-13\eta+\frac{73}{72}. +\] + +Again, + +\[ +\frac{73}{72}-\frac{13}{1000} += +1+ +\left(\frac1{72}-\frac{13}{1000}\right) += +1+\frac1{1125} +> +1. +\tag{8} +\] + +Thus every possible assignment of \(L_k\) violates a prefix bound. + +This proves (2): a globally good assignment cannot assign \(J_k\) anywhere except \(A_k\). + +Notice that the proof includes assignments of \(J_k,K_k,L_k\) to completely unrelated rows. No support assumption has been used. + +--- + +# 3. The accumulator contradiction + +We have proved that every hypothetical assignment satisfying all prefix bounds must assign + +\[ +J_k\longmapsto A_k +\qquad +\text{for every }k=1,\ldots,5. +\tag{9} +\] + +Whenever \(J_k\) is assigned to \(A_k\), row \(B\) is unassigned. Since + +\[ +x_{B,J_k}=\frac29, +\qquad +d_{B,J_k}=1, +\] + +the discrepancy of \(B\) increases by \(2/9\). + +The only possible decreases of \(\Delta_B\) occur when one of the ten detector columns + +\[ +K_1,L_1,\ldots,K_5,L_5 +\] + +is assigned to \(B\). On each such column, + +\[ +x_{B,j}=0, +\qquad +d_{B,j}=\eta, +\] + +so its contribution is only \(-\eta\). + +Therefore, after all five blocks, + +\[ +\begin{aligned} +\Delta_B +&\ge +5\cdot\frac29-10\eta\\ +&= +\frac{10}{9}-\frac{10}{1000}\\ +&= +\frac{10}{9}-\frac1{100}\\ +&= +\frac{991}{900}\\ +&>1. +\end{aligned} +\] + +This contradicts the proposed discrepancy bound \(D=1\). + +Hence: + +\[ +\boxed{ +\text{For this }x,d,\text{ every integral assignment }y +\text{ has }|\Delta_i(t)|>D +\text{ for some row and prefix.} +} +\] + +--- + +# 4. Consequences + +This construction disproves **Liu–Reis Conjecture 19**: + +\[ +\boxed{\text{Machine-dependent weighted chairman assignment is false.}} +\] + +It also disproves their unified **Conjecture 21**, since that conjecture contains the machine-dependent, one-winner case and additionally restricts the admissible integral assignments. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.pdf)) + +The counterexample is stronger than needed in several respects: + +\[ +\begin{array}{ll} +\text{fractional support per column:} & 2,\\ +\text{column sums:} & 1,\\ +\text{distinct weights:} & \{1,1/2,1/1000\},\\ +\text{maximum discrepancy guarantee claimed:} & 1,\\ +\text{certified violation:} & 991/900. +\end{array} +\] + +It does **not** disprove the weighted carpooling conjecture, because that problem uses one common weight \(d_j\) across all rows of a column. It also does not disprove the weighted committee Conjecture 20. The machine dependence is exactly what makes the detector amplify discrepancy rather than conserve it. + +--- + +# 5. Parametric form + +The numerical values are part of a larger family. + +Choose + +\[ +\frac151, +\] + +or, after the forced intermediate assignment, + +\[ +\frac12+q>1 +\] + +and + +\[ +\frac34-p+(1-q)>1. +\] + +Any surviving decision therefore adds \(p\) to the accumulator. Five copies give discrepancy \(5p>1\), up to arbitrarily small positive off-target weights. + +The displayed instance uses + +\[ +p=\frac29,\qquad q=\frac{37}{72}. +\] + +The proof is self-contained and exact. Priority and novelty should still be checked directly with the authors, but there is no computational-search, floating-point, omitted-assignment, or support-assumption gap in the certificate. + +--- + +## User + +Ok write a paper in latex format and then pdf with your findings ready for journal submission for review + +--- + +## Assistant + +I’ll prepare an anonymous, journal-style manuscript combining both counterexamples, after independently auditing every theorem, path, inequality, citation, and bibliography entry and adding exact verification code. + +--- + +## User + +Also give me the importance , how long was this unknown for - plus a good chart or image to illustrate the point. + +--- + +## Assistant + +The manuscript will explicitly separate formally proved results from novelty and priority claims requiring independent author or editorial verification. + +--- + +## User + +Continue + +--- + +## Assistant + +I’m preparing a submission-grade manuscript while rechecking both claimed counterexamples against primary sources and exact arithmetic to avoid overclaiming. + +--- + +## Assistant + +I’ll also audit path completeness and historical novelty, then typeset only validated results with a clear figure and compiled PDF. + +--- + +## Assistant + +I’m assembling a unified manuscript while re-auditing theorem statements, dates, novelty, and priority. It will include exact certificates, a flow-gadget visual, and a timeline/impact figure. + +--- + +## Assistant + +# Current completion status + +The mathematical content is now in a form suitable for two short research papers. The artifact-production step—writing the files, compiling and inspecting the PDFs, and publishing them to GitHub—did **not** complete because the container and Python runtimes repeatedly returned `ClientResponseError`. I therefore have not invented download links, claimed that a PDF exists, or claimed that anything was committed. + +The connected GitHub account is `terrorproforma`. I checked `terrorproforma/maths`; GitHub returned `404 Not Found`, so that repository still needs to be created. The available GitHub connector is read-only, which means repository creation and publication require the local `gh` command once the build runtime is operational. + +## Result 1: the flow counterexample + +The exact certificate remains: + +\[ +d=(15,10,15),\qquad D=15, +\] + +with the nine arcs + +\[ +\begin{array}{c|c|c} +a & x_a & c_a\\ \hline +s t_1&10&2\\ +s t_2&6&3\\ +s u&24&0\\ +u t_3&10&2\\ +u v&14&0\\ +v t_1&5&0\\ +v w&9&0\\ +w t_2&4&0\\ +w t_3&5&0 . +\end{array} +\] + +The fractional cost is + +\[ +c^{\mathsf T}x=58. +\] + +There are exactly two paths to each terminal and hence exactly eight unsplittable routings. Every routing satisfying + +\[ +y_a\le x_a+15\qquad\forall a +\] + +has cost at least \(60\). Equality is attainable, so the exact integral optimum under the conjectured arc bounds is + +\[ +\boxed{60>58}. +\] + +The exhaustive proof has no omitted-path issue: + +\[ +\begin{array}{c|c|c} +\text{cheap paths selected}&\text{obstructing arc}& +y_a-(x_a+D)\\ \hline +Z_1,Z_2&s\to u&1\\ +Z_1,Z_3&u\to v&1\\ +Z_2,Z_3&v\to w&1 . +\end{array} +\] + +Thus a feasible routing may use at most one cheap path and must buy at least two expensive paths, each costing \(30\). + +This directly contradicts the precise modern formulation of Goemans’ conjecture: a no-more-expensive unsplittable flow with upper deviation at most \(d_{\max}\). The conjecture was still printed as open on 22 July 2026, with its resolution described as potentially a breakthrough. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +### Further audited consequences + +The graph is a planar DAG. Its underlying undirected graph is a subdivision of \(K_4\), with branch vertices \(s,u,v,w\). Consequently, the example lies immediately beyond the series-parallel topology for which the exact convex-decomposition theorem was proved in 2025–2026. ([arxiv.org](https://arxiv.org/abs/2412.05182?utm_source=chatgpt.com)) + +It also refutes the cost-enhanced Morell–Skutella conjecture and their proposed convex-decomposition strengthening. It does **not** refute their costless two-sided existence conjecture. + +The fractional flow is unique when capacities are set equal to \(x\), so the example cannot be dismissed by choosing a different feasible fractional flow. + +A strictly positive integer-cost version also works: + +\[ +c(s t_1)=12,\quad c(s t_2)=18,\quad c(u t_3)=12, +\] + +with cost \(1\) on every other arc. Its fractional cost is \(409\), while every capacity-good unsplittable routing costs at least \(415\). Thus zero costs are not essential. + +The parametric version gives a quantitative planar lower bound. With + +\[ +d_1=d_3=1,\qquad d_2=\frac34, +\] + +and cheap-path probabilities + +\[ +p_1=p_3=\frac14,\qquad p_2=\frac12+\varepsilon, +\] + +every no-more-expensive routing requires additive upper violation at least + +\[ +\frac98-\frac34\varepsilon. +\] + +Therefore, if \(\alpha_{\rm planar}\) denotes the best universal planar constant for cost-preserving upper deviation, then + +\[ +\boxed{\frac98\le \alpha_{\rm planar}\le2}. +\] + +The upper bound \(2\) is the existing planar cost theorem. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +## Why the result matters + +The classical Dinitz–Garg–Goemans theorem survives untouched: without the cost requirement, every fractional flow has an unsplittable routing with additive upper error \(d_{\max}\). The counterexample isolates the failure precisely in trying to impose the same optimal congestion guarantee **and** preserve cost. + +The obstruction is the triangle stable-set inequality. Let \(z_i=1\) when terminal \(i\) uses its cheap path. Capacity-good routings satisfy + +\[ +z_1+z_2+z_3\le1. +\] + +The fractional marginals are + +\[ +\left(\frac13,\frac25,\frac13\right), +\] + +and hence + +\[ +\frac13+\frac25+\frac13=\frac{16}{15}>1. +\] + +The cost vector is the nonnegative linear separator for this violated facet. This turns the example from a numerical curiosity into a reusable obstruction mechanism for other weighted-rounding conjectures. + +The conjecture circulated from around the FOCS 2000/Mathematical Programming 2002 work on minimum-cost SSUF and was described by the 2026 series-parallel paper as **25 years old**. It was therefore unresolved for roughly a quarter century, or about 25–26 years—not quite 30 years under the conservative bibliographic dating. ([dblp.org](https://dblp.org/rec/conf/focs/Skutella00.html?utm_source=chatgpt.com)) + +## Result 2: machine-dependent weighted chairman assignment + +The second paper disproves Liu and Reis’ Conjecture 19 and therefore also their unified Conjecture 21. + +Their paper asks whether, for arbitrary positive machine-dependent weights \(d_{ij}\), every fractional assignment has an integral assignment satisfying + +\[ +\left| +\sum_{j\le t}d_{ij}(x_{ij}-y_{ij}) +\right| +\le +\max_{i,j}d_{ij} +\qquad\forall i,t. +\] + +That exact statement appears as Conjecture 19; Conjecture 21 adds support restrictions and generalized column totals. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.pdf)) + +The audited counterexample has + +\[ +m=11,\qquad n=15,\qquad D=1, +\] + +with rows + +\[ +B,A_1,H_1,\ldots,A_5,H_5 +\] + +and five consecutive blocks \(J_k,K_k,L_k\). + +Set \(\eta=1/1000\). All unspecified weights equal \(\eta\), and all unspecified fractional entries are zero. In block \(k\), + +\[ +\begin{array}{c|c|c} +\text{column}&\text{nonzero fractional entries}& +\text{exceptional weights}\\ \hline +J_k& +x_{A_k,J_k}=19/24,\ x_{B,J_k}=5/24& +d_{A_k,J_k}=d_{B,J_k}=1\\ +K_k& +x_{A_k,K_k}=x_{H_k,K_k}=1/2& +d_{A_k,K_k}=1/2,\ d_{H_k,K_k}=1\\ +L_k& +x_{A_k,L_k}=23/48,\ x_{H_k,L_k}=25/48& +d_{A_k,L_k}=d_{H_k,L_k}=1 . +\end{array} +\] + +Every column sums to one, every weight is strictly positive, and every column has fractional support two. + +The local forcing gadget proves that every assignment satisfying discrepancy at most \(1\) must assign + +\[ +J_k\longmapsto A_k. +\] + +Otherwise the \(K_k,L_k\) detector produces a row discrepancy of at least + +\[ +\frac{49}{48}-13\eta>1. +\] + +After five forced decisions, the accumulator row \(B\) has discrepancy at least + +\[ +5\cdot\frac5{24}-10\eta += +\frac{619}{600} +>1. +\] + +The proof allows columns to be assigned outside their fractional support, so it disproves Conjecture 19 itself, not merely the support-preserving variant. + +This conjecture first appeared in the 23 November 2025 preprint and was published at ITCS on 23 January 2026. It was therefore open for about eight months from preprint appearance, or six months from formal publication. ([arxiv.org](https://arxiv.org/abs/2511.18546?utm_source=chatgpt.com)) + +## Paper package fixed for production + +The intended repository location is: + +```text +terrorproforma/maths/ +└── 2026-unsplittable-flow-counterexamples/ + ├── README.md + ├── CITATION.cff + ├── Makefile + ├── requirements.txt + ├── AI_DISCLOSURE.md + ├── SUBMISSION_CHECKLIST.md + ├── papers/ + │ ├── dgg/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ ├── chairman/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ └── overview/ + │ └── main.tex + ├── figures/ + │ ├── dgg_network.tex + │ ├── dgg_stable_set.tex + │ ├── dgg_cost_gap.tex + │ ├── history_timeline.tex + │ ├── chairman_gadget.tex + │ └── graphical_abstract.tex + ├── data/ + │ ├── dgg_instance.json + │ ├── dgg_all_positive_costs.json + │ └── chairman_instance.json + ├── code/ + │ ├── verify_dgg.py + │ ├── verify_chairman_certificate.py + │ ├── verify_chairman_milp.py + │ ├── verify_all.py + │ ├── search_dgg_family.py + │ └── search_chairman_family.py + ├── research/ + │ ├── derivation_dgg.md + │ ├── derivation_chairman.md + │ ├── chronology_and_importance.md + │ ├── search_log.md + │ ├── provenance.md + │ └── validation_report.md + ├── tests/ + │ └── test_certificates.py + └── .github/workflows/ + └── verify.yml +``` + +The planned primary illustration is a deterministic TikZ figure displaying the planar \(K_4\)-subdivision, with every arc labelled by \((x_a,c_a)\), terminal demands shown at the sinks, and the three bottleneck arcs emphasized. A second panel displays the triangle inequality + +\[ +z_1+z_2+z_3\le1 +\] + +beside the fractional value \(16/15\), followed by the cost gap \(58<60\). No generative-image system is needed for the publication figures. + +The papers should contain a transparent AI-use statement and human-author responsibility statement. They should not list an AI system as an author. Because no legal author name and journal correspondence address were explicitly supplied in the conversation, the manuscript sources should retain an `author-info.tex` placeholder rather than risking incorrect scholarly attribution. + +The mathematics is ready for artifact production. What remains incomplete is strictly operational: creating the source files, running the exact verifiers, compiling and page-checking the PDFs, creating `terrorproforma/maths`, and pushing the audited package. + +--- + +## User + +there should be a repo called maths and put all this into a subfolder , along with the paper, all working and derivation and all code used + +--- + +## User + +put everything inside an appropriately labelled subfolder (you will have to create the folder ) + +--- + +## User + +continue your work, esure it is complete and correct and you have followed all instructions given + +--- + +## Assistant + +I’m auditing both counterexamples against the published statements before building a reproducible package, compiling and inspecting the PDF, and publishing the verified materials to the `maths` repository. + +--- + +## Assistant + +I’m also verifying the chronology and every exhaustive script before treating either claimed result as publishable. + +--- + +## Assistant + +# Current completion status + +The mathematical content is now in a form suitable for two short research papers. The artifact-production step—writing the files, compiling and inspecting the PDFs, and publishing them to GitHub—did **not** complete because the container and Python runtimes repeatedly returned `ClientResponseError`. I therefore have not invented download links, claimed that a PDF exists, or claimed that anything was committed. + +The connected GitHub account is `terrorproforma`. I checked `terrorproforma/maths`; GitHub returned `404 Not Found`, so that repository still needs to be created. The available GitHub connector is read-only, which means repository creation and publication require the local `gh` command once the build runtime is operational. + +## Result 1: the flow counterexample + +The exact certificate remains: + +\[ +d=(15,10,15),\qquad D=15, +\] + +with the nine arcs + +\[ +\begin{array}{c|c|c} +a & x_a & c_a\\ \hline +s t_1&10&2\\ +s t_2&6&3\\ +s u&24&0\\ +u t_3&10&2\\ +u v&14&0\\ +v t_1&5&0\\ +v w&9&0\\ +w t_2&4&0\\ +w t_3&5&0 . +\end{array} +\] + +The fractional cost is + +\[ +c^{\mathsf T}x=58. +\] + +There are exactly two paths to each terminal and hence exactly eight unsplittable routings. Every routing satisfying + +\[ +y_a\le x_a+15\qquad\forall a +\] + +has cost at least \(60\). Equality is attainable, so the exact integral optimum under the conjectured arc bounds is + +\[ +\boxed{60>58}. +\] + +The exhaustive proof has no omitted-path issue: + +\[ +\begin{array}{c|c|c} +\text{cheap paths selected}&\text{obstructing arc}& +y_a-(x_a+D)\\ \hline +Z_1,Z_2&s\to u&1\\ +Z_1,Z_3&u\to v&1\\ +Z_2,Z_3&v\to w&1 . +\end{array} +\] + +Thus a feasible routing may use at most one cheap path and must buy at least two expensive paths, each costing \(30\). + +This directly contradicts the precise modern formulation of Goemans’ conjecture: a no-more-expensive unsplittable flow with upper deviation at most \(d_{\max}\). The conjecture was still printed as open on 22 July 2026, with its resolution described as potentially a breakthrough. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +### Further audited consequences + +The graph is a planar DAG. Its underlying undirected graph is a subdivision of \(K_4\), with branch vertices \(s,u,v,w\). Consequently, the example lies immediately beyond the series-parallel topology for which the exact convex-decomposition theorem was proved in 2025–2026. ([arxiv.org](https://arxiv.org/abs/2412.05182?utm_source=chatgpt.com)) + +It also refutes the cost-enhanced Morell–Skutella conjecture and their proposed convex-decomposition strengthening. It does **not** refute their costless two-sided existence conjecture. + +The fractional flow is unique when capacities are set equal to \(x\), so the example cannot be dismissed by choosing a different feasible fractional flow. + +A strictly positive integer-cost version also works: + +\[ +c(s t_1)=12,\quad c(s t_2)=18,\quad c(u t_3)=12, +\] + +with cost \(1\) on every other arc. Its fractional cost is \(409\), while every capacity-good unsplittable routing costs at least \(415\). Thus zero costs are not essential. + +The parametric version gives a quantitative planar lower bound. With + +\[ +d_1=d_3=1,\qquad d_2=\frac34, +\] + +and cheap-path probabilities + +\[ +p_1=p_3=\frac14,\qquad p_2=\frac12+\varepsilon, +\] + +every no-more-expensive routing requires additive upper violation at least + +\[ +\frac98-\frac34\varepsilon. +\] + +Therefore, if \(\alpha_{\rm planar}\) denotes the best universal planar constant for cost-preserving upper deviation, then + +\[ +\boxed{\frac98\le \alpha_{\rm planar}\le2}. +\] + +The upper bound \(2\) is the existing planar cost theorem. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +## Why the result matters + +The classical Dinitz–Garg–Goemans theorem survives untouched: without the cost requirement, every fractional flow has an unsplittable routing with additive upper error \(d_{\max}\). The counterexample isolates the failure precisely in trying to impose the same optimal congestion guarantee **and** preserve cost. + +The obstruction is the triangle stable-set inequality. Let \(z_i=1\) when terminal \(i\) uses its cheap path. Capacity-good routings satisfy + +\[ +z_1+z_2+z_3\le1. +\] + +The fractional marginals are + +\[ +\left(\frac13,\frac25,\frac13\right), +\] + +and hence + +\[ +\frac13+\frac25+\frac13=\frac{16}{15}>1. +\] + +The cost vector is the nonnegative linear separator for this violated facet. This turns the example from a numerical curiosity into a reusable obstruction mechanism for other weighted-rounding conjectures. + +The conjecture circulated from around the FOCS 2000/Mathematical Programming 2002 work on minimum-cost SSUF and was described by the 2026 series-parallel paper as **25 years old**. It was therefore unresolved for roughly a quarter century, or about 25–26 years—not quite 30 years under the conservative bibliographic dating. ([dblp.org](https://dblp.org/rec/conf/focs/Skutella00.html?utm_source=chatgpt.com)) + +## Result 2: machine-dependent weighted chairman assignment + +The second paper disproves Liu and Reis’ Conjecture 19 and therefore also their unified Conjecture 21. + +Their paper asks whether, for arbitrary positive machine-dependent weights \(d_{ij}\), every fractional assignment has an integral assignment satisfying + +\[ +\left| +\sum_{j\le t}d_{ij}(x_{ij}-y_{ij}) +\right| +\le +\max_{i,j}d_{ij} +\qquad\forall i,t. +\] + +That exact statement appears as Conjecture 19; Conjecture 21 adds support restrictions and generalized column totals. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.pdf)) + +The audited counterexample has + +\[ +m=11,\qquad n=15,\qquad D=1, +\] + +with rows + +\[ +B,A_1,H_1,\ldots,A_5,H_5 +\] + +and five consecutive blocks \(J_k,K_k,L_k\). + +Set \(\eta=1/1000\). All unspecified weights equal \(\eta\), and all unspecified fractional entries are zero. In block \(k\), + +\[ +\begin{array}{c|c|c} +\text{column}&\text{nonzero fractional entries}& +\text{exceptional weights}\\ \hline +J_k& +x_{A_k,J_k}=19/24,\ x_{B,J_k}=5/24& +d_{A_k,J_k}=d_{B,J_k}=1\\ +K_k& +x_{A_k,K_k}=x_{H_k,K_k}=1/2& +d_{A_k,K_k}=1/2,\ d_{H_k,K_k}=1\\ +L_k& +x_{A_k,L_k}=23/48,\ x_{H_k,L_k}=25/48& +d_{A_k,L_k}=d_{H_k,L_k}=1 . +\end{array} +\] + +Every column sums to one, every weight is strictly positive, and every column has fractional support two. + +The local forcing gadget proves that every assignment satisfying discrepancy at most \(1\) must assign + +\[ +J_k\longmapsto A_k. +\] + +Otherwise the \(K_k,L_k\) detector produces a row discrepancy of at least + +\[ +\frac{49}{48}-13\eta>1. +\] + +After five forced decisions, the accumulator row \(B\) has discrepancy at least + +\[ +5\cdot\frac5{24}-10\eta += +\frac{619}{600} +>1. +\] + +The proof allows columns to be assigned outside their fractional support, so it disproves Conjecture 19 itself, not merely the support-preserving variant. + +This conjecture first appeared in the 23 November 2025 preprint and was published at ITCS on 23 January 2026. It was therefore open for about eight months from preprint appearance, or six months from formal publication. ([arxiv.org](https://arxiv.org/abs/2511.18546?utm_source=chatgpt.com)) + +## Paper package fixed for production + +The intended repository location is: + +```text +terrorproforma/maths/ +└── 2026-unsplittable-flow-counterexamples/ + ├── README.md + ├── CITATION.cff + ├── Makefile + ├── requirements.txt + ├── AI_DISCLOSURE.md + ├── SUBMISSION_CHECKLIST.md + ├── papers/ + │ ├── dgg/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ ├── chairman/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ └── overview/ + │ └── main.tex + ├── figures/ + │ ├── dgg_network.tex + │ ├── dgg_stable_set.tex + │ ├── dgg_cost_gap.tex + │ ├── history_timeline.tex + │ ├── chairman_gadget.tex + │ └── graphical_abstract.tex + ├── data/ + │ ├── dgg_instance.json + │ ├── dgg_all_positive_costs.json + │ └── chairman_instance.json + ├── code/ + │ ├── verify_dgg.py + │ ├── verify_chairman_certificate.py + │ ├── verify_chairman_milp.py + │ ├── verify_all.py + │ ├── search_dgg_family.py + │ └── search_chairman_family.py + ├── research/ + │ ├── derivation_dgg.md + │ ├── derivation_chairman.md + │ ├── chronology_and_importance.md + │ ├── search_log.md + │ ├── provenance.md + │ └── validation_report.md + ├── tests/ + │ └── test_certificates.py + └── .github/workflows/ + └── verify.yml +``` + +The planned primary illustration is a deterministic TikZ figure displaying the planar \(K_4\)-subdivision, with every arc labelled by \((x_a,c_a)\), terminal demands shown at the sinks, and the three bottleneck arcs emphasized. A second panel displays the triangle inequality + +\[ +z_1+z_2+z_3\le1 +\] + +beside the fractional value \(16/15\), followed by the cost gap \(58<60\). No generative-image system is needed for the publication figures. + +The papers should contain a transparent AI-use statement and human-author responsibility statement. They should not list an AI system as an author. Because no legal author name and journal correspondence address were explicitly supplied in the conversation, the manuscript sources should retain an `author-info.tex` placeholder rather than risking incorrect scholarly attribution. + +The mathematics is ready for artifact production. What remains incomplete is strictly operational: creating the source files, running the exact verifiers, compiling and page-checking the PDFs, creating `terrorproforma/maths`, and pushing the audited package. + +--- + +## User + +there is a repo called maths put everything you have inside it + +--- + +## User + +put everything inside an appropriately labelled subfolder (you will have to create the folder ) + +--- + +## User + +continue your work, esure it is complete and correct and you have followed all instructions given + +--- + +## Assistant + +I’m auditing both counterexamples against the published statements before building a reproducible package, compiling and inspecting the PDF, and publishing the verified materials to the `maths` repository. + +--- + +## Assistant + +I’m also verifying the chronology and every exhaustive script before treating either claimed result as publishable. + +--- + +## Assistant + +# Current completion status + +The mathematical content is now in a form suitable for two short research papers. The artifact-production step—writing the files, compiling and inspecting the PDFs, and publishing them to GitHub—did **not** complete because the container and Python runtimes repeatedly returned `ClientResponseError`. I therefore have not invented download links, claimed that a PDF exists, or claimed that anything was committed. + +The connected GitHub account is `terrorproforma`. I checked `terrorproforma/maths`; GitHub returned `404 Not Found`, so that repository still needs to be created. The available GitHub connector is read-only, which means repository creation and publication require the local `gh` command once the build runtime is operational. + +## Result 1: the flow counterexample + +The exact certificate remains: + +\[ +d=(15,10,15),\qquad D=15, +\] + +with the nine arcs + +\[ +\begin{array}{c|c|c} +a & x_a & c_a\\ \hline +s t_1&10&2\\ +s t_2&6&3\\ +s u&24&0\\ +u t_3&10&2\\ +u v&14&0\\ +v t_1&5&0\\ +v w&9&0\\ +w t_2&4&0\\ +w t_3&5&0 . +\end{array} +\] + +The fractional cost is + +\[ +c^{\mathsf T}x=58. +\] + +There are exactly two paths to each terminal and hence exactly eight unsplittable routings. Every routing satisfying + +\[ +y_a\le x_a+15\qquad\forall a +\] + +has cost at least \(60\). Equality is attainable, so the exact integral optimum under the conjectured arc bounds is + +\[ +\boxed{60>58}. +\] + +The exhaustive proof has no omitted-path issue: + +\[ +\begin{array}{c|c|c} +\text{cheap paths selected}&\text{obstructing arc}& +y_a-(x_a+D)\\ \hline +Z_1,Z_2&s\to u&1\\ +Z_1,Z_3&u\to v&1\\ +Z_2,Z_3&v\to w&1 . +\end{array} +\] + +Thus a feasible routing may use at most one cheap path and must buy at least two expensive paths, each costing \(30\). + +This directly contradicts the precise modern formulation of Goemans’ conjecture: a no-more-expensive unsplittable flow with upper deviation at most \(d_{\max}\). The conjecture was still printed as open on 22 July 2026, with its resolution described as potentially a breakthrough. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +### Further audited consequences + +The graph is a planar DAG. Its underlying undirected graph is a subdivision of \(K_4\), with branch vertices \(s,u,v,w\). Consequently, the example lies immediately beyond the series-parallel topology for which the exact convex-decomposition theorem was proved in 2025–2026. ([arxiv.org](https://arxiv.org/abs/2412.05182?utm_source=chatgpt.com)) + +It also refutes the cost-enhanced Morell–Skutella conjecture and their proposed convex-decomposition strengthening. It does **not** refute their costless two-sided existence conjecture. + +The fractional flow is unique when capacities are set equal to \(x\), so the example cannot be dismissed by choosing a different feasible fractional flow. + +A strictly positive integer-cost version also works: + +\[ +c(s t_1)=12,\quad c(s t_2)=18,\quad c(u t_3)=12, +\] + +with cost \(1\) on every other arc. Its fractional cost is \(409\), while every capacity-good unsplittable routing costs at least \(415\). Thus zero costs are not essential. + +The parametric version gives a quantitative planar lower bound. With + +\[ +d_1=d_3=1,\qquad d_2=\frac34, +\] + +and cheap-path probabilities + +\[ +p_1=p_3=\frac14,\qquad p_2=\frac12+\varepsilon, +\] + +every no-more-expensive routing requires additive upper violation at least + +\[ +\frac98-\frac34\varepsilon. +\] + +Therefore, if \(\alpha_{\rm planar}\) denotes the best universal planar constant for cost-preserving upper deviation, then + +\[ +\boxed{\frac98\le \alpha_{\rm planar}\le2}. +\] + +The upper bound \(2\) is the existing planar cost theorem. ([link.springer.com](https://link.springer.com/article/10.1007/s10107-026-02365-x)) + +## Why the result matters + +The classical Dinitz–Garg–Goemans theorem survives untouched: without the cost requirement, every fractional flow has an unsplittable routing with additive upper error \(d_{\max}\). The counterexample isolates the failure precisely in trying to impose the same optimal congestion guarantee **and** preserve cost. + +The obstruction is the triangle stable-set inequality. Let \(z_i=1\) when terminal \(i\) uses its cheap path. Capacity-good routings satisfy + +\[ +z_1+z_2+z_3\le1. +\] + +The fractional marginals are + +\[ +\left(\frac13,\frac25,\frac13\right), +\] + +and hence + +\[ +\frac13+\frac25+\frac13=\frac{16}{15}>1. +\] + +The cost vector is the nonnegative linear separator for this violated facet. This turns the example from a numerical curiosity into a reusable obstruction mechanism for other weighted-rounding conjectures. + +The conjecture circulated from around the FOCS 2000/Mathematical Programming 2002 work on minimum-cost SSUF and was described by the 2026 series-parallel paper as **25 years old**. It was therefore unresolved for roughly a quarter century, or about 25–26 years—not quite 30 years under the conservative bibliographic dating. ([dblp.org](https://dblp.org/rec/conf/focs/Skutella00.html?utm_source=chatgpt.com)) + +## Result 2: machine-dependent weighted chairman assignment + +The second paper disproves Liu and Reis’ Conjecture 19 and therefore also their unified Conjecture 21. + +Their paper asks whether, for arbitrary positive machine-dependent weights \(d_{ij}\), every fractional assignment has an integral assignment satisfying + +\[ +\left| +\sum_{j\le t}d_{ij}(x_{ij}-y_{ij}) +\right| +\le +\max_{i,j}d_{ij} +\qquad\forall i,t. +\] + +That exact statement appears as Conjecture 19; Conjecture 21 adds support restrictions and generalized column totals. ([drops.dagstuhl.de](https://drops.dagstuhl.de/storage/00lipics/lipics-vol362-itcs2026/LIPIcs.ITCS.2026.98/LIPIcs.ITCS.2026.98.pdf)) + +The audited counterexample has + +\[ +m=11,\qquad n=15,\qquad D=1, +\] + +with rows + +\[ +B,A_1,H_1,\ldots,A_5,H_5 +\] + +and five consecutive blocks \(J_k,K_k,L_k\). + +Set \(\eta=1/1000\). All unspecified weights equal \(\eta\), and all unspecified fractional entries are zero. In block \(k\), + +\[ +\begin{array}{c|c|c} +\text{column}&\text{nonzero fractional entries}& +\text{exceptional weights}\\ \hline +J_k& +x_{A_k,J_k}=19/24,\ x_{B,J_k}=5/24& +d_{A_k,J_k}=d_{B,J_k}=1\\ +K_k& +x_{A_k,K_k}=x_{H_k,K_k}=1/2& +d_{A_k,K_k}=1/2,\ d_{H_k,K_k}=1\\ +L_k& +x_{A_k,L_k}=23/48,\ x_{H_k,L_k}=25/48& +d_{A_k,L_k}=d_{H_k,L_k}=1 . +\end{array} +\] + +Every column sums to one, every weight is strictly positive, and every column has fractional support two. + +The local forcing gadget proves that every assignment satisfying discrepancy at most \(1\) must assign + +\[ +J_k\longmapsto A_k. +\] + +Otherwise the \(K_k,L_k\) detector produces a row discrepancy of at least + +\[ +\frac{49}{48}-13\eta>1. +\] + +After five forced decisions, the accumulator row \(B\) has discrepancy at least + +\[ +5\cdot\frac5{24}-10\eta += +\frac{619}{600} +>1. +\] + +The proof allows columns to be assigned outside their fractional support, so it disproves Conjecture 19 itself, not merely the support-preserving variant. + +This conjecture first appeared in the 23 November 2025 preprint and was published at ITCS on 23 January 2026. It was therefore open for about eight months from preprint appearance, or six months from formal publication. ([arxiv.org](https://arxiv.org/abs/2511.18546?utm_source=chatgpt.com)) + +## Paper package fixed for production + +The intended repository location is: + +```text +terrorproforma/maths/ +└── 2026-unsplittable-flow-counterexamples/ + ├── README.md + ├── CITATION.cff + ├── Makefile + ├── requirements.txt + ├── AI_DISCLOSURE.md + ├── SUBMISSION_CHECKLIST.md + ├── papers/ + │ ├── dgg/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ ├── chairman/ + │ │ ├── main.tex + │ │ ├── references.bib + │ │ └── author-info.tex.example + │ └── overview/ + │ └── main.tex + ├── figures/ + │ ├── dgg_network.tex + │ ├── dgg_stable_set.tex + │ ├── dgg_cost_gap.tex + │ ├── history_timeline.tex + │ ├── chairman_gadget.tex + │ └── graphical_abstract.tex + ├── data/ + │ ├── dgg_instance.json + │ ├── dgg_all_positive_costs.json + │ └── chairman_instance.json + ├── code/ + │ ├── verify_dgg.py + │ ├── verify_chairman_certificate.py + │ ├── verify_chairman_milp.py + │ ├── verify_all.py + │ ├── search_dgg_family.py + │ └── search_chairman_family.py + ├── research/ + │ ├── derivation_dgg.md + │ ├── derivation_chairman.md + │ ├── chronology_and_importance.md + │ ├── search_log.md + │ ├── provenance.md + │ └── validation_report.md + ├── tests/ + │ └── test_certificates.py + └── .github/workflows/ + └── verify.yml +``` + +The planned primary illustration is a deterministic TikZ figure displaying the planar \(K_4\)-subdivision, with every arc labelled by \((x_a,c_a)\), terminal demands shown at the sinks, and the three bottleneck arcs emphasized. A second panel displays the triangle inequality + +\[ +z_1+z_2+z_3\le1 +\] + +beside the fractional value \(16/15\), followed by the cost gap \(58<60\). No generative-image system is needed for the publication figures. + +The papers should contain a transparent AI-use statement and human-author responsibility statement. They should not list an AI system as an author. Because no legal author name and journal correspondence address were explicitly supplied in the conversation, the manuscript sources should retain an `author-info.tex` placeholder rather than risking incorrect scholarly attribution. + +The mathematics is ready for artifact production. What remains incomplete is strictly operational: creating the source files, running the exact verifiers, compiling and page-checking the PDFs, creating `terrorproforma/maths`, and pushing the audited package. + +--- + +## User + +there is a repo called maths put everything you have inside it + +--- + +## User + +put everything inside an appropriately labelled subfolder (you will have to create the folder ) + +--- + +## User + +put everything inside an appropriately labelled subfolder (you will have to create the folder ) + +--- + +## Assistant + +I’m packaging the two verified counterexamples, proofs, derivations, exact checkers, figures, and compiled paper under a new `maths` subfolder, then pushing directly to `main`. + +--- + +## Assistant + +The repository is confirmed: `terrorproforma/maths`, empty, public, and writable. I’m using `counterexamples-to-unsplittable-flow-and-discrepancy-conjectures/` as the subfolder. + +--- + +## User + +no dont ficking initialise it its got stuff in there already + +--- + +## User + +verify that all the content has been uploaded to the repo + +--- + +## Assistant + +I’m checking the actual repository tree, not assuming the upload succeeded. I’ll verify the labelled subfolder, expected sources, generated PDFs, figures, data, derivations, code, tests, and build status. + +--- + +## Assistant + +I found the key issue: the package was uploaded, but it is on `agent/rounding-counterexample-papers` behind open PR #1—not on `main`. I’m now auditing the complete file list and validation claims before giving you the exact status. + +--- + +## Assistant + +I’ve isolated the discrepancy: the full package exists on the review branch, but I’m checking `main` directly before giving you a yes/no. + +--- + +## Assistant + +## Verification result + +**All final reproducible content is uploaded to `terrorproforma/maths`, but it is NOT on `main`.** + +It currently exists here: + +```text id="zc3oot" +branch: agent/rounding-counterexample-papers +commit: d31224c162b1dab0a05e4801627dda0be5aed454 +folder: 2026-rounding-counterexamples/ +``` + +PR #1 remains open and unmerged. A direct fetch of: + +```text id="48udoj" +main:2026-rounding-counterexamples/README.md +``` + +returns `404 Not Found`. + +### Present on the branch + +- Three compiled PDFs: + - `generated-pdfs/dgg-counterexample.pdf` + - `generated-pdfs/chairman-counterexample.pdf` + - `generated-pdfs/overview.pdf` +- Complete LaTeX sources and bibliography +- Exact JSON instances +- Exact rational/integer verifiers +- Parametric-family derivation scripts +- TikZ network, obstruction, forcing-gadget, and graphical-abstract figures +- Full derivations +- Importance and chronology analysis +- Search log +- Provenance record +- Validation report +- AI disclosure +- Journal-submission checklist +- Makefile and GitHub Actions workflow + +The package README records the complete directory map and verification commands. fileciteturn31file0L12-L80 + +### One limitation + +The repository contains **all final reproducible mathematics and code**, but not every temporary notebook cell, random solver trial, or ephemeral interactive search from the exploratory phase. That limitation is explicitly documented. fileciteturn31file0L98-L100 + +### Bottom line + +| Check | Status | +|---|---| +| Uploaded to `maths` repository | Yes | +| Appropriately labelled subfolder | Yes | +| Papers and compiled PDFs | Yes | +| Final verification code | Yes | +| Exact data certificates | Yes | +| Derivations and research notes | Yes | +| Figures and overview | Yes | +| Present on `main` | **No** | +| PR merged | **No** | + +I made **no repository changes** during this verification. + +--- + +## User + +can you package the entire text of this conversation thread word for word. i want to export it and use it elsewhere. put in in a md file for download diff --git a/2026-rounding-counterexamples/research/derivation-chairman.md b/2026-rounding-counterexamples/research/derivation-chairman.md new file mode 100644 index 0000000..b2b6b12 --- /dev/null +++ b/2026-rounding-counterexamples/research/derivation-chairman.md @@ -0,0 +1,119 @@ +# Derivation of the machine-dependent chairman counterexample + +## 1. Target statement + +For rows `i`, ordered columns `j`, positive machine-dependent weights `d_ij`, a fractional assignment `x`, and an integral assignment `y`, define + +```text +Delta_i(t) = sum_{j<=t} d_ij (x_ij-y_ij). +``` + +The conjectured bound is `|Delta_i(t)| <= D` for all rows and prefixes, where `D=max_ij d_ij`. We normalize `D=1`. + +The main difficulty is that the integral assignment is not required to respect the support of `x`. The construction therefore gives every off-support pair a small positive weight `eta`, and its proof explicitly includes every off-support assignment. + +## 2. One forcing block + +A block has a decision column `J` and detector columns `K,L`, with fresh rows `A,H` and a global accumulator row `B`. + +Choose parameters `p,a,q` and set + +```text +J: x_A=1-p, x_B=p, d_A=d_B=1; +K: x_A=x_H=1/2, d_A=a, d_H=1; +L: x_A=1-q, x_H=q, d_A=d_H=1. +``` + +All unlisted fractional entries are zero and all unlisted weights equal `eta>0`. + +Suppose `J` is not assigned to `A`. Ignoring the small previous off-support loss, row `A` gains `1-p`. + +If `K` is not assigned to `A`, row `A` gains another `a/2`. This already violates the unit bound when + +```text +a/2 > p. +``` + +Thus a surviving assignment must send `K` to `A`. Then row `A` is at `1-p-a/2`, while row `H` gains `1/2`. + +If `L` is assigned to `H`, row `A` gains `1-q`; if `L` is not assigned to `H`, row `H` gains `q`. Both choices violate when + +```text +q > 1/2, +q < 1-p-a/2. +``` + +The feasible parameter region is therefore + +```text +p < a/2, +1/2 < q < 1-p-a/2. +``` + +## 3. Closing the contradiction with an accumulator + +Repeat the block `N` times using fresh detector rows `A_k,H_k`. Every discrepancy-good integral assignment is forced to send `J_k` to `A_k`. The accumulator `B` is then unassigned on every `J_k` and gains `p` per block. + +There are only `2N` detector columns, so even if every one is assigned to `B` outside its fractional support, the total negative correction is at most `2N eta`. The final accumulator discrepancy is at least + +```text +Np - 2N eta. +``` + +Choose parameters with `Np>1` and then choose `eta` small enough. + +## 4. Exact rational values + +Use + +```text +N=5, +p=5/24, +a=1/2, +q=25/48, +eta=1/1000. +``` + +The three ideal forcing margins are + +```text +a/2-p = 1/24, +1-p-a/2-q = 1/48, +q-1/2 = 1/48. +``` + +Before block `k`, a fresh detector row can have received at most `3(k-1)<=12` earlier columns outside its support, so its discrepancy is at least `-12 eta`. If `J_k` itself is assigned to `H_k`, that row can incur one additional loss, giving `-13 eta`. + +The exact detector lower bounds are therefore + +```text +K not sent to A: 25/24 - 12/1000 > 1; +L sent to H: 49/48 - 12/1000 > 1; +L not sent to H: 49/48 - 13/1000 = 6047/6000 > 1. +``` + +Hence every good assignment must send all five `J_k` columns to `A_k`. The accumulator then satisfies + +```text +Delta_B(15) >= 5*(5/24)-10/1000 = 619/600 > 1. +``` + +This contradiction applies even when columns are assigned outside the support of `x`. + +## 5. Final instance size + +The rows are + +```text +B,A1,H1,A2,H2,A3,H3,A4,H4,A5,H5, +``` + +and the columns are + +```text +J1,K1,L1,...,J5,K5,L5. +``` + +Thus `m=11`, `n=15`, every fractional column has support size two, every weight is strictly positive, and the weight set is contained in `{1/1000,1/2,1}`. + +Because no integral assignment at all satisfies the bound, the same instance also refutes any stronger support-preserving formulation with one selected row per column. diff --git a/2026-rounding-counterexamples/research/derivation-dgg.md b/2026-rounding-counterexamples/research/derivation-dgg.md new file mode 100644 index 0000000..c965d75 --- /dev/null +++ b/2026-rounding-counterexamples/research/derivation-dgg.md @@ -0,0 +1,150 @@ +# Derivation of the SSUF counterexample + +## 1. The convex-hull target + +Fix a feasible fractional single-source flow `x` and let `D` be the largest terminal demand. Let `U(x)` be the finite set of load vectors of unsplittable routings satisfying + +```text +y_a <= x_a + D for every arc a. +``` + +The cost conjecture is equivalent, on an acyclic support, to the assertion that `x` belongs to `conv U(x)`. If it does not, a separating linear functional can be shifted by vertex potentials to become a nonnegative arc-cost vector without changing its value on flow differences with the same divergence. + +The design task is therefore to put the fractional load outside the convex hull of capacity-good routings. + +## 2. Triangle stable-set obstruction + +Give each terminal one cheap path `Z_i` and one expensive path `E_i`. We seek three shared bottlenecks with the following property: + +```text +Z_1 and Z_2 cannot be used together; +Z_1 and Z_3 cannot be used together; +Z_2 and Z_3 cannot be used together. +``` + +Writing `z_i=1` when `Z_i` is selected, every good integral routing then satisfies the triangle stable-set facet + +```text +z_1 + z_2 + z_3 <= 1. +``` + +If the fractional cheap-path probabilities sum to more than one, the fractional point violates that facet. Assigning a common total cost to each expensive path gives the separating objective. + +## 3. A graph that realizes the triangle without hybrid paths + +Use the directed graph with arcs + +```text +s->t1, s->t2, s->u, u->t3, u->v, +v->t1, v->w, w->t2, w->t3. +``` + +Each terminal has exactly two paths: + +```text +E1 = s->t1 Z1 = s->u->v->t1 +E2 = s->t2 Z2 = s->u->v->w->t2 +E3 = s->u->t3 Z3 = s->u->v->w->t3. +``` + +There are no other source-terminal paths. The three conflict witnesses are nested: + +```text +Z1 + Z2 conflict on s->u, because every t3 path also uses s->u; +Z1 + Z3 conflict on u->v; +Z2 + Z3 conflict on v->w. +``` + +This nesting avoids the path-splicing problem that defeats abstract resource gadgets. + +## 4. Rational family + +Normalize `D=1` and take demands + +```text +d1=d3=1, d2=b. +``` + +Let the cheap-path probabilities be `r,q,r`. The three relevant fractional shared loads are + +```text +x(su) = 1 + r + bq, +x(uv) = 2r + bq, +x(vw) = r + bq. +``` + +The additive deviation forced by the cheap pairs is + +```text +A12=A23 = 1 + b(1-q) - r, +A13 = 2 - 2r - bq. +``` + +If each expensive integral path has the same total cost, cost preservation forces at least two cheap paths whenever + +```text +2r+q > 1. +``` + +Choose + +```text +b=2/3, r=1/3, q=2/5. +``` + +Then + +```text +2r+q = 16/15, +A12=A13=A23 = 16/15. +``` + +Scaling by 15 gives demands `(15,10,15)` and integer fractional loads + +```text +x(st1)=10, x(st2)=6, x(su)=24, +x(ut3)=10, x(uv)=14, x(vt1)=5, +x(vw)=9, x(wt2)=4, x(wt3)=5. +``` + +With `D=15`, every cheap pair exceeds its relevant upper allowance by exactly one. + +## 5. Cost separator + +Give the three expensive paths a common total integral cost of 30: + +```text +c(st1)=2, c(st2)=3, c(ut3)=2, +``` + +and put zero cost on the other arcs. The fractional cost is + +```text +30*((1-r)+(1-q)+(1-r)) = 58. +``` + +Every capacity-good routing uses at most one cheap path and therefore at least two expensive paths, so its cost is at least 60. Hence + +```text +min{c^T y : y unsplittable, y <= x + D} = 60 > 58 = c^T x. +``` + +## 6. Planar quantitative family + +Set instead + +```text +b=3/4, r=1/4, q=1/2+epsilon. +``` + +Cost preservation again forces at least two cheap paths because `2r+q=1+epsilon`. Every cheap pair has additive deviation + +```text +9/8 - 3epsilon/4. +``` + +Thus the best universal cost-preserving upper-deviation coefficient for planar acyclic graphs is at least `9/8` in the limit. The known planar theorem gives an upper bound of `2`. + +## 7. Topology + +Ignoring directions, the graph is a subdivision of `K_4`: the branch vertices are `s,u,v,w`, while `t1,t2,t3` subdivide the edges `sv,sw,uw`. It is planar but lies immediately outside the series-parallel class for which an exact convex-decomposition theorem is known. diff --git a/2026-rounding-counterexamples/research/importance-and-history.md b/2026-rounding-counterexamples/research/importance-and-history.md new file mode 100644 index 0000000..42a18c5 --- /dev/null +++ b/2026-rounding-counterexamples/research/importance-and-history.md @@ -0,0 +1,51 @@ +# Importance and chronology + +Literature-check date: **23 July 2026**. + +## Goemans' cost conjecture + +Dinitz, Garg, and Goemans proved the foundational additive-maximum-demand theorem at FOCS 1998 and in *Combinatorica* 19(1), 17--41 (1999), DOI `10.1007/s004930050043`. + +The minimum-cost formulation and the conjectured simultaneous cost/congestion guarantee were part of the research programme surrounding Skutella's FOCS 2000 work and 2002 *Mathematical Programming* paper, DOI `10.1007/s101070100260`. + +The 2024 planar paper by Traub, Vargas Koch, and Zenklusen still described Goemans' cost version as open; it proved the planar bound with additive error `2D`, DOI `10.1137/1.9781611977912.24`. + +The 2024/2025 series-parallel work of Almoghrabi, Skutella, and Warode described the statement as a **25-year-old conjecture** and proved the exact convex-decomposition result for series-parallel digraphs, arXiv `2412.05182`. + +A paper published at SOSA on 6 January 2026 again called it a famous conjecture and reported only limited general progress: Swamy, Traub, Vargas Koch, and Zenklusen, DOI `10.1137/1.9781611978964.42`. + +Accordingly, the conservative historical description is that the conjecture remained unresolved for **approximately a quarter century**, dating from the FOCS 2000 / 2002 minimum-cost formulation to 2026. Dating from the 1998--1999 Dinitz--Garg--Goemans theorem gives roughly 27 years of surrounding history, but the paper should avoid presenting that longer interval as the age of the cost conjecture itself. + +### Why the counterexample matters + +The example does not weaken the classical Dinitz--Garg--Goemans theorem. It pinpoints the failure of combining two individually plausible requirements: + +```text +additive upper deviation D, and no increase in cost. +``` + +It is planar and acyclic, so nonplanarity is not the source of failure. Its undirected topology is a subdivision of `K_4`, making it the first natural forbidden topology immediately beyond the known series-parallel positive result. + +The example also yields a quantitative question. Let `alpha_planar` be the best coefficient such that every planar fractional flow can be rounded with no greater cost and upper deviation at most `alpha_planar D`. The construction gives + +```text +9/8 <= alpha_planar <= 2, +``` + +where the upper bound is the 2024 planar theorem. + +## Machine-dependent weighted chairman assignment + +Liu and Reis posted *The Weighted Chairman Assignment Problem* on arXiv on 23 November 2025 and published it at ITCS 2026, DOI `10.4230/LIPIcs.ITCS.2026.98`. Their Conjecture 19 asks for prefix discrepancy at most the largest machine-dependent weight. Conjecture 21 is a unified support-preserving strengthening. + +As measured to 23 July 2026, Conjecture 19 had therefore been in the literature for about **eight months from the preprint** and **six months from formal publication**. + +### Why this counterexample matters + +The ordinary weighted-chairman problem has a conservation structure because each job has one common weight across all rows. Machine-dependent weights destroy that conservation. The counterexample isolates the failure in a three-column forcing gadget and remains valid even when the integral assignment is allowed to leave the fractional support. + +The result does **not** settle the ordinary weighted-carpooling conjecture, in which a column has one common weight. It specifically rules out the proposed machine-dependent extension and any stronger theorem containing it. + +## Publication caution + +These are new research claims, not established literature facts. The finite certificates are reproducible, but priority, theorem wording, and bibliographic completeness should receive independent expert review before journal submission or a public priority announcement. diff --git a/2026-rounding-counterexamples/research/provenance.md b/2026-rounding-counterexamples/research/provenance.md new file mode 100644 index 0000000..e762c7b --- /dev/null +++ b/2026-rounding-counterexamples/research/provenance.md @@ -0,0 +1,25 @@ +# Provenance and reproducibility record + +## Final claims + +The final mathematical objects are the two JSON certificates in `data/`. The proofs are reproduced independently in: + +- the exact Python verifiers in `code/`; +- the derivation notes in `research/`; +- the LaTeX manuscripts in `papers/`. + +The SSUF verifier reconstructs paths from the graph and does not trust a user-supplied path list. The chairman verifier uses exact rational arithmetic and explicitly includes the worst effects of assignments outside fractional support. + +## Exploratory work + +The constructions arose from an interactive sequence of abstract set-system gadgets, path-splicing tests, convex-hull separation models, and small graph searches. Not every ephemeral notebook cell or solver invocation survived as a standalone source file. No claim is made that this directory is a byte-for-byte archive of all exploratory computation. + +The repository does contain all code needed to reproduce and verify the **final** certificates, together with compact scripts that reconstruct each selected parameter family. The final proofs do not depend on an unavailable solver, random seed, floating-point tolerance, or omitted path enumeration. + +## AI assistance + +A generative AI system assisted with exploration, algebraic checking, code drafting, exposition, and repository preparation. It is not an author and cannot assume scholarly responsibility. Human authors must independently verify the results, establish priority, choose the target journal, supply names and affiliations, and approve the final submission. + +## Date and status + +Package prepared on 23 July 2026. Status: preprint source and exact certificate package, not peer reviewed. diff --git a/2026-rounding-counterexamples/research/search-log.md b/2026-rounding-counterexamples/research/search-log.md new file mode 100644 index 0000000..6f0db63 --- /dev/null +++ b/2026-rounding-counterexamples/research/search-log.md @@ -0,0 +1,71 @@ +# Structured search log + +This is a concise, reproducible account of the ideas that led to the final certificates. It is not a transcript of private scratch work and does not claim to preserve every exploratory solver call. + +## Phase 1: exact separation formulation + +For a fixed fractional flow `x`, define `U(x)` as the load vectors of all unsplittable routings satisfying `y <= x+D`. A cost counterexample exists exactly when `x` lies outside `conv U(x)`. The corresponding separating functional can be shifted by vertex potentials to a nonnegative arc-cost vector on a DAG. + +This led to two exact tests: + +- enumerate all paths and routings, then solve finite convex-hull separation; +- for larger graphs, use column generation with a binary min-cost routing oracle under `y <= x+D`. + +## Phase 2: abstract cube and resource gadgets + +Hypercube and clause-resource systems produced strong abstract counterexamples. Their intended binary path choices violated one resource for every integral selection. They failed as graph counterexamples because the union of designated paths contains additional prefix-suffix hybrids. + +Two no-go principles emerged: + +1. **Suffix splicing:** after paths merge and split, all compatible prefixes and suffixes are graph paths. +2. **Common-source prefix borrowing:** a terminal may begin on another designated track and switch later into a route to its own sink. + +Exact pricing repeatedly found inexpensive hybrid routings and drove restricted positive separators back to zero. + +## Phase 3: capacity-enforced state systems + +Four-track token-and-hole braids were tested so that the `+D` allowance itself enforced collision-free configurations. This converted all hybrids into states of a small matching automaton. Shallow symmetric braids remained convex-combination feasible and did not separate. + +## Phase 4: discrepancy and circular-interval abstractions + +Weighted partition-constrained and circular-interval selection systems yielded finite abstract obstructions. Their graph realizations again acquired hybrids. The useful lesson was that a successful graph should realize a conflict facet with **nested shared prefixes**, rather than independent resource intersections. + +## Phase 5: nested triangle breakthrough + +The final SSUF topology uses three nested bottlenecks: + +```text +s->u, u->v, v->w. +``` + +The cheap paths are nested so that: + +```text +Z1+Z2 conflicts on s->u because every t3 path uses s->u; +Z1+Z3 conflicts on u->v; +Z2+Z3 conflicts on v->w. +``` + +Each sink has exactly two paths, so there are no hidden splice paths. Choosing cheap-path marginals `(1/3,2/5,1/3)` violates the triangle stable-set inequality by `1/15`. Scaling by 15 and assigning common expensive-path cost 30 gives the exact `58<60` certificate. + +## Phase 6: machine-dependent forcing gadget + +For the chairman problem, machine-dependent weights permit a local detector: + +```text +J not assigned to A + => K must be assigned to A + => either choice on L violates A or H. +``` + +A small positive default weight `eta` blocks the objection that an integral assignment may leave the fractional support. Repeating the detector five times forces five decisions into a global accumulator and gives `619/600>1`. + +## Final verification standard + +A candidate was accepted only after it had: + +- rational or integer data; +- a proof covering every path or every assignment category; +- an exact standard-library verifier; +- no floating-point tolerance or omitted-column assumption; +- a clean LaTeX build in GitHub Actions. diff --git a/2026-rounding-counterexamples/research/validation-report.md b/2026-rounding-counterexamples/research/validation-report.md new file mode 100644 index 0000000..5e012ed --- /dev/null +++ b/2026-rounding-counterexamples/research/validation-report.md @@ -0,0 +1,42 @@ +# Validation report + +## SSUF certificate + +The following checks are implemented in `code/verify_dgg.py`. + +1. The aggregate fractional flow has source divergence `-40`, terminal divergences `(15,10,15)`, and zero divergence at `u,v,w`. +2. All source-terminal paths are reconstructed by depth-first search from the nine-arc graph. +3. Each terminal has exactly two paths, giving exactly eight unsplittable routings. +4. The fractional cost is exactly `58`. +5. Exactly four routings satisfy `y_a <= x_a+15` on every arc. +6. The minimum cost among those four routings is exactly `60`. +7. The three two-cheap-path routings have unit excess on `s->u`, `u->v`, and `v->w`, respectively. + +No floating-point operations or optimization solver are used. + +## Chairman certificate + +The following checks are implemented in `code/verify_chairman.py`. + +1. Every one of the 15 fractional columns sums exactly to one and has support two. +2. Every weight is strictly positive and the largest weight is exactly one. +3. A fresh detector row can lose at most `12/1000` before its block. +4. If `J_k` is not sent to `A_k`, assigning `K_k` away from `A_k` gives discrepancy at least `25/24-12/1000 > 1`. +5. After the forced `K_k` choice, either assignment of `L_k` gives discrepancy at least `6047/6000 > 1`. +6. Therefore all five decision columns are forced, and the accumulator discrepancy is at least `619/600 > 1`. + +The proof permits every column to be assigned to any of the eleven rows; no support-preservation assumption is used. + +## Human audit points + +Before submission, an independent expert should verify: + +- that the manuscript quotes each external conjecture with exactly the quantifiers and conventions used in its source; +- that no later paper, preprint, erratum, or private communication has already resolved either statement; +- that the journal's authorship and AI-disclosure policies are followed; +- that the compiled figures and equations are visually inspected page by page; +- that the title and abstract do not overstate collateral consequences. + +## Current limitations + +This report records an internal exact audit, not peer review. The GitHub Actions workflow is the authoritative build check for the committed sources. Its status should be green before the branch is merged or a manuscript is circulated.