tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576
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 +49 -44
- package/dist/transfer.js +48 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +14 -2
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +116 -64
- package/src/check.ts +516 -280
- 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 +190 -1
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +123 -38
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +370 -99
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +135 -11
- 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 +51 -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/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 +27 -1
- 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/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 +1 -2
- 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 +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- 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 +5 -8
- 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 +1 -2
- 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/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/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 +1 -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/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/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/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/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 +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- 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 +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- 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 +713 -210
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +350 -195
- 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 +11 -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 +1 -0
- 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 +1274 -257
- package/src/runtime.ts +7 -1
- 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 +18 -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 +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +319 -135
- package/src/simulate.ts +235 -182
- package/src/spec-description.ts +8 -6
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +37 -13
- 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 +67 -43
- 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
|
@@ -1,6 +1,3 @@
|
|
|
1
|
-
// Deviation from Z3: ties between polynomials break by creation-order id, where Z3 recycles ids of
|
|
2
|
-
// freed polynomials (id_gen in polynomial.cpp), so a cell bound can be another polynomial with the
|
|
3
|
-
// same root.
|
|
4
1
|
import { NlsatUnsupportedError } from "../../../../errors";
|
|
5
2
|
import { Rational } from "../rational";
|
|
6
3
|
import { type AlgebraicManager, type Anum, mergeSortIndices } from "./algebraic";
|
|
@@ -9,14 +6,26 @@ import {
|
|
|
9
6
|
type Polynomial,
|
|
10
7
|
type PolynomialCache,
|
|
11
8
|
type PolynomialManager,
|
|
9
|
+
PolynomialRef,
|
|
10
|
+
PolynomialRefVector,
|
|
12
11
|
} from "./polynomial";
|
|
13
12
|
|
|
14
|
-
|
|
15
|
-
isSection
|
|
16
|
-
lower:
|
|
17
|
-
lowerIndex
|
|
18
|
-
upper:
|
|
19
|
-
upperIndex
|
|
13
|
+
export class CellInterval {
|
|
14
|
+
isSection = false;
|
|
15
|
+
readonly lower: PolynomialRef;
|
|
16
|
+
lowerIndex = 0;
|
|
17
|
+
readonly upper: PolynomialRef;
|
|
18
|
+
upperIndex = 0;
|
|
19
|
+
|
|
20
|
+
constructor(pm: PolynomialManager) {
|
|
21
|
+
this.lower = new PolynomialRef(pm);
|
|
22
|
+
this.upper = new PolynomialRef(pm);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
release() {
|
|
26
|
+
this.upper.reset();
|
|
27
|
+
this.lower.reset();
|
|
28
|
+
}
|
|
20
29
|
}
|
|
21
30
|
|
|
22
31
|
interface RootFunction {
|
|
@@ -32,98 +41,119 @@ const UNSET = -1;
|
|
|
32
41
|
const BOTH_SIDES = 3;
|
|
33
42
|
const SPANNING_TREE_THRESHOLD = 4;
|
|
34
43
|
|
|
44
|
+
export const releaseIntervals = (intervals: readonly CellInterval[]) => {
|
|
45
|
+
for (let index = intervals.length; index-- > 0;) intervals[index].release();
|
|
46
|
+
};
|
|
47
|
+
|
|
35
48
|
export class TodoSet {
|
|
36
|
-
|
|
37
|
-
private inSet =
|
|
49
|
+
readonly set: PolynomialRefVector;
|
|
50
|
+
private inSet: boolean[] = [];
|
|
38
51
|
|
|
39
52
|
constructor(
|
|
40
|
-
private pm: PolynomialManager,
|
|
41
53
|
private cache: PolynomialCache,
|
|
42
|
-
|
|
54
|
+
private isCanonicalizing: boolean,
|
|
55
|
+
) {
|
|
56
|
+
this.set = new PolynomialRefVector(cache.pm);
|
|
57
|
+
}
|
|
43
58
|
|
|
44
59
|
get isEmpty() {
|
|
45
|
-
return this.
|
|
60
|
+
return this.set.size === 0;
|
|
46
61
|
}
|
|
47
62
|
|
|
48
63
|
reset() {
|
|
49
|
-
this.
|
|
50
|
-
this.
|
|
64
|
+
for (const polynomial of this.set.items) this.inSet[polynomial.id] = false;
|
|
65
|
+
this.set.reset();
|
|
51
66
|
}
|
|
52
67
|
|
|
53
68
|
insert(polynomial: Polynomial) {
|
|
54
|
-
|
|
69
|
+
const pm = this.cache.pm;
|
|
70
|
+
if (this.inSet[polynomial.id] === true) return polynomial;
|
|
55
71
|
if (this.cache.contains(polynomial)) {
|
|
56
|
-
this.inSet
|
|
57
|
-
this.
|
|
72
|
+
this.inSet[polynomial.id] = true;
|
|
73
|
+
this.set.push(polynomial);
|
|
58
74
|
return polynomial;
|
|
59
75
|
}
|
|
60
|
-
const
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
76
|
+
const pinned = new PolynomialRef(pm);
|
|
77
|
+
let p = polynomial;
|
|
78
|
+
if (this.isCanonicalizing) {
|
|
79
|
+
if (!pm.isZero(p) && !pm.isConst(p)) {
|
|
80
|
+
pinned.move(pm.pp(p, pm.maxVar(p)));
|
|
81
|
+
p = pinned.get();
|
|
82
|
+
} else pinned.set(p);
|
|
83
|
+
p = pm.flipSignIfLmNeg(p);
|
|
84
|
+
pinned.set(p);
|
|
85
|
+
}
|
|
86
|
+
p = this.cache.mkUnique(p);
|
|
87
|
+
if (this.inSet[p.id] !== true) {
|
|
88
|
+
this.inSet[p.id] = true;
|
|
89
|
+
this.set.push(p);
|
|
68
90
|
}
|
|
69
|
-
|
|
91
|
+
pinned.reset();
|
|
92
|
+
return p;
|
|
70
93
|
}
|
|
71
94
|
|
|
72
95
|
getMaxVar() {
|
|
73
|
-
return this.pm.getMaxVarOfPolys(this.
|
|
96
|
+
return this.cache.pm.getMaxVarOfPolys(this.set.items);
|
|
74
97
|
}
|
|
75
98
|
|
|
76
|
-
extractMaxPolys(out:
|
|
77
|
-
out.
|
|
99
|
+
extractMaxPolys(out: PolynomialRefVector) {
|
|
100
|
+
out.reset();
|
|
78
101
|
const variable = this.getMaxVar();
|
|
79
102
|
this.extractPolysAtLevel(variable, out);
|
|
80
103
|
return variable;
|
|
81
104
|
}
|
|
82
105
|
|
|
83
|
-
extractPolysAtLevel(variable: number, out:
|
|
84
|
-
const
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
this.
|
|
106
|
+
extractPolysAtLevel(variable: number, out: PolynomialRefVector) {
|
|
107
|
+
const pm = this.cache.pm;
|
|
108
|
+
let kept = 0;
|
|
109
|
+
for (let index = 0; index < this.set.size; index++) {
|
|
110
|
+
const polynomial = this.set.get(index);
|
|
111
|
+
if (pm.maxVar(polynomial) === variable) {
|
|
112
|
+
out.push(polynomial);
|
|
113
|
+
this.inSet[polynomial.id] = false;
|
|
114
|
+
} else this.set.set(kept++, polynomial);
|
|
92
115
|
}
|
|
93
|
-
this.
|
|
116
|
+
this.set.shrink(kept);
|
|
94
117
|
}
|
|
95
118
|
}
|
|
96
119
|
|
|
97
|
-
class Levelwise {
|
|
98
|
-
|
|
99
|
-
private todo: TodoSet;
|
|
120
|
+
export class Levelwise {
|
|
121
|
+
readonly intervals: CellInterval[] = [];
|
|
100
122
|
private level = 0;
|
|
101
|
-
private levelPolys: Polynomial[] = [];
|
|
102
|
-
private witnesses: (Polynomial | null)[] = [];
|
|
103
|
-
private hasRoots: boolean[] = [];
|
|
104
|
-
private rootFunctions: RootFunction[] = [];
|
|
105
|
-
private pairs = new Map<string, [number, number]>();
|
|
106
|
-
private sideMask: number[] = [];
|
|
107
|
-
private isLcOmitted: boolean[] = [];
|
|
108
123
|
private lowerRf = UNSET;
|
|
109
124
|
private upperRf = UNSET;
|
|
125
|
+
private todo: TodoSet;
|
|
126
|
+
private levelPs: PolynomialRefVector;
|
|
127
|
+
private witnesses: PolynomialRef[] = [];
|
|
128
|
+
private polyHasRoots: boolean[] = [];
|
|
129
|
+
private pscTmp: PolynomialRefVector;
|
|
130
|
+
private sideMask: number[] = [];
|
|
131
|
+
private isLcOmitted: boolean[] = [];
|
|
132
|
+
private degInOrderGraph: number[] = [];
|
|
133
|
+
private rootFunctions: RootFunction[] = [];
|
|
134
|
+
private pairs = new Map<string, [number, number]>();
|
|
110
135
|
|
|
111
136
|
constructor(
|
|
112
137
|
private pm: PolynomialManager,
|
|
113
138
|
private am: AlgebraicManager,
|
|
114
139
|
private cache: PolynomialCache,
|
|
115
|
-
private
|
|
140
|
+
private polynomials: PolynomialRefVector,
|
|
116
141
|
private maxVar: number,
|
|
142
|
+
private sample: readonly (Anum | undefined)[],
|
|
117
143
|
private isLinear: boolean,
|
|
118
144
|
) {
|
|
119
|
-
this.todo = new TodoSet(
|
|
120
|
-
this.
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
145
|
+
this.todo = new TodoSet(cache, true);
|
|
146
|
+
this.levelPs = new PolynomialRefVector(pm);
|
|
147
|
+
this.pscTmp = new PolynomialRefVector(pm);
|
|
148
|
+
for (let index = 0; index < maxVar; index++) this.intervals.push(new CellInterval(pm));
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
release() {
|
|
152
|
+
this.pscTmp.reset();
|
|
153
|
+
this.clearWitnesses();
|
|
154
|
+
this.levelPs.reset();
|
|
155
|
+
this.todo.set.reset();
|
|
156
|
+
releaseIntervals(this.intervals);
|
|
127
157
|
}
|
|
128
158
|
|
|
129
159
|
private getSign(polynomial: Polynomial) {
|
|
@@ -134,93 +164,200 @@ class Levelwise {
|
|
|
134
164
|
return this.sample.map((value, index) => (index === variable ? undefined : value));
|
|
135
165
|
}
|
|
136
166
|
|
|
137
|
-
private
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
for (let
|
|
167
|
-
if (
|
|
168
|
-
const
|
|
169
|
-
|
|
170
|
-
if (
|
|
171
|
-
|
|
167
|
+
private clearWitnesses() {
|
|
168
|
+
for (let index = this.witnesses.length; index-- > 0;) this.witnesses[index].reset();
|
|
169
|
+
this.witnesses = [];
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
private handleNullifiedPoly(p: Polynomial) {
|
|
173
|
+
const pm = this.pm;
|
|
174
|
+
const degree = pm.degree(p, this.level);
|
|
175
|
+
for (let power = 0; power <= degree; power++) {
|
|
176
|
+
const coeff = new PolynomialRef(pm);
|
|
177
|
+
coeff.set(pm.coeff(p, this.level, power));
|
|
178
|
+
if (!pm.isZero(coeff.get()) && !pm.isConst(coeff.get())) this.requestFactorized(coeff.get());
|
|
179
|
+
coeff.reset();
|
|
180
|
+
}
|
|
181
|
+
let curPolys = new PolynomialRefVector(pm);
|
|
182
|
+
let curMinVar: number[] = [];
|
|
183
|
+
curPolys.push(p);
|
|
184
|
+
curMinVar.push(0);
|
|
185
|
+
while (curPolys.size > 0) {
|
|
186
|
+
const nextPolys = new PolynomialRefVector(pm);
|
|
187
|
+
const nextMinVar: number[] = [];
|
|
188
|
+
for (let index = 0; index < curPolys.size; index++) {
|
|
189
|
+
const q = new PolynomialRef(pm);
|
|
190
|
+
q.set(curPolys.get(index));
|
|
191
|
+
const maxVar = pm.maxVar(q.get());
|
|
192
|
+
if (maxVar === NULL_VAR) {
|
|
193
|
+
q.reset();
|
|
194
|
+
continue;
|
|
195
|
+
}
|
|
196
|
+
for (let x = curMinVar[index]; x <= maxVar; x++) {
|
|
197
|
+
if (pm.degree(q.get(), x) === 0) continue;
|
|
198
|
+
const dq = new PolynomialRef(pm);
|
|
199
|
+
dq.set(pm.derivative(q.get(), x));
|
|
200
|
+
if (pm.isZero(dq.get()) || pm.isConst(dq.get())) {
|
|
201
|
+
dq.reset();
|
|
202
|
+
continue;
|
|
203
|
+
}
|
|
204
|
+
if (this.getSign(dq.get()) !== 0) {
|
|
205
|
+
this.requestFactorized(dq.get());
|
|
206
|
+
dq.reset();
|
|
207
|
+
q.reset();
|
|
208
|
+
nextPolys.reset();
|
|
209
|
+
curPolys.reset();
|
|
172
210
|
return;
|
|
173
211
|
}
|
|
174
|
-
|
|
212
|
+
nextPolys.push(dq.get());
|
|
213
|
+
nextMinVar.push(x);
|
|
214
|
+
dq.reset();
|
|
175
215
|
}
|
|
216
|
+
q.reset();
|
|
176
217
|
}
|
|
177
|
-
for (
|
|
178
|
-
|
|
218
|
+
for (let index = 0; index < nextPolys.size; index++) {
|
|
219
|
+
const dq = new PolynomialRef(pm);
|
|
220
|
+
dq.set(nextPolys.get(index));
|
|
221
|
+
this.requestFactorized(dq.get());
|
|
222
|
+
dq.reset();
|
|
223
|
+
}
|
|
224
|
+
curPolys.reset();
|
|
225
|
+
curPolys = nextPolys;
|
|
226
|
+
curMinVar = nextMinVar;
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
private resetInterval(interval: CellInterval) {
|
|
231
|
+
interval.isSection = false;
|
|
232
|
+
interval.lower.reset();
|
|
233
|
+
interval.upper.reset();
|
|
234
|
+
interval.lowerIndex = 0;
|
|
235
|
+
interval.upperIndex = 0;
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
private getFirstPsc(chain: PolynomialRefVector) {
|
|
239
|
+
const r = new PolynomialRef(this.pm);
|
|
240
|
+
for (let index = 0; index < chain.size; index++) {
|
|
241
|
+
r.set(chain.get(index));
|
|
242
|
+
if (this.pm.isZero(r.get())) continue;
|
|
243
|
+
if (this.pm.isConst(r.get())) {
|
|
244
|
+
r.reset();
|
|
245
|
+
return r;
|
|
246
|
+
}
|
|
247
|
+
return r;
|
|
179
248
|
}
|
|
249
|
+
r.reset();
|
|
250
|
+
return r;
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
private pscDiscriminant(pIn: Polynomial, x: number) {
|
|
254
|
+
const pm = this.pm;
|
|
255
|
+
if (pm.isZero(pIn) || pm.isConst(pIn) || pm.degree(pIn, x) < 2) return new PolynomialRef(pm);
|
|
256
|
+
const p = new PolynomialRef(pm);
|
|
257
|
+
p.set(pIn);
|
|
258
|
+
const d = new PolynomialRef(pm);
|
|
259
|
+
d.set(pm.derivative(p.get(), x));
|
|
260
|
+
const chain = this.pscTmp;
|
|
261
|
+
chain.reset();
|
|
262
|
+
this.cache.pscChain(p.get(), d.get(), x, chain);
|
|
263
|
+
const disc = this.getFirstPsc(chain);
|
|
264
|
+
d.reset();
|
|
265
|
+
p.reset();
|
|
266
|
+
return disc;
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
private pscResultant(a: Polynomial, b: Polynomial, x: number) {
|
|
270
|
+
const pa = new PolynomialRef(this.pm);
|
|
271
|
+
pa.set(a);
|
|
272
|
+
const pb = new PolynomialRef(this.pm);
|
|
273
|
+
pb.set(b);
|
|
274
|
+
const chain = this.pscTmp;
|
|
275
|
+
chain.reset();
|
|
276
|
+
this.cache.pscChain(pa.get(), pb.get(), x, chain);
|
|
277
|
+
const r = this.getFirstPsc(chain);
|
|
278
|
+
pb.reset();
|
|
279
|
+
pa.reset();
|
|
280
|
+
return r;
|
|
180
281
|
}
|
|
181
282
|
|
|
182
|
-
private
|
|
183
|
-
const
|
|
283
|
+
private requestFactorized(polynomial: Polynomial | null) {
|
|
284
|
+
const pm = this.pm;
|
|
285
|
+
if (polynomial === null || pm.isZero(polynomial) || pm.isConst(polynomial)) return;
|
|
286
|
+
const factors = new PolynomialRefVector(pm);
|
|
287
|
+
this.cache.factor(polynomial, factors);
|
|
288
|
+
for (let index = 0; index < factors.size; index++) {
|
|
289
|
+
const f = new PolynomialRef(pm);
|
|
290
|
+
f.set(factors.get(index));
|
|
291
|
+
if (!pm.isZero(f.get()) && !pm.isConst(f.get())) this.todo.insert(f.get());
|
|
292
|
+
f.reset();
|
|
293
|
+
}
|
|
294
|
+
factors.reset();
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
private chooseNonzeroCoeff(p: Polynomial, x: number) {
|
|
298
|
+
const pm = this.pm;
|
|
299
|
+
const degree = pm.degree(p, x);
|
|
300
|
+
const coeff = new PolynomialRef(pm);
|
|
184
301
|
for (let power = 0; power <= degree; power++) {
|
|
185
|
-
|
|
186
|
-
if (
|
|
302
|
+
coeff.set(pm.coeff(p, x, power));
|
|
303
|
+
if (pm.isZero(coeff.get())) continue;
|
|
304
|
+
if (pm.isConst(coeff.get())) return coeff;
|
|
187
305
|
}
|
|
188
|
-
|
|
306
|
+
const best = new PolynomialRef(pm);
|
|
307
|
+
let bestTotalDegree = 0;
|
|
308
|
+
let bestSize = 0;
|
|
309
|
+
let bestMaxVar = NULL_VAR;
|
|
189
310
|
for (let power = 0; power <= degree; power++) {
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
const
|
|
311
|
+
coeff.set(pm.coeff(p, x, power));
|
|
312
|
+
const current = coeff.get();
|
|
313
|
+
if (pm.isZero(current) || this.getSign(current) === 0) continue;
|
|
314
|
+
const totalDegree = pm.totalDegree(current);
|
|
315
|
+
const size = current.size;
|
|
316
|
+
const maxVar = pm.maxVar(current);
|
|
194
317
|
if (
|
|
195
|
-
best === null ||
|
|
196
|
-
totalDegree <
|
|
197
|
-
(totalDegree ===
|
|
198
|
-
(
|
|
199
|
-
(
|
|
200
|
-
)
|
|
201
|
-
best
|
|
318
|
+
best.getOrNull() === null ||
|
|
319
|
+
totalDegree < bestTotalDegree ||
|
|
320
|
+
(totalDegree === bestTotalDegree &&
|
|
321
|
+
(size < bestSize ||
|
|
322
|
+
(size === bestSize && (bestMaxVar === NULL_VAR || maxVar < bestMaxVar))))
|
|
323
|
+
) {
|
|
324
|
+
best.copy(coeff);
|
|
325
|
+
bestTotalDegree = totalDegree;
|
|
326
|
+
bestSize = size;
|
|
327
|
+
bestMaxVar = maxVar;
|
|
328
|
+
}
|
|
202
329
|
}
|
|
330
|
+
coeff.reset();
|
|
203
331
|
return best;
|
|
204
332
|
}
|
|
205
333
|
|
|
206
334
|
private addProjectionForPoly(
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
335
|
+
p: Polynomial,
|
|
336
|
+
x: number,
|
|
337
|
+
nonzeroCoeff: Polynomial | null,
|
|
210
338
|
isLcAdded: boolean,
|
|
339
|
+
isDiscAdded: boolean,
|
|
211
340
|
) {
|
|
212
|
-
|
|
341
|
+
const pm = this.pm;
|
|
342
|
+
let isNonzeroCoeffAdded = nonzeroCoeff !== null && !pm.isConst(nonzeroCoeff);
|
|
213
343
|
if (isLcAdded) {
|
|
214
|
-
const
|
|
215
|
-
|
|
216
|
-
|
|
344
|
+
const lc = new PolynomialRef(pm);
|
|
345
|
+
lc.set(pm.coeff(p, x, pm.degree(p, x)));
|
|
346
|
+
this.requestFactorized(lc.get());
|
|
347
|
+
if (isNonzeroCoeffAdded && this.getSign(lc.get()) !== 0) isNonzeroCoeffAdded = false;
|
|
348
|
+
lc.reset();
|
|
217
349
|
}
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
this.
|
|
221
|
-
|
|
350
|
+
if (isDiscAdded) {
|
|
351
|
+
const disc = new PolynomialRef(pm);
|
|
352
|
+
disc.move(this.pscDiscriminant(p, x));
|
|
353
|
+
const value = disc.getOrNull();
|
|
354
|
+
if (value !== null) {
|
|
355
|
+
this.requestFactorized(value);
|
|
356
|
+
if (isNonzeroCoeffAdded && this.getSign(value) !== 0) isNonzeroCoeffAdded = false;
|
|
357
|
+
}
|
|
358
|
+
disc.reset();
|
|
222
359
|
}
|
|
223
|
-
if (
|
|
360
|
+
if (isNonzeroCoeffAdded) this.requestFactorized(nonzeroCoeff);
|
|
224
361
|
}
|
|
225
362
|
|
|
226
363
|
private addPair(first: number, second: number) {
|
|
@@ -242,7 +379,7 @@ class Levelwise {
|
|
|
242
379
|
|
|
243
380
|
private computeSideMask() {
|
|
244
381
|
if (this.lowerRf === UNSET) return;
|
|
245
|
-
while (this.sideMask.length < this.
|
|
382
|
+
while (this.sideMask.length < this.levelPs.size) this.sideMask.push(0);
|
|
246
383
|
this.rootFunctions.forEach((rootFunction, index) => {
|
|
247
384
|
this.sideMask[rootFunction.psIndex] |= index <= this.lowerRf ? 1 : 2;
|
|
248
385
|
});
|
|
@@ -252,20 +389,24 @@ class Levelwise {
|
|
|
252
389
|
return rootFunctionIndex === UNSET ? UNSET : this.rootFunctions[rootFunctionIndex].psIndex;
|
|
253
390
|
}
|
|
254
391
|
|
|
392
|
+
private computeResultantGraphDegree() {
|
|
393
|
+
this.degInOrderGraph = Array.from({ length: this.levelPs.size }, () => 0);
|
|
394
|
+
for (const pair of this.pairs.values()) {
|
|
395
|
+
this.degInOrderGraph[pair[0]]++;
|
|
396
|
+
this.degInOrderGraph[pair[1]]++;
|
|
397
|
+
}
|
|
398
|
+
}
|
|
399
|
+
|
|
255
400
|
private computeOmitLcBothSides(isLeafRequired: boolean) {
|
|
256
|
-
this.isLcOmitted = this.
|
|
401
|
+
this.isLcOmitted = Array.from({ length: this.levelPs.size }, () => false);
|
|
257
402
|
if (this.rootFunctions.length === 0 || this.pairs.size === 0 || this.sideMask.length === 0)
|
|
258
403
|
return;
|
|
259
|
-
|
|
260
|
-
for (const pair of this.pairs.values()) {
|
|
261
|
-
degrees[pair[0]]++;
|
|
262
|
-
degrees[pair[1]]++;
|
|
263
|
-
}
|
|
404
|
+
if (isLeafRequired) this.computeResultantGraphDegree();
|
|
264
405
|
const lowerBound = this.getBoundIndex(this.lowerRf);
|
|
265
406
|
const upperBound = this.getBoundIndex(this.upperRf);
|
|
266
|
-
for (let index = 0; index < this.
|
|
407
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
267
408
|
if (this.sideMask[index] !== BOTH_SIDES) continue;
|
|
268
|
-
if (isLeafRequired &&
|
|
409
|
+
if (isLeafRequired && this.degInOrderGraph[index] !== 1) continue;
|
|
269
410
|
if (index === lowerBound || index === upperBound) continue;
|
|
270
411
|
this.isLcOmitted[index] = true;
|
|
271
412
|
}
|
|
@@ -281,26 +422,24 @@ class Levelwise {
|
|
|
281
422
|
}
|
|
282
423
|
|
|
283
424
|
private fillRelationSection() {
|
|
425
|
+
if (this.rootFunctions.length === 0) return;
|
|
284
426
|
for (let index = 0; index < this.lowerRf; index++) this.addPair(index, this.lowerRf);
|
|
285
427
|
for (let index = this.lowerRf + 1; index < this.rootFunctions.length; index++)
|
|
286
428
|
this.addPair(this.lowerRf, index);
|
|
287
429
|
}
|
|
288
430
|
|
|
289
431
|
private buildBothSideSpanningTree() {
|
|
290
|
-
const lowerRfs = this.
|
|
291
|
-
const upperRfs = this.
|
|
432
|
+
const lowerRfs = Array.from({ length: this.levelPs.size }, () => UNSET);
|
|
433
|
+
const upperRfs = Array.from({ length: this.levelPs.size }, () => UNSET);
|
|
292
434
|
for (let index = 0; index <= this.lowerRf; index++)
|
|
293
435
|
lowerRfs[this.rootFunctions[index].psIndex] = index;
|
|
294
436
|
for (let index = this.upperRf; index < this.rootFunctions.length; index++)
|
|
295
437
|
upperRfs[this.rootFunctions[index].psIndex] = index;
|
|
296
|
-
const both =
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
lowerRf: lowerRfs[psIndex],
|
|
300
|
-
|
|
301
|
-
}))
|
|
302
|
-
.filter((info) => this.sideMask[info.psIndex] === BOTH_SIDES)
|
|
303
|
-
.sort((first, second) => first.lowerRf - second.lowerRf);
|
|
438
|
+
const both: { psIndex: number; lowerRf: number; upperRf: number }[] = [];
|
|
439
|
+
for (let psIndex = 0; psIndex < this.levelPs.size; psIndex++)
|
|
440
|
+
if (this.sideMask[psIndex] === BOTH_SIDES)
|
|
441
|
+
both.push({ psIndex, lowerRf: lowerRfs[psIndex], upperRf: upperRfs[psIndex] });
|
|
442
|
+
both.sort((first, second) => first.lowerRf - second.lowerRf);
|
|
304
443
|
for (let first = 0; first < both.length - 1; first++) {
|
|
305
444
|
let closest = first + 1;
|
|
306
445
|
for (let index = first + 2; index < both.length; index++)
|
|
@@ -331,21 +470,21 @@ class Levelwise {
|
|
|
331
470
|
}
|
|
332
471
|
|
|
333
472
|
private isolateRootsAroundSample(
|
|
473
|
+
p: Polynomial,
|
|
334
474
|
psIndex: number,
|
|
335
475
|
value: Anum,
|
|
336
476
|
lower: RootFunction[],
|
|
337
477
|
upper: RootFunction[],
|
|
338
478
|
) {
|
|
339
|
-
const polynomial = this.levelPolys[psIndex];
|
|
340
479
|
const values = this.getValuesWithout(this.level);
|
|
341
480
|
const mkRootFunction = (root: Anum, index: number) => ({
|
|
342
481
|
value: this.am.copy(root),
|
|
343
|
-
polynomial,
|
|
482
|
+
polynomial: p,
|
|
344
483
|
index,
|
|
345
484
|
psIndex,
|
|
346
485
|
});
|
|
347
486
|
if (value.value instanceof Rational) {
|
|
348
|
-
const closest = this.am.isolateRootsClosest(this.pm,
|
|
487
|
+
const closest = this.am.isolateRootsClosest(this.pm, p, values, value.value);
|
|
349
488
|
closest.roots.forEach((root, index) => {
|
|
350
489
|
(this.am.compare(root, value) <= 0 ? lower : upper).push(
|
|
351
490
|
mkRootFunction(root, closest.indices[index]),
|
|
@@ -353,7 +492,7 @@ class Levelwise {
|
|
|
353
492
|
});
|
|
354
493
|
return closest.roots.length > 0;
|
|
355
494
|
}
|
|
356
|
-
const roots = this.am.isolateRoots(this.pm,
|
|
495
|
+
const roots = this.am.isolateRoots(this.pm, p, values);
|
|
357
496
|
let lowerIndex = UNSET;
|
|
358
497
|
let upperIndex = UNSET;
|
|
359
498
|
let isSection = false;
|
|
@@ -400,95 +539,115 @@ class Levelwise {
|
|
|
400
539
|
if (middle === 0) {
|
|
401
540
|
this.lowerRf = UNSET;
|
|
402
541
|
this.upperRf = 0;
|
|
403
|
-
interval.upper
|
|
542
|
+
interval.upper.set(rootFunctions[0].polynomial);
|
|
404
543
|
interval.upperIndex = rootFunctions[0].index;
|
|
405
544
|
return;
|
|
406
545
|
}
|
|
407
546
|
this.lowerRf = middle - 1;
|
|
408
547
|
const lower = rootFunctions[middle - 1];
|
|
409
|
-
interval.lower = lower.polynomial;
|
|
410
|
-
interval.lowerIndex = lower.index;
|
|
411
548
|
if (this.am.compare(lower.value, value) === 0) {
|
|
412
549
|
interval.isSection = true;
|
|
550
|
+
interval.lower.set(lower.polynomial);
|
|
551
|
+
interval.lowerIndex = lower.index;
|
|
413
552
|
this.upperRf = this.lowerRf;
|
|
414
553
|
return;
|
|
415
554
|
}
|
|
555
|
+
interval.lower.set(lower.polynomial);
|
|
556
|
+
interval.lowerIndex = lower.index;
|
|
416
557
|
if (middle < rootFunctions.length) {
|
|
417
558
|
this.upperRf = this.lowerRf + 1;
|
|
418
|
-
interval.upper
|
|
559
|
+
interval.upper.set(rootFunctions[middle].polynomial);
|
|
419
560
|
interval.upperIndex = rootFunctions[middle].index;
|
|
420
561
|
}
|
|
421
562
|
}
|
|
422
563
|
|
|
423
|
-
private addLinearPolyFromRoot(root: Anum, isLower: boolean) {
|
|
424
|
-
const
|
|
425
|
-
const
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
);
|
|
564
|
+
private addLinearPolyFromRoot(root: Anum, isLower: boolean, p: PolynomialRef) {
|
|
565
|
+
const pm = this.pm;
|
|
566
|
+
const value = this.am.toRational(root);
|
|
567
|
+
p.set(pm.mkVar(this.level));
|
|
568
|
+
const scaled = new PolynomialRef(pm);
|
|
569
|
+
scaled.set(pm.mulConst(value.den, p.get()));
|
|
570
|
+
const constant = new PolynomialRef(pm);
|
|
571
|
+
constant.set(pm.mkConst(value.num));
|
|
572
|
+
const difference = new PolynomialRef(pm);
|
|
573
|
+
difference.set(pm.sub(scaled.get(), constant.get()));
|
|
574
|
+
constant.reset();
|
|
575
|
+
p.move(difference);
|
|
576
|
+
scaled.reset();
|
|
429
577
|
const interval = this.intervals[this.level];
|
|
430
578
|
if (isLower) {
|
|
431
|
-
interval.lower
|
|
579
|
+
interval.lower.copy(p);
|
|
432
580
|
interval.lowerIndex = 1;
|
|
433
581
|
} else {
|
|
434
|
-
interval.upper
|
|
582
|
+
interval.upper.copy(p);
|
|
435
583
|
interval.upperIndex = 1;
|
|
436
584
|
}
|
|
437
|
-
this.
|
|
438
|
-
this.
|
|
439
|
-
this.
|
|
440
|
-
|
|
585
|
+
this.levelPs.push(p.get());
|
|
586
|
+
this.polyHasRoots.push(true);
|
|
587
|
+
const witness = this.chooseNonzeroCoeff(p.get(), this.level);
|
|
588
|
+
const copy = new PolynomialRef(pm);
|
|
589
|
+
copy.copy(witness);
|
|
590
|
+
this.witnesses.push(copy);
|
|
591
|
+
witness.reset();
|
|
441
592
|
}
|
|
442
593
|
|
|
443
594
|
private addLinearApproximations(value: Anum) {
|
|
595
|
+
const pLower = new PolynomialRef(this.pm);
|
|
596
|
+
const pUpper = new PolynomialRef(this.pm);
|
|
444
597
|
const interval = this.intervals[this.level];
|
|
445
598
|
const mkRootFunction = (polynomial: Polynomial, root: Anum) => ({
|
|
446
599
|
value: this.am.copy(root),
|
|
447
600
|
polynomial,
|
|
448
601
|
index: 1,
|
|
449
|
-
psIndex: this.
|
|
602
|
+
psIndex: this.levelPs.size - 1,
|
|
450
603
|
});
|
|
451
604
|
if (interval.isSection) {
|
|
452
605
|
if (!this.am.isRational(value))
|
|
453
606
|
throw new NlsatUnsupportedError("a linear cell around an irrational section");
|
|
454
|
-
if (this.pm.totalDegree(interval.lower
|
|
455
|
-
|
|
456
|
-
this.rootFunctions.splice(this.lowerRf, 0, mkRootFunction(
|
|
607
|
+
if (this.pm.totalDegree(interval.lower.get()) > 1) {
|
|
608
|
+
this.addLinearPolyFromRoot(value, true, pLower);
|
|
609
|
+
this.rootFunctions.splice(this.lowerRf, 0, mkRootFunction(pLower.get(), value));
|
|
457
610
|
}
|
|
611
|
+
pUpper.reset();
|
|
612
|
+
pLower.reset();
|
|
458
613
|
return;
|
|
459
614
|
}
|
|
460
|
-
|
|
615
|
+
const lower = interval.lower.getOrNull();
|
|
616
|
+
if (lower !== null && this.pm.totalDegree(lower) > 1) {
|
|
461
617
|
const between = this.am.select(this.rootFunctions[this.lowerRf].value, value);
|
|
462
|
-
|
|
463
|
-
this.rootFunctions.splice(this.lowerRf + 1, 0, mkRootFunction(
|
|
618
|
+
this.addLinearPolyFromRoot(between, true, pLower);
|
|
619
|
+
this.rootFunctions.splice(this.lowerRf + 1, 0, mkRootFunction(pLower.get(), between));
|
|
464
620
|
this.lowerRf++;
|
|
465
621
|
if (this.upperRf !== UNSET) this.upperRf++;
|
|
466
622
|
}
|
|
467
|
-
|
|
623
|
+
const upper = interval.upper.getOrNull();
|
|
624
|
+
if (upper !== null && this.pm.totalDegree(upper) > 1) {
|
|
468
625
|
const between = this.am.select(value, this.rootFunctions[this.upperRf].value);
|
|
469
|
-
|
|
470
|
-
this.rootFunctions.splice(this.upperRf, 0, mkRootFunction(
|
|
626
|
+
this.addLinearPolyFromRoot(between, false, pUpper);
|
|
627
|
+
this.rootFunctions.splice(this.upperRf, 0, mkRootFunction(pUpper.get(), between));
|
|
471
628
|
}
|
|
629
|
+
pUpper.reset();
|
|
630
|
+
pLower.reset();
|
|
472
631
|
}
|
|
473
632
|
|
|
474
633
|
private buildInterval() {
|
|
475
634
|
this.rootFunctions = [];
|
|
476
635
|
this.pairs.clear();
|
|
477
|
-
|
|
478
|
-
isSection: false,
|
|
479
|
-
lower: null,
|
|
480
|
-
lowerIndex: 0,
|
|
481
|
-
upper: null,
|
|
482
|
-
upperIndex: 0,
|
|
483
|
-
});
|
|
636
|
+
this.resetInterval(this.intervals[this.level]);
|
|
484
637
|
this.lowerRf = UNSET;
|
|
485
638
|
this.upperRf = UNSET;
|
|
486
639
|
const value = this.sample[this.level]!;
|
|
640
|
+
this.polyHasRoots = Array.from({ length: this.levelPs.size }, () => false);
|
|
487
641
|
const lower: RootFunction[] = [];
|
|
488
642
|
const upper: RootFunction[] = [];
|
|
489
|
-
|
|
490
|
-
this.isolateRootsAroundSample(
|
|
491
|
-
|
|
643
|
+
for (let index = 0; index < this.levelPs.size; index++)
|
|
644
|
+
this.polyHasRoots[index] = this.isolateRootsAroundSample(
|
|
645
|
+
this.levelPs.get(index),
|
|
646
|
+
index,
|
|
647
|
+
value,
|
|
648
|
+
lower,
|
|
649
|
+
upper,
|
|
650
|
+
);
|
|
492
651
|
if (lower.length === 0 && upper.length === 0) return false;
|
|
493
652
|
this.rootFunctions = [
|
|
494
653
|
...this.sortRootFunctions(lower, true),
|
|
@@ -501,20 +660,27 @@ class Levelwise {
|
|
|
501
660
|
}
|
|
502
661
|
|
|
503
662
|
private addRelationResultants() {
|
|
504
|
-
for (const pair of this.getSortedPairs())
|
|
505
|
-
this.
|
|
506
|
-
this.
|
|
663
|
+
for (const pair of this.getSortedPairs()) {
|
|
664
|
+
const res = this.pscResultant(
|
|
665
|
+
this.levelPs.get(pair[0]),
|
|
666
|
+
this.levelPs.get(pair[1]),
|
|
667
|
+
this.level,
|
|
507
668
|
);
|
|
669
|
+
this.requestFactorized(res.getOrNull());
|
|
670
|
+
res.reset();
|
|
671
|
+
}
|
|
508
672
|
}
|
|
509
673
|
|
|
510
674
|
private addAdjacentRootResultants() {
|
|
675
|
+
this.polyHasRoots = Array.from({ length: this.levelPs.size }, () => false);
|
|
511
676
|
const rootValues: { root: Anum; polynomial: Polynomial }[] = [];
|
|
512
677
|
const values = this.getValuesWithout(this.maxVar);
|
|
513
|
-
|
|
678
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
679
|
+
const polynomial = this.levelPs.get(index);
|
|
514
680
|
const roots = this.am.isolateRoots(this.pm, polynomial, values);
|
|
681
|
+
this.polyHasRoots[index] = roots.length > 0;
|
|
515
682
|
for (const root of roots) rootValues.push({ root: this.am.copy(root), polynomial });
|
|
516
|
-
|
|
517
|
-
});
|
|
683
|
+
}
|
|
518
684
|
if (rootValues.length < 2) return;
|
|
519
685
|
const order = mergeSortIndices(
|
|
520
686
|
rootValues.length,
|
|
@@ -529,32 +695,51 @@ class Levelwise {
|
|
|
529
695
|
const key = `${low.id},${high.id}`;
|
|
530
696
|
if (added.has(key)) continue;
|
|
531
697
|
added.add(key);
|
|
532
|
-
this.
|
|
698
|
+
const res = this.pscResultant(low, high, this.maxVar);
|
|
699
|
+
this.requestFactorized(res.getOrNull());
|
|
700
|
+
res.reset();
|
|
533
701
|
}
|
|
534
702
|
}
|
|
535
703
|
|
|
536
704
|
private addSectionProjections() {
|
|
537
|
-
const sectionPolynomial = this.intervals[this.level].lower;
|
|
705
|
+
const sectionPolynomial = this.intervals[this.level].lower.get();
|
|
538
706
|
const withRoots = new Set(this.rootFunctions.map((rootFunction) => rootFunction.psIndex));
|
|
539
|
-
this.
|
|
540
|
-
const
|
|
541
|
-
|
|
542
|
-
|
|
707
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
708
|
+
const p = new PolynomialRef(this.pm);
|
|
709
|
+
p.set(this.levelPs.get(index));
|
|
710
|
+
const witness = new PolynomialRef(this.pm);
|
|
711
|
+
witness.copy(this.witnesses[index]);
|
|
712
|
+
const isFull = this.levelPs.get(index) === sectionPolynomial || !withRoots.has(index);
|
|
713
|
+
this.addProjectionForPoly(p.get(), this.level, witness.getOrNull(), isFull, true);
|
|
714
|
+
witness.reset();
|
|
715
|
+
p.reset();
|
|
716
|
+
}
|
|
543
717
|
}
|
|
544
718
|
|
|
545
719
|
private addSectorProjections() {
|
|
546
|
-
|
|
720
|
+
const pm = this.pm;
|
|
721
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
722
|
+
const p = new PolynomialRef(pm);
|
|
723
|
+
p.set(this.levelPs.get(index));
|
|
724
|
+
const lc = new PolynomialRef(pm);
|
|
725
|
+
lc.set(pm.coeff(p.get(), this.level, pm.degree(p.get(), this.level)));
|
|
547
726
|
const isLcAdded = !(this.isLcOmitted[index] ?? false);
|
|
548
|
-
|
|
727
|
+
const witness = new PolynomialRef(pm);
|
|
728
|
+
witness.copy(this.witnesses[index]);
|
|
729
|
+
const value = witness.getOrNull();
|
|
549
730
|
if (
|
|
550
731
|
isLcAdded &&
|
|
551
|
-
|
|
552
|
-
!
|
|
553
|
-
|
|
732
|
+
value !== null &&
|
|
733
|
+
!pm.isConst(value) &&
|
|
734
|
+
!pm.isZero(lc.get()) &&
|
|
735
|
+
this.getSign(lc.get()) !== 0
|
|
554
736
|
)
|
|
555
|
-
witness
|
|
556
|
-
this.addProjectionForPoly(
|
|
557
|
-
|
|
737
|
+
witness.reset();
|
|
738
|
+
this.addProjectionForPoly(p.get(), this.level, witness.getOrNull(), isLcAdded, true);
|
|
739
|
+
witness.reset();
|
|
740
|
+
lc.reset();
|
|
741
|
+
p.reset();
|
|
742
|
+
}
|
|
558
743
|
}
|
|
559
744
|
|
|
560
745
|
private shouldUseSpanningTree() {
|
|
@@ -562,12 +747,19 @@ class Levelwise {
|
|
|
562
747
|
if (this.lowerRf === UNSET || this.upperRf === UNSET) return false;
|
|
563
748
|
if (this.getBoundIndex(this.lowerRf) === this.getBoundIndex(this.upperRf)) return false;
|
|
564
749
|
let bothCount = 0;
|
|
565
|
-
for (let index = 0; index < this.
|
|
750
|
+
for (let index = 0; index < this.levelPs.size; index++)
|
|
566
751
|
if (this.sideMask[index] === BOTH_SIDES && ++bothCount >= SPANNING_TREE_THRESHOLD)
|
|
567
752
|
return true;
|
|
568
753
|
return false;
|
|
569
754
|
}
|
|
570
755
|
|
|
756
|
+
private clearLevelState() {
|
|
757
|
+
this.isLcOmitted = [];
|
|
758
|
+
this.pairs.clear();
|
|
759
|
+
this.sideMask = [];
|
|
760
|
+
this.degInOrderGraph = [];
|
|
761
|
+
}
|
|
762
|
+
|
|
571
763
|
private processLevelWithMode(mode: ProjectionMode, hasInterval: boolean) {
|
|
572
764
|
if (hasInterval) {
|
|
573
765
|
if (mode === "section") this.fillRelationSection();
|
|
@@ -584,21 +776,23 @@ class Levelwise {
|
|
|
584
776
|
}
|
|
585
777
|
|
|
586
778
|
private collectNonNullWitnesses() {
|
|
587
|
-
this.
|
|
588
|
-
for (let index = 0; index < this.
|
|
589
|
-
const
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
this.
|
|
593
|
-
|
|
594
|
-
|
|
779
|
+
this.clearWitnesses();
|
|
780
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
781
|
+
const p = new PolynomialRef(this.pm);
|
|
782
|
+
p.set(this.levelPs.get(index));
|
|
783
|
+
const witness = this.chooseNonzeroCoeff(p.get(), this.level);
|
|
784
|
+
if (witness.getOrNull() === null) this.handleNullifiedPoly(p.get());
|
|
785
|
+
const copy = new PolynomialRef(this.pm);
|
|
786
|
+
copy.copy(witness);
|
|
787
|
+
this.witnesses.push(copy);
|
|
788
|
+
if (index + 1 === this.levelPs.size) this.todo.extractPolysAtLevel(this.level, this.levelPs);
|
|
789
|
+
witness.reset();
|
|
790
|
+
p.reset();
|
|
595
791
|
}
|
|
596
792
|
}
|
|
597
793
|
|
|
598
794
|
private processLevel() {
|
|
599
|
-
this.
|
|
600
|
-
this.pairs.clear();
|
|
601
|
-
this.sideMask = [];
|
|
795
|
+
this.clearLevelState();
|
|
602
796
|
this.collectNonNullWitnesses();
|
|
603
797
|
const hasInterval = this.buildInterval();
|
|
604
798
|
this.processLevelWithMode(
|
|
@@ -612,39 +806,65 @@ class Levelwise {
|
|
|
612
806
|
}
|
|
613
807
|
|
|
614
808
|
private processTopLevel() {
|
|
809
|
+
const pm = this.pm;
|
|
615
810
|
this.collectNonNullWitnesses();
|
|
616
811
|
this.addAdjacentRootResultants();
|
|
617
|
-
this.
|
|
618
|
-
const
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
812
|
+
for (let index = 0; index < this.levelPs.size; index++) {
|
|
813
|
+
const p = new PolynomialRef(pm);
|
|
814
|
+
p.set(this.levelPs.get(index));
|
|
815
|
+
const lc = new PolynomialRef(pm);
|
|
816
|
+
lc.set(pm.coeff(p.get(), this.maxVar, pm.degree(p.get(), this.maxVar)));
|
|
817
|
+
let isLcAdded = true;
|
|
818
|
+
if (
|
|
819
|
+
!(this.polyHasRoots[index] ?? false) &&
|
|
820
|
+
!pm.isZero(lc.get()) &&
|
|
821
|
+
this.getSign(lc.get()) !== 0
|
|
822
|
+
) {
|
|
823
|
+
isLcAdded = false;
|
|
824
|
+
this.witnesses[index].reset();
|
|
825
|
+
}
|
|
826
|
+
this.addProjectionForPoly(
|
|
827
|
+
p.get(),
|
|
828
|
+
this.maxVar,
|
|
829
|
+
this.witnesses[index].getOrNull(),
|
|
830
|
+
isLcAdded,
|
|
831
|
+
true,
|
|
832
|
+
);
|
|
833
|
+
lc.reset();
|
|
834
|
+
p.reset();
|
|
835
|
+
}
|
|
836
|
+
}
|
|
837
|
+
|
|
838
|
+
private copyIntervals() {
|
|
839
|
+
return this.intervals.map((interval) => {
|
|
840
|
+
const copy = new CellInterval(this.pm);
|
|
841
|
+
copy.isSection = interval.isSection;
|
|
842
|
+
copy.lower.copy(interval.lower);
|
|
843
|
+
copy.lowerIndex = interval.lowerIndex;
|
|
844
|
+
copy.upper.copy(interval.upper);
|
|
845
|
+
copy.upperIndex = interval.upperIndex;
|
|
846
|
+
return copy;
|
|
623
847
|
});
|
|
624
848
|
}
|
|
625
849
|
|
|
626
|
-
|
|
627
|
-
if (this.maxVar === 0) return this.
|
|
628
|
-
|
|
629
|
-
|
|
850
|
+
singleCell() {
|
|
851
|
+
if (this.maxVar === 0) return this.copyIntervals();
|
|
852
|
+
this.todo.reset();
|
|
853
|
+
for (let index = 0; index < this.polynomials.size; index++) {
|
|
854
|
+
const p = new PolynomialRef(this.pm);
|
|
855
|
+
p.set(this.polynomials.get(index));
|
|
856
|
+
this.requestFactorized(p.get());
|
|
857
|
+
p.reset();
|
|
858
|
+
}
|
|
859
|
+
if (this.todo.isEmpty) return this.copyIntervals();
|
|
630
860
|
if (this.todo.getMaxVar() === this.maxVar) {
|
|
631
|
-
this.level = this.todo.extractMaxPolys(this.
|
|
861
|
+
this.level = this.todo.extractMaxPolys(this.levelPs);
|
|
632
862
|
this.processTopLevel();
|
|
633
863
|
}
|
|
634
864
|
while (!this.todo.isEmpty) {
|
|
635
|
-
this.level = this.todo.extractMaxPolys(this.
|
|
865
|
+
this.level = this.todo.extractMaxPolys(this.levelPs);
|
|
636
866
|
this.processLevel();
|
|
637
867
|
}
|
|
638
|
-
return this.
|
|
868
|
+
return this.copyIntervals();
|
|
639
869
|
}
|
|
640
870
|
}
|
|
641
|
-
|
|
642
|
-
export const getSingleCell = (
|
|
643
|
-
pm: PolynomialManager,
|
|
644
|
-
am: AlgebraicManager,
|
|
645
|
-
cache: PolynomialCache,
|
|
646
|
-
polynomials: readonly Polynomial[],
|
|
647
|
-
maxVar: number,
|
|
648
|
-
sample: readonly (Anum | undefined)[],
|
|
649
|
-
isLinear: boolean,
|
|
650
|
-
) => new Levelwise(pm, am, cache, sample, maxVar, isLinear).computeSingleCell(polynomials);
|