VFR: A Verified Filter for Romanov's Triplet Logic — research artifact

This archive contains the complete research artifact for the paper:

Dmitry V. Alexandrov "Formal Verification of Romanov's Triplet Logic: A Verified Filter for Sliding-Window 3-CNF with Application to Structured Formulas" (2026) (preprint at arXiv:2608.18445).

CONTENTS

--------

- theories/ — Coq/Rocq formalization (17 .v files, 424 lemmas and theorems, 0 admits)

  * Theorem 1 (weak & compat), Theorem 2 (systemic aligned)

  * Algorithm.v — verified path-building and effective procedure

  * FormulaTranslation.v — CNF ↔ CTF soundness

  * Complexity.v — polynomial cost model (O(n⁴) generic, O(n²) single-forbidden)

  * Structured.v — verified grouped sliding CNF solver

  * Counterexample.v — formalized incompleteness proofs

- OCaml extraction — vfr_solver (JSON bridge to verified code)

- Python reference implementation — solver, CTF/CTS, hyperstructures, tests

- Docker — fully reproducible multi-stage build

- 177 pytest tests + 3 empirical verification scripts

- TLA+ specifications (17 modules)

- paper/edited.md — reviewer changelog for the v2 revision

The article itself is not duplicated in this archive; it is available as

a preprint at arXiv:2608.18445.

VERIFIED COMPONENTS

-------------------

- Sliding-window CNF → OCaml vfr_solver (extracted)

- Grouped sliding CNF → OCaml solve_grouped_sliding (extracted)

- Overlapping single-group CNF → OCaml solve_overlapping_single_group (extracted)

- UNSAT proofs → Swansea RUP checker (Coq-extracted; EXTERNAL, see below)

EXTERNAL DEPENDENCY: SWANSEA RUP CHECKER

----------------------------------------

The verified UNSAT path uses the RUP proof checker of H. Bryant, A. Lawrence,

M. Seisenberger, and A. Setzer, "Verification of Z3 RUP Proofs in Coq-Rocq and

Agda":

  https://github.com/HarryBryant99/Verification-of-Z3-RUP-Proofs-in-Coq-Rocq-and-Agda

Being third-party code, it is NOT vendored in this archive. To include it in

the build:

1. Clone and build the original project, following its README (requires opam

   with Rocq/Coq; the RUP checker lives in Rocq/vers1):

     git clone https://github.com/HarryBryant99/Verification-of-Z3-RUP-Proofs-in-Coq-Rocq-and-Agda swansea-rup

2. Run its Rocq build/extraction to produce the OCaml checker file

   swansea_rup.ml (see the repository's instructions for Rocq/vers1).

3. Place the extracted file into the bridge directory (already present in

   this archive, containing our JSON wrapper swansea_bridge.ml and a Makefile):

     cp swansea-rup/<extracted>/swansea_rup.ml tla+/src/swansea_rup/

4. Build the checker:

     cd tla+/src/swansea_rup && make

   This produces tla+/src/swansea_rup/swansea_rup_checker, which the Python

   solver invokes for UNSAT proof verification (strict mode: any verification

   failure raises RuntimeError).

Note: the Docker build performs step 4 automatically when swansea_rup.ml is

present and skips it (with a warning) otherwise. Fetch the sources BEFORE

running docker build to enable the verified UNSAT path inside the container.

REPRODUCIBILITY

---------------

See DEPLOY.md for artifact evaluation instructions:

  docker build -t vfr . && docker run --rm vfr

THIRD-PARTY COMPONENTS

----------------------

The Docker image includes third-party tools and libraries (Z3, Rocq/Coq, OCaml,

Python packages, Ubuntu system packages, and — fetched separately as described

above — the Swansea RUP checker). Their licenses are summarized in

THIRD_PARTY_LICENSES.md. The VFR project itself is released under the MIT

License.