tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315
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/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +56 -56
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -92
- package/dist/transfer.js +97 -92
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +518 -281
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +18 -4
- package/src/cli/tlc.ts +18 -12
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +155 -66
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +152 -25
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +179 -60
- package/src/liveness.ts +55 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +3 -2
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/bv1-blast.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +84 -15
- package/src/prover/smt/solver/ctx-simplify.ts +9 -4
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
- package/src/prover/smt/solver/diff-neq.ts +9 -8
- package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
- package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -11
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +608 -139
- package/src/prover/smt/solver/fix-dl-var.ts +2 -3
- package/src/prover/smt/solver/fm-tactic.ts +9 -7
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/lia2pb.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +2 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/normalize-bounds.ts +2 -2
- package/src/prover/smt/solver/occf.ts +1 -1
- package/src/prover/smt/solver/opt-context.ts +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/purify-arith.ts +51 -49
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/reduce-args.ts +2 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
- package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +2 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +718 -213
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -4
- package/src/prover/smt/solver/tactic.ts +389 -199
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1311 -268
- package/src/runtime.ts +21 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +19 -12
- package/src/sany/generator.ts +12 -6
- package/src/sany/lexer.ts +15 -7
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +12 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +321 -135
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +666 -147
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- package/src/tlc/trace-spec.ts +9 -22
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
|
@@ -8,12 +8,14 @@ import {
|
|
|
8
8
|
TRUE_BOOL_VAR,
|
|
9
9
|
TRUE_LITERAL,
|
|
10
10
|
} from "./atoms";
|
|
11
|
-
import {
|
|
11
|
+
import { type CellInterval, Levelwise, releaseIntervals, TodoSet } from "./levelwise";
|
|
12
12
|
import {
|
|
13
13
|
NULL_VAR,
|
|
14
14
|
type Polynomial,
|
|
15
15
|
type PolynomialCache,
|
|
16
16
|
type PolynomialManager,
|
|
17
|
+
PolynomialRef,
|
|
18
|
+
PolynomialRefVector,
|
|
17
19
|
} from "./polynomial";
|
|
18
20
|
import { type IneqAtom, type IneqKind, type RootKind, isIneqAtom } from "./types";
|
|
19
21
|
|
|
@@ -64,9 +66,13 @@ const getKindForSign = (sign: number): IneqKind => (sign === 0 ? "EQ" : sign < 0
|
|
|
64
66
|
export class Explain {
|
|
65
67
|
private result: ScopedLiterals | null = null;
|
|
66
68
|
private added = new Set<number>();
|
|
69
|
+
private ps: PolynomialRefVector;
|
|
70
|
+
private factors: PolynomialRefVector;
|
|
71
|
+
private factorsSave: PolynomialRefVector;
|
|
67
72
|
private todo: TodoSet;
|
|
68
|
-
private lowerStagePolys: Polynomial[] = [];
|
|
69
73
|
private core: ScopedLiterals;
|
|
74
|
+
private lowerStagePolys: PolynomialRefVector;
|
|
75
|
+
private lastLwsInputPolys: PolynomialRefVector;
|
|
70
76
|
private isAddAllCoeffs = false;
|
|
71
77
|
|
|
72
78
|
isFullDimensional = false;
|
|
@@ -78,8 +84,13 @@ export class Explain {
|
|
|
78
84
|
private cache: PolynomialCache,
|
|
79
85
|
private context: ExplainContext,
|
|
80
86
|
) {
|
|
81
|
-
this.
|
|
87
|
+
this.ps = new PolynomialRefVector(pm);
|
|
88
|
+
this.factors = new PolynomialRefVector(pm);
|
|
89
|
+
this.factorsSave = new PolynomialRefVector(pm);
|
|
90
|
+
this.todo = new TodoSet(cache, true);
|
|
82
91
|
this.core = new ScopedLiterals(context.atoms);
|
|
92
|
+
this.lowerStagePolys = new PolynomialRefVector(pm);
|
|
93
|
+
this.lastLwsInputPolys = new PolynomialRefVector(pm);
|
|
83
94
|
}
|
|
84
95
|
|
|
85
96
|
private getSign(polynomial: Polynomial) {
|
|
@@ -106,16 +117,13 @@ export class Explain {
|
|
|
106
117
|
this.core.reset();
|
|
107
118
|
}
|
|
108
119
|
|
|
109
|
-
private collectPolys(literals: readonly number[]) {
|
|
110
|
-
|
|
120
|
+
private collectPolys(literals: readonly number[], ps: PolynomialRefVector) {
|
|
121
|
+
ps.reset();
|
|
122
|
+
for (const literal of literals) {
|
|
111
123
|
const atom = this.getAtom(literal);
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
private addAssumption(kind: IneqKind, polynomial: Polynomial, isNeg = false) {
|
|
117
|
-
const boolVar = this.context.atoms.mkIneqAtom(kind, [polynomial], [false]);
|
|
118
|
-
this.addLiteral(2 * boolVar + (isNeg ? 0 : 1));
|
|
124
|
+
if (isIneqAtom(atom)) for (const polynomial of atom.polynomials) ps.push(polynomial);
|
|
125
|
+
else ps.push(atom.polynomial);
|
|
126
|
+
}
|
|
119
127
|
}
|
|
120
128
|
|
|
121
129
|
private findSectionRoot(polynomial: Polynomial, variable: number) {
|
|
@@ -133,104 +141,153 @@ export class Explain {
|
|
|
133
141
|
}
|
|
134
142
|
|
|
135
143
|
private addZeroAssumption(polynomial: Polynomial) {
|
|
136
|
-
const
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
144
|
+
const q = new PolynomialRef(this.pm);
|
|
145
|
+
try {
|
|
146
|
+
this.pm.squareFree(polynomial, q);
|
|
147
|
+
if (this.pm.isConst(q.get())) return;
|
|
148
|
+
const variable = this.pm.maxVar(q.get());
|
|
149
|
+
const index = this.findSectionRoot(q.get(), variable);
|
|
150
|
+
if (index !== null) this.addRootLiteral("ROOT_EQ", variable, index, q.get());
|
|
151
|
+
} finally {
|
|
152
|
+
q.reset();
|
|
153
|
+
}
|
|
141
154
|
}
|
|
142
155
|
|
|
143
|
-
private
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
this.addZeroAssumption(lc);
|
|
161
|
-
return this.pm.zero;
|
|
156
|
+
private addAssumption(kind: IneqKind, polynomial: Polynomial, isNeg = false) {
|
|
157
|
+
const boolVar = this.context.atoms.mkIneqAtom(kind, [polynomial], [false]);
|
|
158
|
+
this.addLiteral(2 * boolVar + (isNeg ? 0 : 1));
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
private elimVanishing(p: PolynomialRef) {
|
|
162
|
+
const pm = this.pm;
|
|
163
|
+
let variable = pm.maxVar(p.get());
|
|
164
|
+
let degree = pm.degree(p.get(), variable);
|
|
165
|
+
const lc = new PolynomialRef(pm);
|
|
166
|
+
const reduct = new PolynomialRef(pm);
|
|
167
|
+
try {
|
|
168
|
+
while (true) {
|
|
169
|
+
if (pm.isConst(p.get())) return;
|
|
170
|
+
if (degree === 0) {
|
|
171
|
+
variable = pm.maxVar(p.get());
|
|
172
|
+
degree = pm.degree(p.get(), variable);
|
|
162
173
|
}
|
|
163
|
-
|
|
164
|
-
|
|
174
|
+
if (pm.isNonzeroConstCoeff(p.get(), variable, degree)) return;
|
|
175
|
+
lc.set(pm.coeffWithReduct(p.get(), variable, degree, reduct));
|
|
176
|
+
this.insertFreshFactorsInTodo(lc);
|
|
177
|
+
if (!pm.isZero(lc.get()) && this.getSign(lc.get()) !== 0) return;
|
|
178
|
+
if (degree === 0) {
|
|
179
|
+
p.set(pm.zero);
|
|
180
|
+
if (this.isAddAllCoeffs) {
|
|
181
|
+
this.addZeroAssumption(lc.get());
|
|
182
|
+
return;
|
|
183
|
+
}
|
|
184
|
+
this.isAddAllCoeffs = true;
|
|
185
|
+
throw new AddAllCoeffsRestart();
|
|
186
|
+
}
|
|
187
|
+
this.addZeroAssumption(lc.get());
|
|
188
|
+
degree--;
|
|
189
|
+
p.copy(reduct);
|
|
165
190
|
}
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
191
|
+
} finally {
|
|
192
|
+
reduct.reset();
|
|
193
|
+
lc.reset();
|
|
169
194
|
}
|
|
170
195
|
}
|
|
171
196
|
|
|
172
|
-
private elimVanishingAll(
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
197
|
+
private elimVanishingAll(ps: PolynomialRefVector) {
|
|
198
|
+
const size = ps.size;
|
|
199
|
+
const p = new PolynomialRef(this.pm);
|
|
200
|
+
try {
|
|
201
|
+
let kept = 0;
|
|
202
|
+
for (let index = 0; index < size; index++) {
|
|
203
|
+
p.set(ps.get(index));
|
|
204
|
+
this.elimVanishing(p);
|
|
205
|
+
if (!this.pm.isConst(p.get())) ps.set(kept++, p.get());
|
|
206
|
+
}
|
|
207
|
+
ps.shrink(kept);
|
|
208
|
+
} finally {
|
|
209
|
+
p.reset();
|
|
210
|
+
}
|
|
176
211
|
}
|
|
177
212
|
|
|
178
|
-
private insertFreshFactorsInTodo(
|
|
179
|
-
if (this.pm.isConst(
|
|
180
|
-
|
|
181
|
-
if (this.pm.isConst(p)) return
|
|
213
|
+
private insertFreshFactorsInTodo(p: PolynomialRef) {
|
|
214
|
+
if (this.pm.isConst(p.get())) return;
|
|
215
|
+
this.elimVanishing(p);
|
|
216
|
+
if (this.pm.isConst(p.get())) return;
|
|
182
217
|
if (!this.isFactoring) {
|
|
183
|
-
this.todo.insert(p);
|
|
184
|
-
return
|
|
218
|
+
this.todo.insert(p.get());
|
|
219
|
+
return;
|
|
185
220
|
}
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
221
|
+
const saved = this.factorsSave.size;
|
|
222
|
+
this.factorsSave.append(this.factors);
|
|
223
|
+
const f = new PolynomialRef(this.pm);
|
|
224
|
+
try {
|
|
225
|
+
this.cache.factor(p.get(), this.factors);
|
|
226
|
+
for (let index = 0; index < this.factors.size; index++) {
|
|
227
|
+
f.set(this.factors.get(index));
|
|
228
|
+
this.elimVanishing(f);
|
|
229
|
+
if (!this.pm.isConst(f.get())) this.todo.insert(f.get());
|
|
230
|
+
}
|
|
231
|
+
} finally {
|
|
232
|
+
f.reset();
|
|
233
|
+
this.factors.reset();
|
|
234
|
+
for (let index = saved; index < this.factorsSave.size; index++)
|
|
235
|
+
this.factors.push(this.factorsSave.get(index));
|
|
236
|
+
this.factorsSave.shrink(saved);
|
|
189
237
|
}
|
|
190
|
-
return p;
|
|
191
238
|
}
|
|
192
239
|
|
|
193
240
|
private normalizeLiteral(literal: number, max: number) {
|
|
194
241
|
if (literal >> 1 === TRUE_BOOL_VAR) return literal;
|
|
195
242
|
const atom = this.getAtom(literal);
|
|
196
243
|
if (!isIneqAtom(atom)) return literal;
|
|
244
|
+
const pm = this.pm;
|
|
197
245
|
const isNeg = (literal & 1) === 1;
|
|
198
|
-
const
|
|
246
|
+
const ps = new PolynomialRefVector(pm);
|
|
199
247
|
const isEven: boolean[] = [];
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
if (
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
248
|
+
const p = new PolynomialRef(pm);
|
|
249
|
+
try {
|
|
250
|
+
let atomSign = 1;
|
|
251
|
+
let isNormalized = false;
|
|
252
|
+
for (let index = 0; index < atom.polynomials.length; index++) {
|
|
253
|
+
p.set(atom.polynomials[index]);
|
|
254
|
+
if (pm.maxVar(p.get()) === max) this.elimVanishing(p);
|
|
255
|
+
if (pm.isConst(p.get()) || pm.maxVar(p.get()) < max) {
|
|
256
|
+
const sign = this.getSign(p.get());
|
|
257
|
+
if (!pm.isConst(p.get())) {
|
|
258
|
+
this.lowerStagePolys.push(p.get());
|
|
259
|
+
if (sign === 0) this.addAssumption("EQ", p.get());
|
|
260
|
+
else if (atom.isEven[index]) this.addAssumption("EQ", p.get(), true);
|
|
261
|
+
else this.addAssumption(getKindForSign(sign), p.get());
|
|
262
|
+
}
|
|
263
|
+
if (sign === 0) return (atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
|
|
264
|
+
if (sign < 0 && !atom.isEven[index]) atomSign = -atomSign;
|
|
265
|
+
isNormalized = true;
|
|
266
|
+
continue;
|
|
211
267
|
}
|
|
212
|
-
if (
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
continue;
|
|
268
|
+
if (p.get() !== atom.polynomials[index]) isNormalized = true;
|
|
269
|
+
isEven.push(atom.isEven[index]);
|
|
270
|
+
ps.push(p.get());
|
|
216
271
|
}
|
|
217
|
-
if (
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
272
|
+
if (ps.size === 0) {
|
|
273
|
+
const isTrue =
|
|
274
|
+
atom.kind === "EQ" ? false : atom.kind === "LT" ? atomSign < 0 : atomSign > 0;
|
|
275
|
+
return isTrue !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
|
|
276
|
+
}
|
|
277
|
+
if (!isNormalized) return literal;
|
|
278
|
+
const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
|
|
279
|
+
return this.context.atoms.mkIneqLiteral(kind, ps.items, isEven) ^ (isNeg ? 1 : 0);
|
|
280
|
+
} finally {
|
|
281
|
+
p.reset();
|
|
282
|
+
ps.reset();
|
|
224
283
|
}
|
|
225
|
-
if (!isNormalized) return literal;
|
|
226
|
-
const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
|
|
227
|
-
return this.context.atoms.mkIneqLiteral(kind, polynomials, isEven) ^ (isNeg ? 1 : 0);
|
|
228
284
|
}
|
|
229
285
|
|
|
230
286
|
private normalizeCore(core: ScopedLiterals, max: number) {
|
|
287
|
+
const size = core.size;
|
|
231
288
|
let kept = 0;
|
|
232
|
-
for (
|
|
233
|
-
const normalized = this.normalizeLiteral(
|
|
289
|
+
for (let index = 0; index < size; index++) {
|
|
290
|
+
const normalized = this.normalizeLiteral(core.literals[index], max);
|
|
234
291
|
if (normalized === TRUE_LITERAL) continue;
|
|
235
292
|
if (normalized === FALSE_LITERAL) {
|
|
236
293
|
core.reset();
|
|
@@ -247,81 +304,93 @@ export class Explain {
|
|
|
247
304
|
newLiteral.set(literal);
|
|
248
305
|
return;
|
|
249
306
|
}
|
|
307
|
+
const pm = this.pm;
|
|
250
308
|
const isNeg = (literal & 1) === 1;
|
|
251
|
-
const factors: Polynomial[] = [];
|
|
252
|
-
const isEven: boolean[] = [];
|
|
253
309
|
let atomSign = 1;
|
|
254
310
|
let isModified = false;
|
|
311
|
+
const newFactors = new PolynomialRefVector(pm);
|
|
312
|
+
const newFactorsEven: boolean[] = [];
|
|
313
|
+
const newFactor = new PolynomialRef(pm);
|
|
255
314
|
const addLcCondition = (steps: number, isFactorEven: boolean) => {
|
|
256
315
|
if (info.isLcConst) return;
|
|
257
316
|
if (steps % 2 === 0 || isFactorEven || atom.kind === "EQ") addLcDiseq(info);
|
|
258
317
|
else addLcIneq(info);
|
|
259
318
|
};
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
319
|
+
try {
|
|
320
|
+
for (let index = 0; index < atom.polynomials.length; index++) {
|
|
321
|
+
const factor = atom.polynomials[index];
|
|
322
|
+
const isFactorEven = atom.isEven[index];
|
|
323
|
+
if (pm.degree(factor, info.variable) < info.degree) {
|
|
324
|
+
newFactors.push(factor);
|
|
325
|
+
newFactorsEven.push(isFactorEven);
|
|
326
|
+
continue;
|
|
327
|
+
}
|
|
328
|
+
isModified = true;
|
|
329
|
+
const steps = pm.pseudoRemainder(factor, info.eq, info.variable, newFactor);
|
|
330
|
+
if (steps % 2 === 1 && !isFactorEven && info.lcSign < 0) atomSign = -atomSign;
|
|
331
|
+
if (pm.isConst(newFactor.get())) {
|
|
332
|
+
const sign = this.getSign(newFactor.get());
|
|
333
|
+
if (sign === 0) {
|
|
334
|
+
newLiteral.set((atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL);
|
|
335
|
+
if (!info.isLcConst) addLcDiseq(info);
|
|
336
|
+
return;
|
|
337
|
+
}
|
|
338
|
+
addLcCondition(steps, isFactorEven);
|
|
339
|
+
if (sign < 0 && !isFactorEven) atomSign = -atomSign;
|
|
340
|
+
continue;
|
|
341
|
+
}
|
|
342
|
+
newFactors.push(newFactor.get());
|
|
343
|
+
newFactorsEven.push(isFactorEven);
|
|
344
|
+
addLcCondition(steps, isFactorEven);
|
|
266
345
|
}
|
|
267
|
-
isModified
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
const remainder = division.remainder;
|
|
271
|
-
if (!this.pm.isConst(remainder)) {
|
|
272
|
-
factors.push(remainder);
|
|
273
|
-
isEven.push(isFactorEven);
|
|
274
|
-
addLcCondition(division.steps, isFactorEven);
|
|
275
|
-
continue;
|
|
346
|
+
if (!isModified) {
|
|
347
|
+
newLiteral.set(literal);
|
|
348
|
+
return;
|
|
276
349
|
}
|
|
277
|
-
const
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
350
|
+
const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
|
|
351
|
+
newLiteral.set(
|
|
352
|
+
this.context.atoms.mkIneqLiteral(kind, newFactors.items, newFactorsEven) ^ (isNeg ? 1 : 0),
|
|
353
|
+
);
|
|
354
|
+
// Z3's null_var is the largest unsigned, so true and false never count as lower stage.
|
|
355
|
+
const maxVar = this.context.atoms.getMaxVar(newLiteral.literal);
|
|
356
|
+
if (maxVar === NULL_VAR || maxVar >= max) {
|
|
357
|
+
newLiteral.set(this.normalizeLiteral(newLiteral.literal, max));
|
|
281
358
|
return;
|
|
282
359
|
}
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
newLiteral.
|
|
288
|
-
|
|
289
|
-
}
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
// Z3's null_var is the largest unsigned, so true and false never count as lower stage.
|
|
293
|
-
const maxVar = this.context.atoms.getMaxVar(newLiteral.literal);
|
|
294
|
-
if (maxVar === NULL_VAR || maxVar >= max) {
|
|
295
|
-
newLiteral.set(this.normalizeLiteral(newLiteral.literal, max));
|
|
296
|
-
return;
|
|
297
|
-
}
|
|
298
|
-
if (this.context.getValue(newLiteral.literal) === 1) {
|
|
299
|
-
newLiteral.set(literal);
|
|
300
|
-
return;
|
|
360
|
+
if (this.context.getValue(newLiteral.literal) === 1) {
|
|
361
|
+
newLiteral.set(literal);
|
|
362
|
+
return;
|
|
363
|
+
}
|
|
364
|
+
this.addLiteral(newLiteral.literal);
|
|
365
|
+
newLiteral.set(TRUE_LITERAL);
|
|
366
|
+
} finally {
|
|
367
|
+
newFactor.reset();
|
|
368
|
+
newFactors.reset();
|
|
301
369
|
}
|
|
302
|
-
this.addLiteral(newLiteral.literal);
|
|
303
|
-
newLiteral.set(TRUE_LITERAL);
|
|
304
370
|
}
|
|
305
371
|
|
|
306
372
|
private simplifyWithEq(core: ScopedLiterals, eq: Polynomial, max: number) {
|
|
307
373
|
const variable = this.pm.maxVar(eq);
|
|
308
374
|
const degree = this.pm.degree(eq, variable);
|
|
309
|
-
const
|
|
310
|
-
const info = {
|
|
311
|
-
eq,
|
|
312
|
-
variable,
|
|
313
|
-
degree,
|
|
314
|
-
lc,
|
|
315
|
-
lcSign: this.getSign(lc),
|
|
316
|
-
isLcConst: this.pm.isConst(lc),
|
|
317
|
-
isLcAdded: false,
|
|
318
|
-
isLcIneqAdded: false,
|
|
319
|
-
};
|
|
375
|
+
const lcEq = new PolynomialRef(this.pm);
|
|
320
376
|
const newLiteral = new ScopedLiteral(this.context.atoms);
|
|
321
377
|
try {
|
|
378
|
+
lcEq.set(this.pm.coeff(eq, variable, degree));
|
|
379
|
+
const info = {
|
|
380
|
+
eq,
|
|
381
|
+
variable,
|
|
382
|
+
degree,
|
|
383
|
+
lc: lcEq.get(),
|
|
384
|
+
lcSign: this.getSign(lcEq.get()),
|
|
385
|
+
isLcConst: this.pm.isConst(lcEq.get()),
|
|
386
|
+
isLcAdded: false,
|
|
387
|
+
isLcIneqAdded: false,
|
|
388
|
+
};
|
|
389
|
+
const size = core.size;
|
|
322
390
|
let isModified = false;
|
|
323
391
|
let kept = 0;
|
|
324
|
-
for (
|
|
392
|
+
for (let index = 0; index < size; index++) {
|
|
393
|
+
const literal = core.literals[index];
|
|
325
394
|
newLiteral.set(TRUE_LITERAL);
|
|
326
395
|
this.simplifyLiteral(literal, info, max, newLiteral);
|
|
327
396
|
if (newLiteral.literal === literal) {
|
|
@@ -344,6 +413,7 @@ export class Explain {
|
|
|
344
413
|
return isModified;
|
|
345
414
|
} finally {
|
|
346
415
|
newLiteral.set(TRUE_LITERAL);
|
|
416
|
+
lcEq.reset();
|
|
347
417
|
}
|
|
348
418
|
}
|
|
349
419
|
|
|
@@ -370,8 +440,7 @@ export class Explain {
|
|
|
370
440
|
const atom = this.getAtom(literal);
|
|
371
441
|
if (!isIneqAtom(atom)) continue;
|
|
372
442
|
for (const factor of atom.polynomials) {
|
|
373
|
-
const
|
|
374
|
-
for (const variable of variables) {
|
|
443
|
+
for (const variable of this.pm.getVars(factor)) {
|
|
375
444
|
if (variable >= max) continue;
|
|
376
445
|
const eq = this.context.var2eq[variable] ?? null;
|
|
377
446
|
if (eq === null) continue;
|
|
@@ -399,122 +468,210 @@ export class Explain {
|
|
|
399
468
|
}
|
|
400
469
|
|
|
401
470
|
private addRootLiteral(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
471
|
+
const pr = new PolynomialRef(this.pm);
|
|
472
|
+
pr.set(polynomial);
|
|
473
|
+
try {
|
|
474
|
+
if (
|
|
475
|
+
this.mkLinearRoot(kind, variable, polynomial) ||
|
|
476
|
+
this.mkQuadraticRoot(kind, variable, index, polynomial)
|
|
477
|
+
)
|
|
478
|
+
return;
|
|
479
|
+
const boolVar = this.context.atoms.mkRootAtom(kind, variable, index, polynomial);
|
|
480
|
+
this.addLiteral(2 * boolVar + 1);
|
|
481
|
+
} finally {
|
|
482
|
+
pr.reset();
|
|
483
|
+
}
|
|
406
484
|
}
|
|
407
485
|
|
|
408
486
|
private mkLinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
|
|
487
|
+
if (this.pm.degree(polynomial, variable) !== 1) return false;
|
|
409
488
|
const coeff = this.pm.getConstCoeff(polynomial, variable, 1);
|
|
410
|
-
if (
|
|
489
|
+
if (coeff === null) return false;
|
|
411
490
|
this.addLinearRoot(kind, polynomial, coeff < 0n);
|
|
412
491
|
return true;
|
|
413
492
|
}
|
|
414
493
|
|
|
415
|
-
private addLinearRoot(kind: RootKind, polynomial: Polynomial, isNegated: boolean) {
|
|
416
|
-
const ineq = ROOT_TO_INEQ[kind];
|
|
417
|
-
this.addAssumption(ineq.kind, isNegated ? this.pm.neg(polynomial) : polynomial, ineq.isNeg);
|
|
418
|
-
}
|
|
419
|
-
|
|
420
494
|
private mkPlinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
|
|
421
495
|
if (this.pm.degree(polynomial, variable) !== 1) return false;
|
|
422
|
-
const
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
496
|
+
const c = new PolynomialRef(this.pm);
|
|
497
|
+
try {
|
|
498
|
+
c.set(this.pm.coeff(polynomial, variable, 1));
|
|
499
|
+
const sign = this.getSign(c.get());
|
|
500
|
+
if (sign === 0) return false;
|
|
501
|
+
this.ensureSign(c);
|
|
502
|
+
this.addLinearRoot(kind, polynomial, sign < 0);
|
|
503
|
+
return true;
|
|
504
|
+
} finally {
|
|
505
|
+
c.reset();
|
|
506
|
+
}
|
|
428
507
|
}
|
|
429
508
|
|
|
430
509
|
private mkQuadraticRoot(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
const
|
|
435
|
-
const
|
|
436
|
-
const
|
|
437
|
-
const
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
510
|
+
const pm = this.pm;
|
|
511
|
+
if (pm.degree(polynomial, variable) !== 2) return false;
|
|
512
|
+
if (index !== 1 && index !== 2) return false;
|
|
513
|
+
const a = new PolynomialRef(pm);
|
|
514
|
+
const b = new PolynomialRef(pm);
|
|
515
|
+
const c = new PolynomialRef(pm);
|
|
516
|
+
const q = new PolynomialRef(pm);
|
|
517
|
+
const pDiff = new PolynomialRef(pm);
|
|
518
|
+
const yy = new PolynomialRef(pm);
|
|
519
|
+
const pr = new PolynomialRef(pm);
|
|
520
|
+
const first = new PolynomialRef(pm);
|
|
521
|
+
const second = new PolynomialRef(pm);
|
|
522
|
+
const third = new PolynomialRef(pm);
|
|
523
|
+
try {
|
|
524
|
+
a.set(pm.coeff(polynomial, variable, 2));
|
|
525
|
+
b.set(pm.coeff(polynomial, variable, 1));
|
|
526
|
+
c.set(pm.coeff(polynomial, variable, 0));
|
|
527
|
+
first.set(pm.mul(b.get(), b.get()));
|
|
528
|
+
second.set(pm.mulConst(4n, a.get()));
|
|
529
|
+
third.set(pm.mul(second.get(), c.get()));
|
|
530
|
+
q.set(pm.sub(first.get(), third.get()));
|
|
531
|
+
third.reset();
|
|
532
|
+
second.reset();
|
|
533
|
+
first.reset();
|
|
534
|
+
yy.set(pm.mkVar(variable));
|
|
535
|
+
first.set(pm.mulConst(2n, a.get()));
|
|
536
|
+
second.set(pm.mul(first.get(), yy.get()));
|
|
537
|
+
pDiff.set(pm.add(second.get(), b.get()));
|
|
538
|
+
second.reset();
|
|
539
|
+
first.reset();
|
|
540
|
+
pDiff.set(pm.normalize(pDiff.get()));
|
|
541
|
+
const discriminantSign = this.ensureSignQuad(q);
|
|
542
|
+
if (discriminantSign < 0) return false;
|
|
543
|
+
if (this.ensureSignQuad(a) === 0) {
|
|
544
|
+
first.set(pm.mul(b.get(), yy.get()));
|
|
545
|
+
q.set(pm.add(first.get(), c.get()));
|
|
546
|
+
first.reset();
|
|
547
|
+
return this.mkPlinearRoot(kind, variable, q.get());
|
|
548
|
+
}
|
|
549
|
+
this.ensureSign(pDiff);
|
|
550
|
+
if (discriminantSign > 0) {
|
|
551
|
+
pr.set(polynomial);
|
|
552
|
+
this.ensureSign(pr);
|
|
553
|
+
}
|
|
554
|
+
return true;
|
|
555
|
+
} finally {
|
|
556
|
+
third.reset();
|
|
557
|
+
second.reset();
|
|
558
|
+
first.reset();
|
|
559
|
+
pr.reset();
|
|
560
|
+
yy.reset();
|
|
561
|
+
pDiff.reset();
|
|
562
|
+
q.reset();
|
|
563
|
+
c.reset();
|
|
564
|
+
b.reset();
|
|
565
|
+
a.reset();
|
|
566
|
+
}
|
|
444
567
|
}
|
|
445
568
|
|
|
446
|
-
private ensureSign(
|
|
447
|
-
if (this.pm.isConst(
|
|
448
|
-
this.addAssumption(getKindForSign(this.getSign(
|
|
449
|
-
this.insertFreshFactorsInTodo(
|
|
569
|
+
private ensureSign(p: PolynomialRef) {
|
|
570
|
+
if (this.pm.isConst(p.get())) return;
|
|
571
|
+
this.addAssumption(getKindForSign(this.getSign(p.get())), p.get());
|
|
572
|
+
this.insertFreshFactorsInTodo(p);
|
|
450
573
|
}
|
|
451
574
|
|
|
452
|
-
private ensureSignQuad(
|
|
453
|
-
const sign = this.getSign(
|
|
454
|
-
if (!this.pm.isConst(
|
|
455
|
-
this.addAssumption(getKindForSign(sign),
|
|
456
|
-
this.insertFreshFactorsInTodo(
|
|
575
|
+
private ensureSignQuad(p: PolynomialRef) {
|
|
576
|
+
const sign = this.getSign(p.get());
|
|
577
|
+
if (!this.pm.isConst(p.get())) {
|
|
578
|
+
this.addAssumption(getKindForSign(sign), p.get());
|
|
579
|
+
this.insertFreshFactorsInTodo(p);
|
|
457
580
|
}
|
|
458
581
|
return sign;
|
|
459
582
|
}
|
|
460
583
|
|
|
461
|
-
private
|
|
462
|
-
const
|
|
584
|
+
private addLinearRoot(kind: RootKind, polynomial: Polynomial, isNegated: boolean) {
|
|
585
|
+
const pPrime = new PolynomialRef(this.pm);
|
|
586
|
+
pPrime.set(polynomial);
|
|
587
|
+
if (isNegated) pPrime.set(this.pm.neg(pPrime.get()));
|
|
588
|
+
const ineq = ROOT_TO_INEQ[kind];
|
|
589
|
+
this.addAssumption(ineq.kind, pPrime.get(), ineq.isNeg);
|
|
590
|
+
pPrime.reset();
|
|
591
|
+
}
|
|
592
|
+
|
|
593
|
+
private levelwiseSingleCell(ps: PolynomialRefVector, maxVar: number, isLinear: boolean) {
|
|
594
|
+
this.lastLwsInputPolys.reset();
|
|
595
|
+
for (let index = 0; index < ps.size; index++) this.lastLwsInputPolys.push(ps.get(index));
|
|
596
|
+
const levelwise = new Levelwise(
|
|
463
597
|
this.pm,
|
|
464
598
|
this.am,
|
|
465
599
|
this.cache,
|
|
466
|
-
|
|
600
|
+
ps,
|
|
467
601
|
maxVar,
|
|
468
602
|
this.context.sample,
|
|
469
603
|
isLinear,
|
|
470
604
|
);
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
605
|
+
let cell: CellInterval[] = [];
|
|
606
|
+
try {
|
|
607
|
+
cell = levelwise.singleCell();
|
|
608
|
+
const isFull = this.isFullDimensional;
|
|
609
|
+
for (const interval of cell) {
|
|
610
|
+
if (interval.isSection) {
|
|
611
|
+
const lower = interval.lower.get();
|
|
612
|
+
this.addRootLiteral("ROOT_EQ", this.pm.maxVar(lower), interval.lowerIndex, lower);
|
|
613
|
+
continue;
|
|
614
|
+
}
|
|
615
|
+
const lower = interval.lower.getOrNull();
|
|
616
|
+
const upper = interval.upper.getOrNull();
|
|
617
|
+
if (lower !== null)
|
|
618
|
+
this.addRootLiteral(
|
|
619
|
+
isFull ? "ROOT_GE" : "ROOT_GT",
|
|
620
|
+
this.pm.maxVar(lower),
|
|
621
|
+
interval.lowerIndex,
|
|
622
|
+
lower,
|
|
623
|
+
);
|
|
624
|
+
if (upper !== null)
|
|
625
|
+
this.addRootLiteral(
|
|
626
|
+
isFull ? "ROOT_LE" : "ROOT_LT",
|
|
627
|
+
this.pm.maxVar(upper),
|
|
628
|
+
interval.upperIndex,
|
|
629
|
+
upper,
|
|
630
|
+
);
|
|
477
631
|
}
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
this.pm.maxVar(interval.lower),
|
|
482
|
-
interval.lowerIndex,
|
|
483
|
-
interval.lower,
|
|
484
|
-
);
|
|
485
|
-
if (interval.upper !== null)
|
|
486
|
-
this.addRootLiteral(
|
|
487
|
-
isFull ? "ROOT_LE" : "ROOT_LT",
|
|
488
|
-
this.pm.maxVar(interval.upper),
|
|
489
|
-
interval.upperIndex,
|
|
490
|
-
interval.upper,
|
|
491
|
-
);
|
|
632
|
+
} finally {
|
|
633
|
+
releaseIntervals(cell);
|
|
634
|
+
levelwise.release();
|
|
492
635
|
}
|
|
493
636
|
}
|
|
494
637
|
|
|
495
|
-
private project(
|
|
496
|
-
if (
|
|
638
|
+
private project(ps: PolynomialRefVector, maxVar: number) {
|
|
639
|
+
if (ps.size === 0) return;
|
|
497
640
|
this.todo.reset();
|
|
498
|
-
|
|
499
|
-
|
|
641
|
+
const p = new PolynomialRef(this.pm);
|
|
642
|
+
try {
|
|
643
|
+
for (let index = 0; index < ps.size; index++) {
|
|
644
|
+
p.set(ps.get(index));
|
|
645
|
+
this.insertFreshFactorsInTodo(p);
|
|
646
|
+
p.reset();
|
|
647
|
+
}
|
|
648
|
+
} finally {
|
|
649
|
+
p.reset();
|
|
650
|
+
}
|
|
651
|
+
ps.reset();
|
|
652
|
+
for (const polynomial of this.todo.set.items) ps.push(polynomial);
|
|
653
|
+
this.levelwiseSingleCell(ps, maxVar, false);
|
|
500
654
|
}
|
|
501
655
|
|
|
502
|
-
private
|
|
656
|
+
private main(literals: readonly number[]) {
|
|
503
657
|
if (literals.length === 0) return;
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
658
|
+
this.collectPolys(literals, this.ps);
|
|
659
|
+
for (let index = 0; index < this.lowerStagePolys.size; index++)
|
|
660
|
+
this.ps.push(this.lowerStagePolys.get(index));
|
|
661
|
+
const maxVar = this.pm.getMaxVarOfPolys(this.ps.items);
|
|
662
|
+
this.elimVanishingAll(this.ps);
|
|
663
|
+
this.project(this.ps, maxVar);
|
|
507
664
|
}
|
|
508
665
|
|
|
509
666
|
private process(literals: readonly number[]) {
|
|
510
|
-
this.lowerStagePolys
|
|
667
|
+
this.lowerStagePolys.reset();
|
|
511
668
|
const core = this.core;
|
|
512
669
|
core.reset();
|
|
513
670
|
for (const literal of literals) core.push(literal);
|
|
514
671
|
const max = this.context.atoms.getMaxVarOfLiterals(literals);
|
|
515
672
|
this.normalizeCore(core, max);
|
|
516
673
|
this.simplifyCore(core, max);
|
|
517
|
-
this.
|
|
674
|
+
this.main(core.literals);
|
|
518
675
|
core.reset();
|
|
519
676
|
}
|
|
520
677
|
|
|
@@ -563,9 +720,9 @@ export class Explain {
|
|
|
563
720
|
if (isContaining) kept.push(literal);
|
|
564
721
|
else this.addLiteral(literal ^ 1);
|
|
565
722
|
}
|
|
566
|
-
|
|
567
|
-
if (
|
|
568
|
-
const maxVar = this.pm.getMaxVarOfPolys(
|
|
723
|
+
this.collectPolys(kept, this.ps);
|
|
724
|
+
if (this.ps.size > 0) {
|
|
725
|
+
const maxVar = this.pm.getMaxVarOfPolys(this.ps.items);
|
|
569
726
|
if (maxVar !== variable) {
|
|
570
727
|
const renaming = Array.from({ length: this.context.getNumVars() }, (_value, index) =>
|
|
571
728
|
index === variable ? maxVar : index === maxVar ? variable : index,
|
|
@@ -573,7 +730,8 @@ export class Explain {
|
|
|
573
730
|
this.context.reorder(renaming);
|
|
574
731
|
isReordered = true;
|
|
575
732
|
}
|
|
576
|
-
this.
|
|
733
|
+
this.elimVanishingAll(this.ps);
|
|
734
|
+
this.project(this.ps, maxVar);
|
|
577
735
|
this.resetResult();
|
|
578
736
|
if (isReordered) this.context.restoreOrder();
|
|
579
737
|
}
|
|
@@ -591,11 +749,11 @@ export class Explain {
|
|
|
591
749
|
|
|
592
750
|
computeLinearExplanation(literals: readonly number[], result: ScopedLiterals) {
|
|
593
751
|
this.result = result;
|
|
594
|
-
this.lowerStagePolys = [];
|
|
595
|
-
const polynomials = this.collectPolys(literals);
|
|
596
752
|
try {
|
|
597
|
-
|
|
598
|
-
|
|
753
|
+
this.lowerStagePolys.reset();
|
|
754
|
+
this.collectPolys(literals, this.ps);
|
|
755
|
+
if (this.ps.size === 0) return;
|
|
756
|
+
this.levelwiseSingleCell(this.ps, this.pm.getMaxVarOfPolys(this.ps.items) + 1, true);
|
|
599
757
|
} finally {
|
|
600
758
|
this.resetResult();
|
|
601
759
|
}
|