tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.2da24e1
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 +37 -126
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +33 -1
- package/dist/index.d.ts +33 -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 +37 -47
- package/dist/run-cli.js +37 -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} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/{obligation-source.ts → obligations/source.ts} +154 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- 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 +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -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 +446 -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 +508 -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 +529 -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 +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -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 +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +181 -0
- package/src/prove/smt/rewrite.ts +772 -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 +96 -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 +379 -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 +283 -81
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -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,184 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/grobner/pdd_simplifier.h, src/math/grobner/pdd_simplifier.cpp), MIT
|
|
2
|
+
// license, see z3-license.txt. The passes that dd::solver::simplify runs before saturation: solve
|
|
3
|
+
// linear equations for their top variable, retire equations whose top variable occurs nowhere
|
|
4
|
+
// else, subtract equations that share a lo part, and eliminate variables that occur as leaves.
|
|
5
|
+
// The extended linear pass works only modulo 2 and the dual elimination is disabled in Z3, so
|
|
6
|
+
// neither is ported. No pass makes a value outside an operation, so none can run out of nodes.
|
|
7
|
+
import { mkJoin } from "./dependency";
|
|
8
|
+
import { Equation, PddSolver, SetUpdate, SOLVED, TO_SIMPLIFY } from "./pdd-solver";
|
|
9
|
+
import { shrink } from "../array";
|
|
10
|
+
|
|
11
|
+
export class PddSimplifier {
|
|
12
|
+
constructor(private solver: PddSolver) {}
|
|
13
|
+
|
|
14
|
+
run() {
|
|
15
|
+
while (
|
|
16
|
+
!this.solver.isDone() &&
|
|
17
|
+
(this.simplifyLinearStep(true) ||
|
|
18
|
+
this.simplifyElimPureStep() ||
|
|
19
|
+
this.simplifyCcStep() ||
|
|
20
|
+
this.simplifyLeafStep() ||
|
|
21
|
+
this.simplifyLinearStep(false))
|
|
22
|
+
);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
private simplifyLinearStep(isBinary: boolean) {
|
|
26
|
+
const linear = this.solver.toSimplify.filter((equation) =>
|
|
27
|
+
isBinary ? equation.poly.isBinary() : equation.poly.isLinear(),
|
|
28
|
+
);
|
|
29
|
+
if (linear.length === 0) return false;
|
|
30
|
+
return this.simplifyLinear(linear);
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
// simplify_linear_step: solves each linear equation for its top variable, which it eliminates
|
|
34
|
+
// from the others, and moves it to the solved equations.
|
|
35
|
+
private simplifyLinear(linear: Equation[]) {
|
|
36
|
+
const solver = this.solver;
|
|
37
|
+
const useList = this.getUseList();
|
|
38
|
+
linear.sort((first, second) => first.poly.var() - second.poly.var());
|
|
39
|
+
const trivial: Equation[] = [];
|
|
40
|
+
let kept = 0;
|
|
41
|
+
let hasConflict = false;
|
|
42
|
+
for (const source of linear) {
|
|
43
|
+
if (hasConflict) break;
|
|
44
|
+
if (solver.isTrivial(source)) continue;
|
|
45
|
+
const variable = source.poly.var();
|
|
46
|
+
const uses = useList[variable];
|
|
47
|
+
let isAllReduced = true;
|
|
48
|
+
// Equations added to the uses of the variable during the walk are not walked.
|
|
49
|
+
for (let index = 0, length = uses.length; index < length; index++) {
|
|
50
|
+
const target = uses[index];
|
|
51
|
+
if (source === target || solver.isTrivial(target)) continue;
|
|
52
|
+
if (!source.poly.isBinary() && !target.poly.isLinear()) {
|
|
53
|
+
isAllReduced = false;
|
|
54
|
+
continue;
|
|
55
|
+
}
|
|
56
|
+
this.removeFromUse(target, useList, variable);
|
|
57
|
+
const isLeadingTermChanged = solver.simplifyUsing(target, source);
|
|
58
|
+
if (solver.isTrivial(target)) {
|
|
59
|
+
trivial.push(target);
|
|
60
|
+
} else if (solver.isConflict(target)) {
|
|
61
|
+
solver.popEquation(target);
|
|
62
|
+
solver.setConflict(target);
|
|
63
|
+
hasConflict = true;
|
|
64
|
+
} else if (isLeadingTermChanged) {
|
|
65
|
+
solver.popEquation(target);
|
|
66
|
+
solver.pushEquation(TO_SIMPLIFY, target);
|
|
67
|
+
}
|
|
68
|
+
this.addToUse(target, useList);
|
|
69
|
+
}
|
|
70
|
+
if (isAllReduced) linear[kept++] = source;
|
|
71
|
+
}
|
|
72
|
+
if (!hasConflict) {
|
|
73
|
+
shrink(linear, kept);
|
|
74
|
+
for (const source of linear) {
|
|
75
|
+
solver.popEquation(source);
|
|
76
|
+
solver.pushEquation(SOLVED, source);
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
for (const equation of trivial) solver.popEquation(equation);
|
|
80
|
+
return kept > 0 || hasConflict;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
// simplify_cc_step: replaces p*x + q and r*y + q by p*x + q and p*x - r*y, when p or r is a value.
|
|
84
|
+
private simplifyCcStep() {
|
|
85
|
+
const solver = this.solver;
|
|
86
|
+
const los = new Map<number, Equation>();
|
|
87
|
+
let isReduced = false;
|
|
88
|
+
const update = new SetUpdate(solver.toSimplify);
|
|
89
|
+
for (; update.i < update.size; update.i++) {
|
|
90
|
+
const first = update.get();
|
|
91
|
+
const poly = first.poly;
|
|
92
|
+
const second = los.get(poly.lo().root) ?? first;
|
|
93
|
+
if (second === first) los.set(poly.lo().root, first);
|
|
94
|
+
if (
|
|
95
|
+
second !== first &&
|
|
96
|
+
(poly.hi().isVal() || second.poly.hi().isVal()) &&
|
|
97
|
+
!poly.lo().isVal()
|
|
98
|
+
) {
|
|
99
|
+
first.poly = poly.sub(second.poly);
|
|
100
|
+
first.dep = mkJoin(first.dep, second.dep);
|
|
101
|
+
isReduced = true;
|
|
102
|
+
if (solver.isTrivial(first) || solver.checkConflict(first)) continue;
|
|
103
|
+
}
|
|
104
|
+
update.nextj();
|
|
105
|
+
}
|
|
106
|
+
update.finish();
|
|
107
|
+
return isReduced;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
// simplify_leaf_step: removes a*x + b from the equations where x occurs as a leaf, for a value a.
|
|
111
|
+
private simplifyLeafStep() {
|
|
112
|
+
const solver = this.solver;
|
|
113
|
+
const useList = this.getUseList();
|
|
114
|
+
for (let index = 0; index < solver.toSimplify.length; index++) {
|
|
115
|
+
const source = solver.toSimplify[index];
|
|
116
|
+
const poly = source.poly;
|
|
117
|
+
if (poly.isVal() || !poly.hi().isVal()) continue;
|
|
118
|
+
const leaves = useList[poly.var()].filter(
|
|
119
|
+
(target) => target !== source && target.poly.varIsLeaf(poly.var()),
|
|
120
|
+
);
|
|
121
|
+
for (const target of leaves) {
|
|
122
|
+
this.removeFromUse(target, useList);
|
|
123
|
+
const isLeadingTermChanged = solver.simplifyUsing(target, source);
|
|
124
|
+
this.addToUse(target, useList);
|
|
125
|
+
if (solver.isTrivial(target)) {
|
|
126
|
+
solver.popEquation(target);
|
|
127
|
+
} else if (target.poly.isVal()) {
|
|
128
|
+
solver.popEquation(target);
|
|
129
|
+
solver.setConflict(target);
|
|
130
|
+
return true;
|
|
131
|
+
} else if (isLeadingTermChanged) {
|
|
132
|
+
solver.popEquation(target);
|
|
133
|
+
solver.pushEquation(TO_SIMPLIFY, target);
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
return false;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
// simplify_elim_pure_step: an equation linear in its top variable, which occurs nowhere else, is
|
|
141
|
+
// solved.
|
|
142
|
+
private simplifyElimPureStep() {
|
|
143
|
+
const solver = this.solver;
|
|
144
|
+
const useList = this.getUseList();
|
|
145
|
+
const update = new SetUpdate(solver.toSimplify);
|
|
146
|
+
let hasSolved = false;
|
|
147
|
+
for (; update.i < update.size; update.i++) {
|
|
148
|
+
const equation = update.get();
|
|
149
|
+
const poly = equation.poly;
|
|
150
|
+
if (!poly.isVal() && poly.hi().isVal() && useList[poly.var()].length === 1) {
|
|
151
|
+
solver.pushEquation(SOLVED, equation);
|
|
152
|
+
hasSolved = true;
|
|
153
|
+
} else {
|
|
154
|
+
update.nextj();
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
update.finish();
|
|
158
|
+
return hasSolved;
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
private addToUse(equation: Equation, useList: Equation[][]) {
|
|
162
|
+
for (const variable of equation.poly.freeVars()) {
|
|
163
|
+
while (useList.length <= variable) useList.push([]);
|
|
164
|
+
useList[variable].push(equation);
|
|
165
|
+
}
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
private removeFromUse(equation: Equation, useList: Equation[][], exceptVar = -1) {
|
|
169
|
+
for (const variable of equation.poly.freeVars()) {
|
|
170
|
+
if (variable === exceptVar) continue;
|
|
171
|
+
while (useList.length <= variable) useList.push([]);
|
|
172
|
+
const uses = useList[variable];
|
|
173
|
+
const index = uses.indexOf(equation);
|
|
174
|
+
if (index !== -1) uses.splice(index, 1);
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
private getUseList() {
|
|
179
|
+
const useList: Equation[][] = [];
|
|
180
|
+
for (const equation of this.solver.toSimplify) this.addToUse(equation, useList);
|
|
181
|
+
for (const equation of this.solver.processed) this.addToUse(equation, useList);
|
|
182
|
+
return useList;
|
|
183
|
+
}
|
|
184
|
+
}
|
|
@@ -0,0 +1,408 @@
|
|
|
1
|
+
// Ported from Z3 (src/math/grobner/pdd_solver.h, src/math/grobner/pdd_solver.cpp), MIT license,
|
|
2
|
+
// see z3-license.txt. dd::solver, the Grobner basis completion that nla runs on polynomials as
|
|
3
|
+
// pdds. Each step picks the simplest equation whose leading variable is highest, simplifies it by
|
|
4
|
+
// the processed equations and them by it, and adds its S-polynomials with them to be simplified.
|
|
5
|
+
// Equations move between the solved, processed and to-simplify sets, each in an array where an
|
|
6
|
+
// equation knows its index. Z3's solver::simplify runs the simplifier, which here is PddSimplifier
|
|
7
|
+
// in pdd-simplifier, run by its caller.
|
|
8
|
+
import { PddMemoryOutError } from "../../../../errors";
|
|
9
|
+
import { Dependency, mkJoin } from "./dependency";
|
|
10
|
+
import { Pdd, PddManager } from "./pdd";
|
|
11
|
+
import { shrink } from "../array";
|
|
12
|
+
|
|
13
|
+
export const SOLVED = 0;
|
|
14
|
+
const PROCESSED = 1;
|
|
15
|
+
export const TO_SIMPLIFY = 2;
|
|
16
|
+
|
|
17
|
+
const UINT_MAX = 0xffffffff;
|
|
18
|
+
|
|
19
|
+
interface PddSolverConfig {
|
|
20
|
+
eqsThreshold: number;
|
|
21
|
+
exprSizeLimit: number;
|
|
22
|
+
exprDegreeLimit: number;
|
|
23
|
+
maxSteps: number;
|
|
24
|
+
maxSimplified: number;
|
|
25
|
+
eqsGrowth: number;
|
|
26
|
+
exprSizeGrowth: number;
|
|
27
|
+
exprDegreeGrowth: number;
|
|
28
|
+
numberOfConflictsToReport: number;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export const getDefaultPddSolverConfig = (): PddSolverConfig => ({
|
|
32
|
+
eqsThreshold: UINT_MAX,
|
|
33
|
+
exprSizeLimit: UINT_MAX,
|
|
34
|
+
exprDegreeLimit: UINT_MAX,
|
|
35
|
+
maxSteps: UINT_MAX,
|
|
36
|
+
maxSimplified: UINT_MAX,
|
|
37
|
+
eqsGrowth: 10,
|
|
38
|
+
exprSizeGrowth: 10,
|
|
39
|
+
exprDegreeGrowth: 5,
|
|
40
|
+
numberOfConflictsToReport: 1,
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
interface Subst {
|
|
44
|
+
variable: number;
|
|
45
|
+
poly: Pdd;
|
|
46
|
+
dep: Dependency;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
class PddSolverStats {
|
|
50
|
+
simplified = 0;
|
|
51
|
+
maxExprSize = 0;
|
|
52
|
+
maxExprDegree = 0;
|
|
53
|
+
superposed = 0;
|
|
54
|
+
computeSteps = 0;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
export class Equation {
|
|
58
|
+
state = TO_SIMPLIFY;
|
|
59
|
+
idx = 0;
|
|
60
|
+
|
|
61
|
+
constructor(
|
|
62
|
+
public poly: Pdd,
|
|
63
|
+
public dep: Dependency,
|
|
64
|
+
) {}
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
// scoped_update: walks a set with i and keeps the equations that nextj moves to j. finish keeps
|
|
68
|
+
// those not walked and drops the rest, as Z3's destructor does.
|
|
69
|
+
export class SetUpdate {
|
|
70
|
+
i = 0;
|
|
71
|
+
private j = 0;
|
|
72
|
+
readonly size: number;
|
|
73
|
+
|
|
74
|
+
constructor(private set: Equation[]) {
|
|
75
|
+
this.size = set.length;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
get() {
|
|
79
|
+
return this.set[this.i];
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
nextj() {
|
|
83
|
+
this.set[this.j] = this.set[this.i];
|
|
84
|
+
this.set[this.i].idx = this.j++;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
finish() {
|
|
88
|
+
for (; this.i < this.size; this.i++) this.nextj();
|
|
89
|
+
shrink(this.set, this.j);
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
export class PddSolver {
|
|
94
|
+
stats = new PddSolverStats();
|
|
95
|
+
config = getDefaultPddSolverConfig();
|
|
96
|
+
solved: Equation[] = [];
|
|
97
|
+
processed: Equation[] = [];
|
|
98
|
+
toSimplify: Equation[] = [];
|
|
99
|
+
private substs: Subst[] = [];
|
|
100
|
+
conflict: Equation | null = null;
|
|
101
|
+
private isTooComplexFound = false;
|
|
102
|
+
private levelp1 = 0;
|
|
103
|
+
private level2var: number[] = [];
|
|
104
|
+
private var2level: number[] = [];
|
|
105
|
+
|
|
106
|
+
constructor(
|
|
107
|
+
readonly manager: PddManager,
|
|
108
|
+
private isCanceled: () => boolean,
|
|
109
|
+
) {}
|
|
110
|
+
|
|
111
|
+
adjustConfig() {
|
|
112
|
+
const config = this.config;
|
|
113
|
+
const count = this.toSimplify.length;
|
|
114
|
+
config.eqsThreshold = Math.trunc(config.eqsGrowth * Math.ceil(Math.log(1 + count)) * count);
|
|
115
|
+
config.exprSizeLimit = 0;
|
|
116
|
+
config.exprDegreeLimit = 0;
|
|
117
|
+
for (const equation of this.toSimplify) {
|
|
118
|
+
config.exprSizeLimit = Math.max(config.exprSizeLimit, equation.poly.treeSize());
|
|
119
|
+
config.exprDegreeLimit = Math.max(config.exprDegreeLimit, equation.poly.degree());
|
|
120
|
+
}
|
|
121
|
+
config.exprSizeLimit *= config.exprSizeGrowth;
|
|
122
|
+
config.exprDegreeLimit *= config.exprDegreeGrowth;
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
reset() {
|
|
126
|
+
this.substs = [];
|
|
127
|
+
this.solved = [];
|
|
128
|
+
this.processed = [];
|
|
129
|
+
this.toSimplify = [];
|
|
130
|
+
this.stats = new PddSolverStats();
|
|
131
|
+
this.level2var = [];
|
|
132
|
+
this.var2level = [];
|
|
133
|
+
this.conflict = null;
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
add(poly: Pdd, dep: Dependency = null) {
|
|
137
|
+
if (poly.isZero()) return;
|
|
138
|
+
const equation = new Equation(poly, dep);
|
|
139
|
+
if (this.checkConflict(equation)) return;
|
|
140
|
+
this.pushEquation(TO_SIMPLIFY, equation);
|
|
141
|
+
if (this.var2level.length > 0) {
|
|
142
|
+
this.levelp1 = Math.max(this.var2level[poly.var()] + 1, this.levelp1);
|
|
143
|
+
}
|
|
144
|
+
this.updateStats(equation);
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
// simplify: applies the substitutions to p, and returns it with its dependency.
|
|
148
|
+
simplify(poly: Pdd, dep: Dependency) {
|
|
149
|
+
let result = poly;
|
|
150
|
+
let resultDep = dep;
|
|
151
|
+
for (const subst of this.substs) {
|
|
152
|
+
const substituted = result.substPdd(subst.variable, subst.poly);
|
|
153
|
+
if (substituted.equals(result)) continue;
|
|
154
|
+
result = substituted;
|
|
155
|
+
resultDep = mkJoin(resultDep, subst.dep);
|
|
156
|
+
}
|
|
157
|
+
return { poly: result, dep: resultDep };
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
addSubst(variable: number, poly: Pdd, dep: Dependency) {
|
|
161
|
+
this.substs.push({ variable, poly, dep });
|
|
162
|
+
if (this.var2level.length > 0) {
|
|
163
|
+
this.levelp1 = Math.max(
|
|
164
|
+
this.var2level[variable] + 1,
|
|
165
|
+
Math.max(this.var2level[poly.var()] + 1, this.levelp1),
|
|
166
|
+
);
|
|
167
|
+
}
|
|
168
|
+
const simplifier = (target: Equation) => {
|
|
169
|
+
const substituted = target.poly.substPdd(variable, poly);
|
|
170
|
+
if (substituted.equals(target.poly)) return null;
|
|
171
|
+
if (this.isTooComplex(substituted)) {
|
|
172
|
+
this.isTooComplexFound = true;
|
|
173
|
+
return null;
|
|
174
|
+
}
|
|
175
|
+
const isLeadingTermChanged = substituted.differentLeadingTerm(target.poly);
|
|
176
|
+
target.poly = substituted;
|
|
177
|
+
target.dep = mkJoin(target.dep, dep);
|
|
178
|
+
this.updateStats(target);
|
|
179
|
+
return isLeadingTermChanged;
|
|
180
|
+
};
|
|
181
|
+
if (!this.isDone()) this.simplifySetUsing(this.processed, simplifier);
|
|
182
|
+
if (!this.isDone()) this.simplifySetUsing(this.toSimplify, simplifier);
|
|
183
|
+
if (!this.isDone()) this.simplifySetUsing(this.solved, simplifier);
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
saturate() {
|
|
187
|
+
if (this.isDone()) return;
|
|
188
|
+
this.initSaturate();
|
|
189
|
+
try {
|
|
190
|
+
while (!this.isDone() && this.step());
|
|
191
|
+
} catch (error) {
|
|
192
|
+
if (!(error instanceof PddMemoryOutError)) throw error;
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
equations() {
|
|
197
|
+
return [...this.solved, ...this.toSimplify, ...this.processed];
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
private step() {
|
|
201
|
+
this.stats.computeSteps++;
|
|
202
|
+
const equation = this.pickNext();
|
|
203
|
+
if (equation === null) return false;
|
|
204
|
+
// scoped_process: the equation goes back to processed unless the step settles it.
|
|
205
|
+
let pending: Equation | null = equation;
|
|
206
|
+
try {
|
|
207
|
+
this.simplifyUsingAll(equation, this.processed);
|
|
208
|
+
if (this.isTrivial(equation)) {
|
|
209
|
+
pending = null;
|
|
210
|
+
return true;
|
|
211
|
+
}
|
|
212
|
+
if (this.checkConflict(equation)) {
|
|
213
|
+
pending = null;
|
|
214
|
+
return false;
|
|
215
|
+
}
|
|
216
|
+
this.isTooComplexFound = false;
|
|
217
|
+
this.simplifySetUsingEquation(this.processed, equation);
|
|
218
|
+
if (this.isDone()) return false;
|
|
219
|
+
for (const target of this.processed) this.superpose(equation, target);
|
|
220
|
+
this.simplifySetUsingEquation(this.toSimplify, equation);
|
|
221
|
+
if (this.isDone()) return false;
|
|
222
|
+
if (!this.isTooComplexFound) {
|
|
223
|
+
pending = null;
|
|
224
|
+
this.pushEquation(equation.poly.degree() === 1 ? SOLVED : PROCESSED, equation);
|
|
225
|
+
}
|
|
226
|
+
return true;
|
|
227
|
+
} finally {
|
|
228
|
+
if (pending !== null) this.pushEquation(PROCESSED, pending);
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
private initSaturate() {
|
|
233
|
+
const level2var = this.manager.level2var;
|
|
234
|
+
this.level2var = [...level2var];
|
|
235
|
+
this.var2level = [];
|
|
236
|
+
for (let level = 0; level < level2var.length; level++) this.var2level[level2var[level]] = level;
|
|
237
|
+
this.levelp1 = level2var.length;
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
private pickNext() {
|
|
241
|
+
while (this.levelp1 > 0) {
|
|
242
|
+
const variable = this.level2var[this.levelp1 - 1];
|
|
243
|
+
let picked: Equation | null = null;
|
|
244
|
+
for (const current of this.toSimplify) {
|
|
245
|
+
if (current.state !== TO_SIMPLIFY || current.poly.var() !== variable) continue;
|
|
246
|
+
if (picked === null || this.isSimpler(current, picked)) picked = current;
|
|
247
|
+
}
|
|
248
|
+
if (picked !== null) {
|
|
249
|
+
this.popEquation(picked);
|
|
250
|
+
return picked;
|
|
251
|
+
}
|
|
252
|
+
this.levelp1--;
|
|
253
|
+
}
|
|
254
|
+
return null;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
private superpose(first: Equation, second: Equation) {
|
|
258
|
+
const poly = this.manager.trySpoly(first.poly, second.poly);
|
|
259
|
+
if (poly === null || poly.isZero()) return;
|
|
260
|
+
if (this.isTooComplex(poly)) {
|
|
261
|
+
this.isTooComplexFound = true;
|
|
262
|
+
return;
|
|
263
|
+
}
|
|
264
|
+
this.stats.superposed++;
|
|
265
|
+
this.add(poly, mkJoin(first.dep, second.dep));
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
// simplify_using(eq, eqs): reduces eq by the set until no reduction applies.
|
|
269
|
+
private simplifyUsingAll(equation: Equation, set: Equation[]) {
|
|
270
|
+
let isSimplified = false;
|
|
271
|
+
do {
|
|
272
|
+
isSimplified = false;
|
|
273
|
+
for (const source of set) {
|
|
274
|
+
if (this.trySimplifyUsing(equation, source) !== null) isSimplified = true;
|
|
275
|
+
if (this.isCanceled() || equation.poly.isVal()) break;
|
|
276
|
+
}
|
|
277
|
+
} while (isSimplified && !equation.poly.isVal());
|
|
278
|
+
if (equation.poly.isUnary() && equation.poly.hi().val().isNegative()) {
|
|
279
|
+
equation.poly = equation.poly.neg();
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
private simplifySetUsingEquation(set: Equation[], source: Equation) {
|
|
284
|
+
this.simplifySetUsing(set, (target) => this.trySimplifyUsing(target, source));
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
// simplify_using(set, simplifier): the simplifier returns null when it leaves the target, and
|
|
288
|
+
// otherwise whether the leading term changed.
|
|
289
|
+
private simplifySetUsing(set: Equation[], simplifier: (target: Equation) => boolean | null) {
|
|
290
|
+
const update = new SetUpdate(set);
|
|
291
|
+
for (; update.i < update.size; update.i++) {
|
|
292
|
+
const target = set[update.i];
|
|
293
|
+
const isLeadingTermChanged = this.isDone() ? null : simplifier(target);
|
|
294
|
+
if (isLeadingTermChanged !== null && this.isTrivial(target)) continue;
|
|
295
|
+
if (isLeadingTermChanged !== null && this.checkConflict(target)) continue;
|
|
296
|
+
if (isLeadingTermChanged === true) {
|
|
297
|
+
if (set === this.toSimplify) update.nextj();
|
|
298
|
+
else this.pushEquation(TO_SIMPLIFY, target);
|
|
299
|
+
if (this.var2level.length > 0) {
|
|
300
|
+
this.levelp1 = Math.max(this.var2level[target.poly.var()] + 1, this.levelp1);
|
|
301
|
+
}
|
|
302
|
+
continue;
|
|
303
|
+
}
|
|
304
|
+
update.nextj();
|
|
305
|
+
}
|
|
306
|
+
update.finish();
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
// try_simplify_using: null when the target stays, and otherwise whether its leading term changed
|
|
310
|
+
// while it was processed.
|
|
311
|
+
private trySimplifyUsing(target: Equation, source: Equation) {
|
|
312
|
+
if (source === target) return null;
|
|
313
|
+
this.stats.simplified++;
|
|
314
|
+
const reduced = target.poly.reduce(source.poly);
|
|
315
|
+
if (reduced.equals(target.poly)) return null;
|
|
316
|
+
if (this.isTooComplex(reduced)) {
|
|
317
|
+
this.isTooComplexFound = true;
|
|
318
|
+
return null;
|
|
319
|
+
}
|
|
320
|
+
const isLeadingTermChanged =
|
|
321
|
+
target.state === PROCESSED && reduced.differentLeadingTerm(target.poly);
|
|
322
|
+
target.poly = reduced;
|
|
323
|
+
target.dep = mkJoin(target.dep, source.dep);
|
|
324
|
+
this.updateStats(target);
|
|
325
|
+
return isLeadingTermChanged;
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
// simplify_using(dst, src): reduces dst by src whatever the result, and returns whether its
|
|
329
|
+
// leading term changed while it was processed.
|
|
330
|
+
simplifyUsing(target: Equation, source: Equation) {
|
|
331
|
+
if (source === target) return false;
|
|
332
|
+
this.stats.simplified++;
|
|
333
|
+
const reduced = target.poly.reduce(source.poly);
|
|
334
|
+
const isLeadingTermChanged =
|
|
335
|
+
target.state === PROCESSED && reduced.differentLeadingTerm(target.poly);
|
|
336
|
+
if (reduced.equals(target.poly)) return isLeadingTermChanged;
|
|
337
|
+
target.poly = reduced;
|
|
338
|
+
target.dep = mkJoin(target.dep, source.dep);
|
|
339
|
+
this.updateStats(target);
|
|
340
|
+
return isLeadingTermChanged;
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
isDone() {
|
|
344
|
+
return (
|
|
345
|
+
this.toSimplify.length + this.processed.length >= this.config.eqsThreshold ||
|
|
346
|
+
this.stats.simplified >= this.config.maxSimplified ||
|
|
347
|
+
this.isCanceled() ||
|
|
348
|
+
this.stats.computeSteps > this.config.maxSteps ||
|
|
349
|
+
this.conflict !== null
|
|
350
|
+
);
|
|
351
|
+
}
|
|
352
|
+
|
|
353
|
+
isTrivial(equation: Equation) {
|
|
354
|
+
return equation.poly.isZero();
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
isConflict(equation: Equation) {
|
|
358
|
+
return equation.poly.isVal() && !this.isTrivial(equation);
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
checkConflict(equation: Equation) {
|
|
362
|
+
if (!this.isConflict(equation)) return false;
|
|
363
|
+
this.setConflict(equation);
|
|
364
|
+
return true;
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
setConflict(equation: Equation) {
|
|
368
|
+
this.conflict = equation;
|
|
369
|
+
this.pushEquation(SOLVED, equation);
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
private isSimpler(first: Equation, second: Equation) {
|
|
373
|
+
return this.manager.lmLt(first.poly, second.poly);
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
private isTooComplex(poly: Pdd) {
|
|
377
|
+
return (
|
|
378
|
+
poly.treeSize() > this.config.exprSizeLimit || poly.degree() > this.config.exprDegreeLimit
|
|
379
|
+
);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
private getQueue(state: number) {
|
|
383
|
+
if (state === PROCESSED) return this.processed;
|
|
384
|
+
return state === TO_SIMPLIFY ? this.toSimplify : this.solved;
|
|
385
|
+
}
|
|
386
|
+
|
|
387
|
+
popEquation(equation: Equation) {
|
|
388
|
+
const set = this.getQueue(equation.state);
|
|
389
|
+
const last = set[set.length - 1];
|
|
390
|
+
if (equation.idx !== set.length - 1) {
|
|
391
|
+
last.idx = equation.idx;
|
|
392
|
+
set[equation.idx] = last;
|
|
393
|
+
}
|
|
394
|
+
set.pop();
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
pushEquation(state: number, equation: Equation) {
|
|
398
|
+
equation.state = state;
|
|
399
|
+
const set = this.getQueue(state);
|
|
400
|
+
equation.idx = set.length;
|
|
401
|
+
set.push(equation);
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
private updateStats(equation: Equation) {
|
|
405
|
+
this.stats.maxExprSize = Math.max(this.stats.maxExprSize, equation.poly.treeSize());
|
|
406
|
+
this.stats.maxExprDegree = Math.max(this.stats.maxExprDegree, equation.poly.degree());
|
|
407
|
+
}
|
|
408
|
+
}
|