tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.43f28be
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +27 -141
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +517 -47
- package/dist/run-cli.js +517 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +54 -19
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +258 -37
- package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
- package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
- package/src/{obligation-format.ts → obligations/format.ts} +6 -5
- package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
- package/src/{obligations.ts → obligations/index.ts} +28 -12
- package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
- package/src/{obligation-module.ts → obligations/module.ts} +46 -20
- package/src/obligations/pickle.ts +100 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +9 -63
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +91 -35
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +100 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +508 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +520 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +552 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +27 -0
- package/src/prove/prove.ts +518 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +210 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +665 -0
- package/src/prove/smt/encode.ts +169 -0
- package/src/prove/smt/extensionality.ts +63 -0
- package/src/prove/smt/flatten.ts +127 -0
- package/src/prove/smt/format.ts +143 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +784 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +97 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +444 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +338 -62
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +244 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +47 -4
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,440 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/nra_solver.cpp, src/math/lp/nla_coi.cpp), MIT license, see
|
|
2
|
+
// z3-license.txt. nla's bridge to nlsat. The constraints in the cone of influence of the monomials
|
|
3
|
+
// to refine go to nlsat, with every monomial and term column replaced by its polynomial. check runs
|
|
4
|
+
// nlsat's search on them: a model becomes nla's, and a refutation a lemma over the constraints of
|
|
5
|
+
// its core. check_assignment instead hands nlsat the current values, and when they violate a
|
|
6
|
+
// constraint, nlsat's linear cell around them becomes a lemma.
|
|
7
|
+
// Deviations from Z3:
|
|
8
|
+
// - nlsat input it does not implement (NlsatUnsupportedError) answers unknown. That is a linear
|
|
9
|
+
// cell around an irrational section, where Z3 exits the process (levelwise.cpp,
|
|
10
|
+
// add_linear_approximations).
|
|
11
|
+
// - nlsat's check(rvalues) never answers satisfied, because its solver starts with the clause
|
|
12
|
+
// [true], whose literal is unassigned outside search. So the satisfied branch of
|
|
13
|
+
// check_assignment, which switches nla to nlsat's model, is left out.
|
|
14
|
+
// - A lemma literal of check_assignment is always linear, because the cell bounds are, so
|
|
15
|
+
// add_mul_def, which defines a fresh monomial column, is left out. A nonlinear literal would
|
|
16
|
+
// answer unknown.
|
|
17
|
+
// - nlsat counts against the budget of a check only its own steps, not those of the polynomial and
|
|
18
|
+
// algebraic number managers, so a long search stops at a different point than Z3's. Like Z3's,
|
|
19
|
+
// it then throws, which ends the whole check as unknown.
|
|
20
|
+
// - Transcendental functions are not supported, so none are registered with nlsat.
|
|
21
|
+
import { NlsatUnsupportedError, SmtInvariantError } from "../../../../errors";
|
|
22
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
|
|
23
|
+
import { Rational, getLcm } from "../rational";
|
|
24
|
+
import { Anum } from "../nlsat/algebraic";
|
|
25
|
+
import { NlsatSolver } from "../nlsat/solver";
|
|
26
|
+
import type { Polynomial } from "../nlsat/polynomial";
|
|
27
|
+
import { isIneqAtom } from "../nlsat/types";
|
|
28
|
+
import {
|
|
29
|
+
KIND_EQ,
|
|
30
|
+
KIND_GE,
|
|
31
|
+
KIND_GT,
|
|
32
|
+
KIND_LE,
|
|
33
|
+
KIND_LT,
|
|
34
|
+
KIND_NE,
|
|
35
|
+
type LarConstraint,
|
|
36
|
+
} from "./constraints";
|
|
37
|
+
import { Explanation } from "./explanation";
|
|
38
|
+
import type { LarSolver } from "./lar-solver";
|
|
39
|
+
import { LarTerm } from "./lar-term";
|
|
40
|
+
import { type NlaCore } from "./nla-core";
|
|
41
|
+
import { LemmaBuilder, mkIneq } from "./nla-types";
|
|
42
|
+
|
|
43
|
+
interface Occurrences {
|
|
44
|
+
constraints: number[];
|
|
45
|
+
monics: number[];
|
|
46
|
+
terms: number[];
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
// lar_base_constraint::coeffs: the term of a term column, else the column itself.
|
|
50
|
+
const getConstraintCoeffs = (lra: LarSolver, constraint: LarConstraint): [number, Rational][] =>
|
|
51
|
+
lra.hasTerm(constraint.column)
|
|
52
|
+
? [...lra.getTerm(constraint.column).coeffs]
|
|
53
|
+
: [[constraint.column, Rational.one]];
|
|
54
|
+
|
|
55
|
+
// coi::init: the constraints reachable from the monomials to refine through shared variables,
|
|
56
|
+
// monomials and terms, in the order the search reaches them.
|
|
57
|
+
const getConeOfInfluence = (core: NlaCore) => {
|
|
58
|
+
const lra = core.lra;
|
|
59
|
+
const occurrences: Occurrences[] = [];
|
|
60
|
+
const getOccurrences = (lpVar: number) =>
|
|
61
|
+
(occurrences[lpVar] ??= { constraints: [], monics: [], terms: [] });
|
|
62
|
+
lra.constraints.constraints.forEach((constraint, index) => {
|
|
63
|
+
if (!constraint.isActive) return;
|
|
64
|
+
for (const entry of getConstraintCoeffs(lra, constraint))
|
|
65
|
+
getOccurrences(entry[0]).constraints.push(index);
|
|
66
|
+
});
|
|
67
|
+
for (const monic of core.emons.monics)
|
|
68
|
+
for (const lpVar of monic.vars) getOccurrences(lpVar).monics.push(monic.variable);
|
|
69
|
+
for (const term of lra.terms)
|
|
70
|
+
for (const entry of term.coeffs) getOccurrences(entry[0]).terms.push(term.column);
|
|
71
|
+
const todo = [...core.toRefine.elems];
|
|
72
|
+
const vars = new Set<number>();
|
|
73
|
+
const constraints = new Set<number>();
|
|
74
|
+
const monics = new Set<number>();
|
|
75
|
+
for (let index = 0; index < todo.length; index++) {
|
|
76
|
+
const lpVar = todo[index];
|
|
77
|
+
if (vars.has(lpVar)) continue;
|
|
78
|
+
vars.add(lpVar);
|
|
79
|
+
const occurring = getOccurrences(lpVar);
|
|
80
|
+
for (const constraintIndex of occurring.constraints) {
|
|
81
|
+
constraints.add(constraintIndex);
|
|
82
|
+
for (const entry of getConstraintCoeffs(lra, lra.constraints.constraints[constraintIndex]))
|
|
83
|
+
todo.push(entry[0]);
|
|
84
|
+
}
|
|
85
|
+
todo.push(...occurring.monics);
|
|
86
|
+
for (const termColumn of occurring.terms) {
|
|
87
|
+
for (const entry of lra.getTerm(termColumn).coeffs) todo.push(entry[0]);
|
|
88
|
+
todo.push(termColumn);
|
|
89
|
+
}
|
|
90
|
+
if (lra.hasTerm(lpVar)) for (const entry of lra.getTerm(lpVar).coeffs) todo.push(entry[0]);
|
|
91
|
+
if (core.emons.isMonicVar(lpVar)) {
|
|
92
|
+
monics.add(lpVar);
|
|
93
|
+
todo.push(...core.emons.get(lpVar).vars);
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
return { vars, constraints, monics };
|
|
97
|
+
};
|
|
98
|
+
|
|
99
|
+
// has_large_dyadic_denominator: a denominator 2^k with k >= 24.
|
|
100
|
+
const hasLargeDyadicDenominator = (value: Rational) => {
|
|
101
|
+
const den = value.den;
|
|
102
|
+
return den >= 1n << 24n && (den & (den - 1n)) === 0n;
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
// is_dyadic_artifact: a constraint of an nla lemma's atom with a constant whose denominator is a
|
|
106
|
+
// large power of two, the value of a column at an LP vertex. nlsat leaves it out, since clearing
|
|
107
|
+
// such denominators blows up its resultants.
|
|
108
|
+
const isDyadicArtifact = (lra: LarSolver, constraint: LarConstraint) =>
|
|
109
|
+
constraint.isAuxiliary &&
|
|
110
|
+
(hasLargeDyadicDenominator(constraint.rhs.x) ||
|
|
111
|
+
getConstraintCoeffs(lra, constraint).some((entry) => hasLargeDyadicDenominator(entry[1])));
|
|
112
|
+
|
|
113
|
+
export class NraSolver {
|
|
114
|
+
// m_nlsat and m_values: the solver of the last check, and the values of its model.
|
|
115
|
+
private solver = new NlsatSolver();
|
|
116
|
+
private values: Anum[] = [];
|
|
117
|
+
// m_lp2nl: the nlsat variable of each column the solver has.
|
|
118
|
+
private lp2nl = new Map<number, number>();
|
|
119
|
+
|
|
120
|
+
constructor(private core: NlaCore) {}
|
|
121
|
+
|
|
122
|
+
get am() {
|
|
123
|
+
return this.solver.am;
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
// The steps of the last check.
|
|
127
|
+
get steps() {
|
|
128
|
+
return this.solver.steps;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// mk_definition: each included column as a polynomial in the included columns that are neither
|
|
132
|
+
// monomials nor terms, scaled by an integer denominator to keep the coefficients integral.
|
|
133
|
+
// Excluded columns have no definition.
|
|
134
|
+
private mkDefinitions(isIncluded: (lpVar: number) => boolean) {
|
|
135
|
+
const core = this.core;
|
|
136
|
+
const lra = core.lra;
|
|
137
|
+
const solver = this.solver;
|
|
138
|
+
const pm = solver.pm;
|
|
139
|
+
const definitions: (Polynomial | null)[] = [];
|
|
140
|
+
const denominators: bigint[] = [];
|
|
141
|
+
for (let lpVar = 0; lpVar < lra.columns.length; lpVar++) {
|
|
142
|
+
if (!isIncluded(lpVar)) {
|
|
143
|
+
definitions.push(null);
|
|
144
|
+
denominators.push(0n);
|
|
145
|
+
continue;
|
|
146
|
+
}
|
|
147
|
+
const variable = solver.mkVar(lra.isInt(lpVar));
|
|
148
|
+
this.lp2nl.set(lpVar, variable);
|
|
149
|
+
if (core.emons.isMonicVar(lpVar)) {
|
|
150
|
+
let definition: Polynomial | null = null;
|
|
151
|
+
let denominator = 1n;
|
|
152
|
+
for (const factor of core.emons.get(lpVar).vars) {
|
|
153
|
+
denominator = denominators[factor] * denominator;
|
|
154
|
+
definition =
|
|
155
|
+
definition === null ? definitions[factor] : pm.mul(definition, definitions[factor]!);
|
|
156
|
+
}
|
|
157
|
+
definitions.push(definition ?? pm.mkVar(variable));
|
|
158
|
+
denominators.push(denominator);
|
|
159
|
+
continue;
|
|
160
|
+
}
|
|
161
|
+
if (lra.hasTerm(lpVar)) {
|
|
162
|
+
const term = [...lra.getTerm(lpVar).coeffs];
|
|
163
|
+
const denominator = term.reduce(
|
|
164
|
+
(result, entry) => getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, result),
|
|
165
|
+
1n,
|
|
166
|
+
);
|
|
167
|
+
let definition: Polynomial | null = null;
|
|
168
|
+
for (const entry of term) {
|
|
169
|
+
const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
|
|
170
|
+
const scaled = pm.mul(pm.mkConst(coeff.num), definitions[entry[0]]!);
|
|
171
|
+
definition = definition === null ? scaled : pm.add(definition, scaled);
|
|
172
|
+
}
|
|
173
|
+
definitions.push(definition ?? pm.zero);
|
|
174
|
+
denominators.push(denominator);
|
|
175
|
+
continue;
|
|
176
|
+
}
|
|
177
|
+
definitions.push(pm.mkVar(variable));
|
|
178
|
+
denominators.push(1n);
|
|
179
|
+
}
|
|
180
|
+
return { definitions, denominators };
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
// add_constraint: the constraint sum(coeff * v) kind rhs as den * (sum(coeff / den[v] * def[v]) -
|
|
184
|
+
// rhs) kind 0, where den clears every denominator, in a unit clause that assumes the constraint.
|
|
185
|
+
private addConstraint(
|
|
186
|
+
constraintIndex: number,
|
|
187
|
+
definitions: readonly (Polynomial | null)[],
|
|
188
|
+
denominators: readonly bigint[],
|
|
189
|
+
) {
|
|
190
|
+
const lra = this.core.lra;
|
|
191
|
+
const solver = this.solver;
|
|
192
|
+
const pm = solver.pm;
|
|
193
|
+
const constraint = lra.constraints.constraints[constraintIndex];
|
|
194
|
+
const rhs = constraint.rhs.x;
|
|
195
|
+
const coeffs = getConstraintCoeffs(lra, constraint);
|
|
196
|
+
const denominator = coeffs.reduce(
|
|
197
|
+
(result, entry) => getLcm(result, entry[1].div(Rational.of(denominators[entry[0]])).den),
|
|
198
|
+
rhs.den,
|
|
199
|
+
);
|
|
200
|
+
let polynomial = pm.mkConst(-(rhs.num * denominator) / rhs.den);
|
|
201
|
+
for (const entry of coeffs) {
|
|
202
|
+
const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
|
|
203
|
+
polynomial = pm.add(polynomial, pm.mul(definitions[entry[0]]!, pm.mkConst(coeff.num)));
|
|
204
|
+
}
|
|
205
|
+
const kind = constraint.kind;
|
|
206
|
+
const literal =
|
|
207
|
+
kind === KIND_LE
|
|
208
|
+
? solver.mkIneqLiteral("GT", [polynomial], [false]) ^ 1
|
|
209
|
+
: kind === KIND_GE
|
|
210
|
+
? solver.mkIneqLiteral("LT", [polynomial], [false]) ^ 1
|
|
211
|
+
: solver.mkIneqLiteral(
|
|
212
|
+
kind === KIND_LT ? "LT" : kind === KIND_GT ? "GT" : "EQ",
|
|
213
|
+
[polynomial],
|
|
214
|
+
[false],
|
|
215
|
+
);
|
|
216
|
+
solver.mkExternalClause([literal], constraintIndex);
|
|
217
|
+
return literal;
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
// check: nlsat's search on the constraints in the cone of influence, with every included column
|
|
221
|
+
// replaced by its polynomial, giving up after maxConflicts conflicts or budget steps. A model
|
|
222
|
+
// becomes nla's, when it satisfies every constraint and monomial, and a refutation becomes the
|
|
223
|
+
// lemma that the constraints of its core are inconsistent.
|
|
224
|
+
check(maxConflicts: number, budget: number) {
|
|
225
|
+
const core = this.core;
|
|
226
|
+
const lra = core.lra;
|
|
227
|
+
this.solver = new NlsatSolver(core.limit, budget);
|
|
228
|
+
this.solver.maxConflicts = maxConflicts;
|
|
229
|
+
this.values = [];
|
|
230
|
+
this.lp2nl.clear();
|
|
231
|
+
const cone = getConeOfInfluence(core);
|
|
232
|
+
const definitions = this.mkDefinitions((lpVar) => cone.vars.has(lpVar));
|
|
233
|
+
const skipped = new Set<number>();
|
|
234
|
+
for (const constraintIndex of cone.constraints) {
|
|
235
|
+
if (isDyadicArtifact(lra, lra.constraints.constraints[constraintIndex])) {
|
|
236
|
+
skipped.add(constraintIndex);
|
|
237
|
+
continue;
|
|
238
|
+
}
|
|
239
|
+
this.addConstraint(constraintIndex, definitions.definitions, definitions.denominators);
|
|
240
|
+
}
|
|
241
|
+
const result = (() => {
|
|
242
|
+
try {
|
|
243
|
+
return this.solver.check();
|
|
244
|
+
} catch (error) {
|
|
245
|
+
if (error instanceof NlsatUnsupportedError) return L_UNDEF;
|
|
246
|
+
throw error;
|
|
247
|
+
}
|
|
248
|
+
})();
|
|
249
|
+
if (result === L_TRUE) {
|
|
250
|
+
this.solver.restoreOrder();
|
|
251
|
+
core.setUseNraModel(true);
|
|
252
|
+
lra.initModel();
|
|
253
|
+
// A violated constraint or monomial that nlsat saw would be a bug.
|
|
254
|
+
for (const [constraintIndex, constraint] of lra.constraints.constraints.entries()) {
|
|
255
|
+
if (!constraint.isActive || this.isConstraintSatisfied(constraint)) continue;
|
|
256
|
+
if (cone.constraints.has(constraintIndex) && !skipped.has(constraintIndex))
|
|
257
|
+
throw new SmtInvariantError(`nlsat's model violates constraint ${constraintIndex}`);
|
|
258
|
+
return L_UNDEF;
|
|
259
|
+
}
|
|
260
|
+
for (const monic of core.emons.monics) {
|
|
261
|
+
if (this.isMonicSatisfied(monic.variable, monic.vars)) continue;
|
|
262
|
+
if (cone.monics.has(monic.variable))
|
|
263
|
+
throw new SmtInvariantError(`nlsat's model violates monomial ${monic.variable}`);
|
|
264
|
+
return L_UNDEF;
|
|
265
|
+
}
|
|
266
|
+
}
|
|
267
|
+
if (result === L_FALSE) {
|
|
268
|
+
const explanation = new Explanation();
|
|
269
|
+
for (const constraintIndex of this.solver.getCore()) explanation.push(constraintIndex);
|
|
270
|
+
new LemmaBuilder(core).addExplanation(explanation);
|
|
271
|
+
core.setUseNraModel(true);
|
|
272
|
+
}
|
|
273
|
+
return result;
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
// value: the model's value of a column. A monomial or term gets the value of its definition, a
|
|
277
|
+
// column outside the cone of influence its value in lar_solver.
|
|
278
|
+
value(lpVar: number) {
|
|
279
|
+
const core = this.core;
|
|
280
|
+
const lra = core.lra;
|
|
281
|
+
const am = this.solver.am;
|
|
282
|
+
for (let column = this.values.length; column <= lpVar; column++) {
|
|
283
|
+
if (core.emons.isMonicVar(column)) {
|
|
284
|
+
this.values.push(
|
|
285
|
+
core.emons
|
|
286
|
+
.get(column)
|
|
287
|
+
.vars.reduce(
|
|
288
|
+
(product, factor) => am.mul(product, this.values[factor]),
|
|
289
|
+
new Anum(Rational.one),
|
|
290
|
+
),
|
|
291
|
+
);
|
|
292
|
+
continue;
|
|
293
|
+
}
|
|
294
|
+
if (lra.hasTerm(column)) {
|
|
295
|
+
this.values.push(
|
|
296
|
+
[...lra.getTerm(column).coeffs].reduce(
|
|
297
|
+
(sum, entry) => am.add(sum, am.mul(new Anum(entry[1]), this.values[entry[0]])),
|
|
298
|
+
new Anum(Rational.zero),
|
|
299
|
+
),
|
|
300
|
+
);
|
|
301
|
+
continue;
|
|
302
|
+
}
|
|
303
|
+
const variable = this.lp2nl.get(column);
|
|
304
|
+
this.values.push(
|
|
305
|
+
variable === undefined ? new Anum(core.val(column)) : this.solver.getValue(variable),
|
|
306
|
+
);
|
|
307
|
+
}
|
|
308
|
+
return this.values[lpVar];
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
// check_monic
|
|
312
|
+
private isMonicSatisfied(lpVar: number, vars: readonly number[]) {
|
|
313
|
+
const am = this.solver.am;
|
|
314
|
+
const product = vars.reduce(
|
|
315
|
+
(result, factor) => am.mul(result, this.value(factor)),
|
|
316
|
+
new Anum(Rational.one),
|
|
317
|
+
);
|
|
318
|
+
return am.compare(this.value(lpVar), product) === 0;
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
// check_constraint: the value of the left side against the right side, without δ.
|
|
322
|
+
private isConstraintSatisfied(constraint: LarConstraint) {
|
|
323
|
+
const am = this.solver.am;
|
|
324
|
+
const sum = getConstraintCoeffs(this.core.lra, constraint).reduce(
|
|
325
|
+
(result, entry) => am.add(result, am.mul(new Anum(entry[1]), this.value(entry[0]))),
|
|
326
|
+
new Anum(constraint.rhs.x.neg()),
|
|
327
|
+
);
|
|
328
|
+
const sign = am.compare(sum, new Anum(Rational.zero));
|
|
329
|
+
const kind = constraint.kind;
|
|
330
|
+
return kind === KIND_LE
|
|
331
|
+
? sign <= 0
|
|
332
|
+
: kind === KIND_GE
|
|
333
|
+
? sign >= 0
|
|
334
|
+
: kind === KIND_LT
|
|
335
|
+
? sign < 0
|
|
336
|
+
: kind === KIND_GT
|
|
337
|
+
? sign > 0
|
|
338
|
+
: sign === 0;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
// setup_assignment_solver and nlsat's check(rvalues, clause): the lemma clause, with the
|
|
342
|
+
// constraint each literal came from, or null when nlsat finds no violated constraint.
|
|
343
|
+
private getClause() {
|
|
344
|
+
const core = this.core;
|
|
345
|
+
const lra = core.lra;
|
|
346
|
+
this.solver = new NlsatSolver(core.limit);
|
|
347
|
+
this.lp2nl.clear();
|
|
348
|
+
const cone = getConeOfInfluence(core);
|
|
349
|
+
const definitions = this.mkDefinitions(() => true);
|
|
350
|
+
const values = lra.columns.map((_column, lpVar) => new Anum(core.val(lpVar)));
|
|
351
|
+
this.values = values;
|
|
352
|
+
const literalConstraints = new Map<number, number>();
|
|
353
|
+
for (const constraintIndex of cone.constraints) {
|
|
354
|
+
const literal = this.addConstraint(
|
|
355
|
+
constraintIndex,
|
|
356
|
+
definitions.definitions,
|
|
357
|
+
definitions.denominators,
|
|
358
|
+
);
|
|
359
|
+
literalConstraints.set(literal, constraintIndex);
|
|
360
|
+
}
|
|
361
|
+
const result = this.solver.checkAssignment(values);
|
|
362
|
+
if (result.result !== L_FALSE) return null;
|
|
363
|
+
return { clause: result.clause, literalConstraints };
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
// check_assignment
|
|
367
|
+
checkAssignment() {
|
|
368
|
+
const clause = (() => {
|
|
369
|
+
try {
|
|
370
|
+
return this.getClause();
|
|
371
|
+
} catch (error) {
|
|
372
|
+
if (error instanceof NlsatUnsupportedError) return null;
|
|
373
|
+
throw error;
|
|
374
|
+
}
|
|
375
|
+
})();
|
|
376
|
+
if (clause === null) return L_UNDEF;
|
|
377
|
+
return this.addLemma(clause.clause, clause.literalConstraints);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
// add_lemma: a literal whose negation is a constraint's literal becomes that constraint in the
|
|
381
|
+
// explanation, and any other literal an inequality over the columns. Unknown, without the lemma,
|
|
382
|
+
// when such an inequality already holds.
|
|
383
|
+
private addLemma(clause: number[], literalConstraints: ReadonlyMap<number, number>) {
|
|
384
|
+
const core = this.core;
|
|
385
|
+
const solver = this.solver;
|
|
386
|
+
const pm = solver.pm;
|
|
387
|
+
const lemma = new LemmaBuilder(core);
|
|
388
|
+
for (const literal of clause) {
|
|
389
|
+
const constraintIndex = literalConstraints.get(literal ^ 1);
|
|
390
|
+
if (constraintIndex !== undefined) {
|
|
391
|
+
const explanation = new Explanation();
|
|
392
|
+
explanation.push(constraintIndex);
|
|
393
|
+
lemma.addExplanation(explanation);
|
|
394
|
+
continue;
|
|
395
|
+
}
|
|
396
|
+
const atom = solver.getAtom(literal);
|
|
397
|
+
if (atom === null) throw new SmtInvariantError(`nlsat literal ${literal} has no atom`);
|
|
398
|
+
// A root atom or a product of factors is unknown, and so is a nonlinear polynomial.
|
|
399
|
+
if (
|
|
400
|
+
!isIneqAtom(atom) ||
|
|
401
|
+
atom.polynomials.length !== 1 ||
|
|
402
|
+
pm.totalDegree(atom.polynomials[0]) > 1
|
|
403
|
+
) {
|
|
404
|
+
core.lemmas.pop();
|
|
405
|
+
return L_UNDEF;
|
|
406
|
+
}
|
|
407
|
+
// process_polynomial_check_assignment, for a linear polynomial.
|
|
408
|
+
const polynomial = atom.polynomials[0];
|
|
409
|
+
const term = new LarTerm();
|
|
410
|
+
let bound = Rational.zero;
|
|
411
|
+
for (let index = 0; index < polynomial.size; index++) {
|
|
412
|
+
const monomial = polynomial.ms[index];
|
|
413
|
+
const coeff = Rational.of(polynomial.as[index]);
|
|
414
|
+
if (monomial.size === 0) bound = bound.sub(coeff);
|
|
415
|
+
else term.addMonomial(coeff, monomial.vars[0]);
|
|
416
|
+
}
|
|
417
|
+
const isNegated = (literal & 1) === 1;
|
|
418
|
+
const kind =
|
|
419
|
+
atom.kind === "EQ"
|
|
420
|
+
? isNegated
|
|
421
|
+
? KIND_NE
|
|
422
|
+
: KIND_EQ
|
|
423
|
+
: atom.kind === "LT"
|
|
424
|
+
? isNegated
|
|
425
|
+
? KIND_GE
|
|
426
|
+
: KIND_LT
|
|
427
|
+
: isNegated
|
|
428
|
+
? KIND_LE
|
|
429
|
+
: KIND_GT;
|
|
430
|
+
const ineq = mkIneq(term, kind, bound);
|
|
431
|
+
if (core.ineqHolds(ineq)) {
|
|
432
|
+
core.lemmas.pop();
|
|
433
|
+
return L_UNDEF;
|
|
434
|
+
}
|
|
435
|
+
lemma.addIneq(ineq);
|
|
436
|
+
}
|
|
437
|
+
core.isCheckFeasible = true;
|
|
438
|
+
return L_FALSE;
|
|
439
|
+
}
|
|
440
|
+
}
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/lp/numeric_pair.h), MIT license, see z3-license.txt. The value x + δy
|
|
2
|
+
// of a column, where δ is a positive infinitesimal that encodes strict bounds.
|
|
3
|
+
import { Rational } from "../rational";
|
|
4
|
+
|
|
5
|
+
export class Impq {
|
|
6
|
+
static readonly zero = new Impq(Rational.zero, Rational.zero);
|
|
7
|
+
|
|
8
|
+
constructor(
|
|
9
|
+
readonly x: Rational,
|
|
10
|
+
readonly y: Rational = Rational.zero,
|
|
11
|
+
) {}
|
|
12
|
+
|
|
13
|
+
add(other: Impq) {
|
|
14
|
+
return new Impq(this.x.add(other.x), this.y.add(other.y));
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
sub(other: Impq) {
|
|
18
|
+
return new Impq(this.x.sub(other.x), this.y.sub(other.y));
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
mul(coeff: Rational) {
|
|
22
|
+
return new Impq(this.x.mul(coeff), this.y.mul(coeff));
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
div(coeff: Rational) {
|
|
26
|
+
return new Impq(this.x.div(coeff), this.y.div(coeff));
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
neg() {
|
|
30
|
+
return new Impq(this.x.neg(), this.y.neg());
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
// Lexicographic, as δ is smaller than any positive rational.
|
|
34
|
+
compare(other: Impq) {
|
|
35
|
+
const byX = this.x.compare(other.x);
|
|
36
|
+
return byX !== 0 ? byX : this.y.compare(other.y);
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
equals(other: Impq) {
|
|
40
|
+
return this.x.equals(other.x) && this.y.equals(other.y);
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
isZero() {
|
|
44
|
+
return this.x.isZero() && this.y.isZero();
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
isInt() {
|
|
48
|
+
return this.y.isZero() && this.x.isInt();
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
// floor and ceil of numeric_pair: x + δy rounded, for a positive δ smaller than any gap.
|
|
52
|
+
floor() {
|
|
53
|
+
if (!this.x.isInt()) return this.x.floor();
|
|
54
|
+
return this.y.isNegative() ? this.x.sub(Rational.one) : this.x;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
ceil() {
|
|
58
|
+
if (!this.x.isInt()) return this.x.ceil();
|
|
59
|
+
return this.y.isPositive() ? this.x.add(Rational.one) : this.x;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
toString() {
|
|
63
|
+
return this.y.isZero() ? this.x.toString() : `(${this.x}, ${this.y})`;
|
|
64
|
+
}
|
|
65
|
+
}
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/dd/pdd_interval.h), MIT license, see z3-license.txt. The interval of a
|
|
2
|
+
// pdd under the intervals of its variables, as x*hi + lo by interval arithmetic. The distributed
|
|
3
|
+
// variant, which nla does not call, is not ported.
|
|
4
|
+
import {
|
|
5
|
+
add,
|
|
6
|
+
type DepInterval,
|
|
7
|
+
type DepsMode,
|
|
8
|
+
mkDepInterval,
|
|
9
|
+
mul,
|
|
10
|
+
setValue,
|
|
11
|
+
} from "./dep-intervals";
|
|
12
|
+
import type { Pdd } from "./pdd";
|
|
13
|
+
|
|
14
|
+
export const getPddInterval = (
|
|
15
|
+
poly: Pdd,
|
|
16
|
+
mode: DepsMode,
|
|
17
|
+
getVarInterval: (variable: number, mode: DepsMode) => DepInterval,
|
|
18
|
+
): DepInterval => {
|
|
19
|
+
const result = mkDepInterval();
|
|
20
|
+
if (poly.isVal()) {
|
|
21
|
+
setValue(result, poly.val());
|
|
22
|
+
return result;
|
|
23
|
+
}
|
|
24
|
+
const varInterval = getVarInterval(poly.var(), mode);
|
|
25
|
+
const hi = getPddInterval(poly.hi(), mode, getVarInterval);
|
|
26
|
+
const lo = getPddInterval(poly.lo(), mode, getVarInterval);
|
|
27
|
+
const product = mkDepInterval();
|
|
28
|
+
mul(hi, varInterval, product, mode);
|
|
29
|
+
add(product, lo, result, mode);
|
|
30
|
+
return result;
|
|
31
|
+
};
|