pyvitri 0.3.0__tar.gz

pyvitri-0.3.0/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Changelog
+
+## 0.3.0
+
+### Migrating from 0.2
+
+- Variables are one-based DIMACS IDs in `1..=i32::MAX`. Replace tuple
+  construction with `VarId::new`, use `get` for the ID and `idx` for an array
+  index. `VarId::from_idx` converts an array index back to an ID.
+- Build formulas with `CnfFormula::new`; use `num_vars()`, `clauses()` and
+  `into_clauses()` in place of direct field access.
+- Replace `ShowSet::from_zero_based` with `from_vars` after converting IDs,
+  and `as_zero_based` / `to_dimacs` with `as_dimacs`. `from_vars` and `insert`
+  no longer return `Result`.
+- Replace `GoatdPolishing::with_wall_limit` with `with_work_limit`; the limit
+  measures construction work rather than elapsed wall time.
+- Use `Vtree::try_linear_from_order` for caller-supplied orders. The existing
+  `linear_from_order` requires a nonempty order without repeated variables.
+- `GoatdPolishing::with_separator`, `GoatdSeparatorConfig` and
+  `score::check_score_env` were removed. Read environment defaults through
+  `PortfolioKnobs::with_env_defaults`.
+- `FrontendRetryConfig` has a new field, `arjun_skip_monotone`. End a
+  struct literal with `..FrontendRetryConfig::default()`.
+
+### Changes
+
+- Package the score-vtree example and update the locked random-number
+  dependency to include its SSE2 compatibility fix.
+
+- Bound component-cache colour refinement by deterministic work, so sparse
+  components spend less time finding cache keys.
+
+- Reject variable counts outside the signed DIMACS domain, invalid peak
+  tolerances, mismatched preprocessing metadata and incorrect export leaves.
+
+- Stop Arjun's independent-support minimization once it has used three quarters of the Arjun budget left when it starts, keeping the last quarter for the stage after it, which eliminates the variables minimization has shown determined. A minimization that met the deadline used to leave that stage no time, and the run returned its input unchanged after spending its whole budget. On a family of track-1 formulas of the Model Counting Competitions with about 3300 variables, minimization had by then shown about four fifths of them determined; with the reserve, the run removes them in under a second. A minimization that finishes earlier is unaffected. Counted by a bottom-up TDD compiler at a 120 s limit, paired on one machine: over 780 track-1 formulas, 608 solved against 607 (two gained, one lost) in 1.3% less time on the formulas solved either way; over the 257 of them on which Arjun takes at least 2 s, 176 against 175 in 5.8% less time. At a one-hour limit, on 30 formulas solved only with more time, the same 23 are solved in 1.7% less time. No count differs.
+- Keep asking about a backbone candidate whose single probe stops at its conflict limit, instead of setting it aside. The next probe asks about that literal and the seven candidates after it in one solve that runs to an answer, so the clauses the solver learnt in the capped attempt go on to settle it. Set aside, every hard candidate after it also spent a full capped probe before any of them was proved, though once one is proved propagation usually fixes the rest for free. Counted at two minutes over the 780 solvable track-1 instances of the Model Counting Competitions, paired on one machine, the backbone phase takes 6% less time on the 602 instances both versions solve and finds the same backbone on every one; one instance whose backbone used to run past the limit is solved; no count differs. A probe that still runs out at the run-to-answer bound is set aside for the recovery pass as before. A literal is asked about this way once: when the probe's counter-model refutes one of the other seven and leaves the literal a candidate, its next probe is capped again, and if that one stops undecided too the literal is set aside, since a run-to-answer probe on it alone can take the whole budget. Paired over the same 780 at two minutes against a version that let that next probe run to an answer, counting solves 610 against 607 (four gained, among them two whose backbone phase used to run into the limit on such a probe, one lost) in 1.0% less time on the 606 both solve, and compiling 531 against 531 (two gained, two lost, all within ten seconds of the limit in one of the runs or known to vary between runs) in 1.3% less time, with 7% less backbone time, on the 529 both compile; the backbone is the same on every instance both solve, and no count differs.
+- Build a component's vtree once for all its renamed copies. The cache a build keeps over its components was keyed on the component's clauses in its local numbering, which follows the order of the formula's variables, so copies of one gadget placed differently in the formula missed each other and each got its own portfolio. The key is now the clauses and show set relabelled into a canonical numbering, from colour refinement on the signed variable-clause incidence graph with the remaining ties broken in turn; equal keys hold the same relabelled clauses, so a hit is always an exact isomorphism, and a tie between variables that are not interchangeable can only cost a hit. Cached vtrees, the retained candidate vtrees and their bag metadata are stored in the canonical numbering and renamed into each copy's numbering on use. On mc2023_track1_124 of the 2023 Model Counting Competition, whose 696 components include 91 renamed copies of one 67-variable component, counting with a bottom-up TDD compiler at a 120 s limit takes 75 s instead of 117 s over three runs each. Over 780 track-1 formulas at 120 s, paired on one machine, counting solves 606 against 603 and none is lost; compiling solves 526 against 527, and the three formulas that moved, re-run three times each, compile the same with and without the change or, for one, in two of three runs only with it. No count differs.
+- End the Arjun run with no reduction when its independent-support minimization has made no progress by a checkpoint partway through it. The checkpoint falls at 30% of the Arjun budget remaining when minimization starts; if the support has then shrunk by less than 5% of its starting size (counting the variables not yet tested as still in it), minimization stops and the budget it would have used stays with the rest of the run. The check sits in minimization's own loop, where its deadline check sits, so a minimization that is making progress is untouched; stopping it and restarting from the partial support instead repeats its setup and lost formulas. In paired runs at a 120 s limit over 257 formulas on which Arjun takes at least 2 s, two more formulas were solved and none lost, and the formulas solved either way that the stop hit took 335 s in total instead of 419 s. It applies under `mc`, `wmc`, `pmc` and `pwmc`. The vendored Arjun gains `Arjun::set_progress_checkpoint` and `Arjun::stopped_no_progress`, recorded in `vendor/arjun/upstream/PROVENANCE.md`; unset, it is bit-identical.
+- Let a caller skip the Arjun stage under `mc` when the formula it would be handed is monotone up to renaming: every variable occurs, always in the same polarity, and every clause names two variables or more. `ArjunOptions::skip_monotone` (`VITRI_ARJUN_SKIP_MONOTONE`) asks for the skip; it is off by default and refused outside `mc` and with the stage off. No variable of such a formula is a backbone or defined by the others, so Arjun has none to eliminate; the skip forgoes only its work on clauses, subsumed-clause removal and bounded variable addition. On the 18 track-1 instances of the Model Counting Competitions whose simplified formula is of this kind, Arjun gave up at its budget on six and returned as many variables or more on the other twelve; counted at two minutes with the skip, paired on one machine, three more of the 18 are solved, none is lost and no count differs. `PreprocessBundle::stages` reports the skip as `SkipReason::Monotone`; `docs/preprocessing.md` gives the argument and what the skip forgoes. A frontend session keeps its simplify checkpoint when the stage was skipped this way, and `FrontendRetryConfig::arjun_skip_monotone` lets a retry run it, so a caller whose compile of the unreduced formula failed can try the reduction without simplifying again. At a one-hour limit, a compiler that does so counts two instances it did not count with the skip alone, of the four such track-1 instances of the 2025 and 2026 competitions whose unreduced compile gives up.
+- Add `ArjunBudget::derived_duration`, the budget `ArjunBudget::Derived` gives a run with a given wall-clock hint before the deadline clamps it, so a caller that sizes an exact or retry budget from the same policy need not restate it.
+- Run the second round of CaDiCaL clause simplification only when the Tarjan stage, re-run over the first round's result, finds an equivalence class the first round had not. The stage binds each literal it merges to its representative with two binary clauses, so the re-run always found the first round's classes again and the second round ran on every formula that had any.
+- Build the implication graph Tarjan's search for equivalent literals runs on over the variables the binary clauses mention, stored flat, and allocate no group for a literal equivalent to no other; unit propagation and backbone stripping index the clauses in flat arrays instead of a list or a hash set per literal. The cost of each now follows the clauses rather than the declared variable count. The classes, their representatives and the reduced formula are unchanged.
+- Stop each SAT equivalence probe at 16,000 conflicts under the wall clock as well as the deterministic one, and end the probing at the second probe that stops undecided. Under the wall clock a probe had no conflict limit, so one pair that no short refutation settles could spend the whole probing budget, and the deterministic clock let each such probe run to 64,000 conflicts. An undecided pair is skipped, never assumed equivalent, and the equivalences proved before the probing ends are kept, so counts are unchanged; where the probing now ends early, fewer equivalences may be merged.
+- Give goatd, in a portfolio build under a deadline, the lesser of its fair share and the time the FlowCutter entries took, but at least twelve seconds when its share allows. On a formula FlowCutter decomposed quickly, most of goatd's search ran past the last tree it kept; with the bound it returns the same trees sooner on most such formulas.
+- Walk `flowcutter-primal` ahead of `flowcutter-incidence` on a formula with at least 20 clauses per variable. The incidence graph has a vertex per clause, so on such a formula its decomposition costs many times the primal one, and walked second it is the view the bound on the second FlowCutter build stops. The walk order also breaks ties, so there a tie between the two views goes to the primal one.
+- Bound the second FlowCutter view of a portfolio build under a deadline by the time the first one took to find its decomposition, or one second when that is more. The bound stops the search without changing how it searches. On the compile-mode portfolio builds of the 780 solvable track-1 instances that took ten seconds or more, the second view ran longer than the first on 13 of 36 and won none of those; with the bound construction is shorter and every instance compiles as before. Without a deadline the step-budgeted search is unchanged.
+- Leave a function-preserving split to the portfolio when one component holds more than three quarters of the variables, even when the formula is large and clause-dense enough for `force` on every component. Of the 42 reductions of the 780 solvable track-1 instances that rule admitted, the three that compiled only under the portfolio are each one component holding 98% or more of the variables beside a few small ones, while no component of the 17 that compiled only under `force` holds more than 63%.
+- Build every component with `force` when a portfolio build of a function-preserving formula (`--mode compile`) splits into components and the formula has at least 1000 variables and at least 4.5 clauses per variable. Over function-preserving reductions of the 780 solvable track-1 instances of the Model Counting Competitions, compiled into tree decision diagrams at two minutes, the 38 formulas the rule admits compiled 17 more under `force` and none fewer, in less total time on those both compiled; outside the rule the portfolio compiles far more. Counting-mode reductions are unaffected: there the same rule gained nothing. `SelectionCtx::preserves_function` carries the condition; the full pipeline sets it from the run's mode and construction-only calls default to `false`.
+- Read the clock once every 1024 decisions, instead of at every decision, when Arjun's search for defined variables checks the deadline. The search makes millions of decisions, and on a machine whose clock has no fast path each read takes about a microsecond, so the check could more than double the time independent-support minimization takes, run it into its deadline and lose the rest of the reduction. Once a read finds the deadline passed, every candidate not yet tested is kept as before.
+- Skip Arjun's oracle in the `pwmc` pre-pass by default: `OracleCaps::weighted_projected` and `VITRI_PWMC_ARJUN_ORACLE_MAX_VARS` default to 0. On weighted projected instances the oracle was the largest part of the pre-pass; skipping it left every count unchanged and cut total time. The `pmc` default is unchanged.
+- Stop Arjun's independent-support minimization at the deadline when it falls inside the search for defined variables. That search tests every candidate inside one solve, and the deadline was checked only between solves, so a budget that ran out during it ran on until the solve had tested every candidate, or until the process holding it was killed and its reduction lost. Past the deadline each candidate not yet tested is now kept in the support, as one that runs out of conflicts already was.
+- Stop projected variable elimination at the run's deadline. Under `pmc` and `pwmc`, the bounded elimination of hidden variables after show-frozen strengthening ignored the deadline, so a large projected formula could run far past the run's wall. It now stops once the deadline passes and keeps the eliminations it finished; each is exact existential quantification, so the projected count is unchanged and only fewer hidden variables are removed. Resolvents are merged from the two sorted clauses instead of sorted from their concatenation, with identical output, so a run without a deadline reduces exactly as before. `projection::eliminate_hidden` takes no deadline and still runs to its fixpoint.
+- Bound the default goatd polishing stage by work instead of by a hundred milliseconds of real time, so the vtree a construction polishes to no longer depends on how fast or how loaded the machine is. The stage runs on the construction's work clock, arming it for the stage when nothing else has, reads it between the kernel's scheduling steps as well as between proposals, and stops after 110 milliseconds of it, about what the real-time bound bought on a typical instance. `GoatdPolishing::with_wall_limit` is renamed `GoatdPolishing::with_work_limit`.
+- Charge a reading of a tree decomposition 400 work units for each variable, adjacency entry and literal it covers, instead of one. That is about what a reading costs against the units the decomposition kernels charge, so a `ConstructionBudget::Deterministic` budget spent on readings lasts about as long as the wall it was sized for rather than far longer, and a deterministic construction considers fewer readings for the same budget.
+- Probe for backbones and literal equivalences over the variables a clause mentions only. A declared variable that no clause mentions was still loaded into the probing solver, which decided it on every probe and read it back with every model, and one numbered above every mentioned variable was probed as a backbone candidate. Such a variable is never a backbone nor equivalent to another, so it is now counted as flippable without a probe, and the reported probe count no longer includes the probes once spent on it.
+- Read a missing complementary weight the way the Model Counting Competition format defines it, in every mode: when `c p weight` lines give one literal of a variable a weight `0 < w < 1` and the other none, the other weighs `1 - w`; a lone weight outside that range is refused, naming the literal; a variable with no weight line weighs 1 both ways.
+- Add `spec::is_structural_spec`, which says whether a spec builds from the formula's graph, so a consumer compiling components separately makes the same call the split builder does; and make `CnfFormula::component_vars` public, the sorted variables of a clause group without the sub-formula.
+- Read `root=centroid` as the centroid alone. A named root other than `leaf` also enumerated the first bag, so the conversion searched both, and one with no formula to score against rooted at the first bag.
+- Read `VITRI_SCORE_AGG_MARGIN=none` whatever its case, like every other word-valued variable.
+- Show the vtree drawing on the browser page. The empty-state panel has `display: flex` in the stylesheet, which beat the `hidden` attribute and left the panel over the canvas; `[hidden]` is now an author rule. A check in the module workflow reads the page against its stylesheet for that.
+- Make `VarId` a type that cannot hold 0, which names no variable: the field is private over a `NonZeroU32`, `VarId::new` and `VarId::try_from_dimacs` are the checked constructors, `VarId::get` reads the number, and `VarId::all` enumerates a variable space. `ShowSet::from_dimacs_ids` still refuses a 0, since it is where file numbers become variables; `ShowSet::from_vars` and `ShowSet::insert` no longer return `Result`.
+- Make `CnfFormula`'s fields private, so a formula cannot carry a clause naming a variable its
+  declared count does not cover. `CnfFormula::new` is the checked constructor, `num_vars()` and
+  `clauses()` read the parts, and `into_clauses` takes the clauses out.
+- Parse a file whose header declares no variables, such as `p cnf 0 1` over the empty clause, instead of reporting its problem line as missing.
+- Honour the construction deadline in bisection — the dials a bisection runs under carry the caller's deadline — and spend the smaller of the soft ceiling and the time left on a goatd elimination pass.
+- Report an empty tree decomposition or a formula with no variables as `VitriError::Input` from `td_to_vtree`, where it asserted.
+- Label `.dot` nodes by `topo_pos`, the numbering the `.vtree` file beside them uses.
+- Refuse a `preprocess.json` or `components.json` whose `format` tag, or whose rank metric, this version does not understand.
+- Check a `VtreeBuild` against its components before writing anything, so a refused build leaves no partial bundle behind.
+- Number variables from 1: a `VarId` is the DIMACS variable of the same number, so `VarId::to_dimacs`, `VarId::from_dimacs` and `Literal`'s conversions carry no offset, and `VarId::idx` / `VarId::from_idx` are the array-index conversions. `ShowSet::from_zero_based`, `ShowSet::as_zero_based` and `ShowSet::to_dimacs` are replaced by `ShowSet::from_vars` and `ShowSet::as_dimacs`. File formats are unchanged.
+- Add `vitri::request`: run a JSON-describable request and get the bundle files in memory with a summary.
+- Run the budgeted Arjun stage inline unless the process is known to have one thread and keeps its children waitable.
+- Add a C ABI in `bindings/c`: shared and static libraries over `vitri::request`, with a generated header.
+- Publish a Linux x86_64 archive of the command-line tool with each release, bundling GMP built from its attached source.
+- Add Python bindings in `bindings/python`: `vitri.prepare` returns the bundle and summary of `vitri::request::prepare`.
+- Build for `wasm32-unknown-emscripten` with the Arjun stage, linking GMP as side modules from the prefix `VITRI_EMSCRIPTEN_PREFIX` names.
+- Add `bindings/wasm`, which builds vitri as a WebAssembly module for the browser, and publish that module with GMP's side modules and source.
+- Publish a page that runs vitri in the browser at the root of the GitHub Pages site, beside the rustdoc.
+- Add `--version` to the command-line tool, which prints the same version string the C, Python and wasm surfaces hand out.
+- Package `docs/showcase/*.cnf`, so the published crate carries the instance `docs/showcase.md` runs its commands on.
+- Report the emitted vtree's scores on `request::VtreeSummary::scores`: the same five numbers selection ranked it on, so a caller reads them without rescoring the tree.
+- Show those scores on the browser page, and link the page from the README.
+- Remove `GoatdPolishing::with_separator`, the `GoatdSeparatorConfig` re-export it existed for, and `score::check_score_env`. Nothing called any of them; the argv-time environment read `check_score_env` was named for still happens in `PortfolioKnobs::with_env_defaults`.
+- Publish GNU's detached signature for the GMP tarball beside it on a release, and record in `docs/THIRD-PARTY.md` where the sources of a binary distribution are and that the Rust standard library is linked into it.
+
+## 0.2.0
+
+- Upgrade Goatd to 0.2.1.
+- Configure final refinement and bipartite lifting with `GoatdPolishing` and `GoatdLift`.
+- Use bounded adaptive polishing by default; explicit legacy policies remain available.
+- Configure pairwise selection weights with `PortfolioKnobs::pairwise_weighting`.
+- Apply cooperative wall limits when converting adaptive refinement results.

pyvitri-0.3.0/Cargo.lock

@@ -0,0 +1,265 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "cc"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5add81bb678e6cb321aff7fa0dc7689ad82b112dbc032cea19f91d6b8e3582b9"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chacha20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "rand_core",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "rand_core",
+]
+
+[[package]]
+name = "goatd"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd36c0dbc0e470c1f355664efd11c037bbd23906b115e2a1157b4d0f3eba18d"
+dependencies = [
+ "cc",
+ "libc",
+ "rustc-hash",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "num-bigint"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
+dependencies = [
+ "chacha20",
+ "getrandom",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "vitri"
+version = "0.3.0"
+dependencies = [
+ "goatd",
+ "libc",
+ "num-bigint",
+ "num-rational",
+ "num-traits",
+ "rand",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

pyvitri-0.3.0/Cargo.toml

@@ -0,0 +1,124 @@
+[package]
+name = "vitri"
+version = "0.3.0"
+edition = "2024"
+# 1.88 stabilized let-chains (`if let … && let …`) for edition 2024, which this
+# crate uses throughout; that is what sets the floor. Verified by a real
+# `cargo +1.88.0 check`; there is no feature surface to check separately.
+rust-version = "1.88"
+authors = ["Guy Van den Broeck <guyvdb@cs.ucla.edu>"]
+license = "Apache-2.0"
+repository = "https://github.com/Tractables/vitri"
+documentation = "https://docs.rs/vitri"
+# `vitri` is a coined name, so it carries no meaning on its own — the
+# description, keywords and categories have to do ALL of the discoverability
+# work. Say what it does in the words someone would search for. (crates.io caps
+# keywords at 5 entries of 20 chars, hence "knowledge-compiler" over the
+# 21-char "knowledge-compilation".)
+description = "CNF preprocessing and vtree construction (variable trees) for circuit compilation and model counting: preprocesses a DIMACS CNF, records the arithmetic to lift a model count back to the original, and builds a good vtree for it — for any d-DNNF/SDD/TDD compiler, or any model counter that takes a vtree."
+keywords = ["vtree", "cnf", "model-counting", "knowledge-compiler", "preprocessing"]
+categories = ["science", "algorithms", "mathematics", "command-line-utilities"]
+readme = "README.md"
+# Allowlist, not a denylist: `cargo package` ships exactly these and nothing
+# else, so a new scratch directory in the repository can never leak into a
+# release. `docs/` is the hand-written consumer documentation — bundle.md,
+# preprocessing.md, vtrees.md, env.md, building.md.
+# `vendor/` holds the Arjun C++ stack that `build.rs` compiles. It sits under
+# the package root because `include` cannot reach outside it, so vendored
+# sources one level up would make a published crate unable to build.
+include = [
+    "src/**/*.rs",
+    "examples/**/*.rs",
+    # The ranker the portfolio selects on by default.
+    "src/score/agg/pair_boost.json",
+    "build.rs",
+    # The build script's own modules.
+    "build/**/*.rs",
+    "Cargo.toml",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "docs/*.md",
+    # Contributor instructions are for the repository, not the crate.
+    "!docs/CONTRIBUTING.md",
+    # The README's vtree picture and the hand-written CNF its command runs on.
+    # A crates.io README with the image left out renders a broken link, and one
+    # without the CNF names an input the reader cannot get.
+    "docs/images/*.png",
+    "docs/example.cnf",
+    # The instance `showcase.md`'s Reproduce block runs on, for the same reason.
+    "docs/showcase/*.cnf",
+    # Test fixtures are hand-written or generated in test code
+    # (`src/tests/circuit_fixture`), with one exception: the aggregate ranker's
+    # tests read recorded (CNF, vtree) pairs under `tests/data/agg`, whose CNFs
+    # are components of public model-counting competition instances. The
+    # packaged crate ships them because `src/score/agg/tests/` reads them.
+    "tests/**/*.rs",
+    "tests/data/agg/**",
+    # Whole trees, not an extension list: the vendored Arjun stack is five CMake
+    # projects (CMakeLists.txt, *.cmake, *.in, *.cpp) and Eigen's headers have no
+    # file extension at all, so any pattern narrower than this silently ships a
+    # package that cannot build its own default features.
+    "vendor/**",
+    # Minus any CNF under `vendor/`: nothing the build reads, and this package
+    # ships no benchmark data. A guard for re-vendoring — upstream repositories
+    # carry their own bug reproducers. The negation comes after the tree it
+    # narrows; later patterns win.
+    "!vendor/**/*.cnf",
+]
+# `build.rs` folds the vendored C++ stack into a single static archive,
+# `libvitri_arjun.a`, in this crate's OUT_DIR. Declaring `links` reserves that
+# native library name so two copies of this crate can never end up linked into
+# one program — Cargo rejects that at resolve time rather than letting it fail
+# as duplicate symbols.
+#
+# The name covers the whole archive, which is CaDiCaL as well as Arjun and
+# CryptoMiniSat. Two CaDiCaL builds in one process link without a warning and
+# then corrupt the heap, so a crate that vendors its own declares this same key
+# and the collision becomes a resolve-time error. `docs/sat.md` says why, and
+# `sat` publishes this crate's solver so a consumer need not vendor one.
+links = "vitri_arjun"
+
+[lib]
+name = "vitri"
+# Doctests RUN, and are left on deliberately. A doc example in a published
+# library is API documentation a reader will copy, so it has to be compiled
+# against the crate's real public surface every build. It also compiles as its
+# OWN crate, which is what makes the check meaningful: paths must be written
+# `vitri::…`, exactly as a downstream user writes them.
+
+# Standalone tool: raw CNF → reduced CNF + count-lift record + vtree bundle.
+# The source lives beside the library rather than under `src/bin/`, so the path
+# is stated explicitly here.
+[[bin]]
+name = "vitri"
+path = "src/cli_main.rs"
+
+[[test]]
+name = "fork_budget"
+path = "tests/fork_budget/main.rs"
+harness = false
+
+[dependencies]
+num-bigint = "0.4"
+num-rational = "0.4"
+num-traits = "0.2"
+rand = "0.10"
+rustc-hash = "2"
+libc = "0.2"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["float_roundtrip"] }
+goatd = "0.3.0"
+
+# There is deliberately NO `[features]` section and no
+# `[package.metadata.docs.rs]` section, and nothing to configure: the crate has
+# no on/off surface, so docs.rs renders the whole API a plain `cargo add vitri`
+# gets, and `--all-features` is the same build as no features at all. The
+# brute-force MC/PMC oracles the test suite checks itself against are
+# `cfg(test)`, not a feature, so no build a consumer can ask for compiles them.
+#
+# docs.rs has no network and cannot install system packages, so neither the
+# CMake run nor the GMP/MPFR/zlib the vendored stack links against are available
+# in its sandbox. `build.rs` handles that directly by skipping the native build
+# when docs.rs sets `DOCS_RS`: rustdoc type-checks but never links, so the
+# `extern "C"` declarations need nothing behind them and the full API renders.