tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa
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 +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -2
- package/dist/index.d.ts +3 -2
- 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 +60 -60
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -44
- package/dist/run.js +44 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -43
- package/dist/transfer.js +39 -39
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +1 -0
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +1 -1
- package/src/check-trace.ts +90 -51
- package/src/check.ts +367 -178
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +16 -10
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +26 -9
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +22 -10
- package/src/environment.ts +58 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +117 -41
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +81 -33
- package/src/liveness.ts +49 -11
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +112 -145
- 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 +169 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +63 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- 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 +32 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +47 -9
- 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 +9 -4
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- 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 +2 -0
- 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 +9 -2
- package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- 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/model-based-opt.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 +10 -4
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.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 +1 -1
- 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/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 +20 -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 +9 -5
- package/src/prover/smt/solver/optsmt.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 +16 -6
- 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.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +13 -5
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -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-kernel.ts +39 -5
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +584 -223
- package/src/prover/smt/solver/smtlib-script.ts +509 -154
- 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 +284 -168
- 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.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/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 +959 -243
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- 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 +166 -101
- package/src/simulate.ts +110 -50
- package/src/spec-description.ts +5 -6
- package/src/standard-modules.ts +15 -6
- package/src/subexpressions.ts +398 -108
- package/src/successors.ts +4 -2
- package/src/symmetry.ts +1 -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 +3 -2
- 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/typed-tier.ts +32 -25
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
// Of Z3's nlsat parameters only seed and factor are ported, so nlsat_simplify and the bounds of
|
|
2
2
|
// eliminated variables are not. The search counts its steps against the resource limit, but not the
|
|
3
3
|
// memory, which Z3 also bounds by max_memory.
|
|
4
|
-
import {
|
|
4
|
+
import { SmtInvariantError } from "../../../../errors";
|
|
5
5
|
import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
|
|
6
6
|
import { type Dependency, linearize, mkJoin, mkLeaf } from "../lp/dependency";
|
|
7
7
|
import { RandomGen } from "../random-gen";
|
|
@@ -11,8 +11,14 @@ import { AlgebraicManager, Anum } from "./algebraic";
|
|
|
11
11
|
import { AtomTable, FALSE_LITERAL, ScopedLiterals, TRUE_LITERAL } from "./atoms";
|
|
12
12
|
import { Evaluator } from "./evaluator";
|
|
13
13
|
import { Explain } from "./explain";
|
|
14
|
-
import type { IntervalSet } from "./interval-set";
|
|
15
|
-
import {
|
|
14
|
+
import type { IntervalSet, IntervalSetManager } from "./interval-set";
|
|
15
|
+
import {
|
|
16
|
+
NULL_VAR,
|
|
17
|
+
type Polynomial,
|
|
18
|
+
PolynomialCache,
|
|
19
|
+
PolynomialManager,
|
|
20
|
+
PolynomialRef,
|
|
21
|
+
} from "./polynomial";
|
|
16
22
|
import { NlsatTranscendentals } from "./transcendentals";
|
|
17
23
|
import { type Clause, type IneqAtom, type IneqKind, isIneqAtom, type RootKind } from "./types";
|
|
18
24
|
|
|
@@ -35,30 +41,18 @@ type Trail =
|
|
|
35
41
|
| { kind: "eq"; old: IneqAtom | null };
|
|
36
42
|
|
|
37
43
|
export class NlsatSolver {
|
|
38
|
-
readonly pm
|
|
39
|
-
readonly am
|
|
40
|
-
private cache
|
|
44
|
+
readonly pm: PolynomialManager;
|
|
45
|
+
readonly am: AlgebraicManager;
|
|
46
|
+
private cache: PolynomialCache;
|
|
41
47
|
private bvalues: number[] = [];
|
|
42
48
|
private levels: number[] = [];
|
|
43
49
|
private justifications: (Justification | null)[] = [];
|
|
44
50
|
private bwatches: Clause[][] = [];
|
|
45
51
|
private isDead: boolean[] = [];
|
|
46
|
-
readonly atoms
|
|
47
|
-
onMk: (boolVar) => {
|
|
48
|
-
this.bvalues[boolVar] = L_UNDEF;
|
|
49
|
-
this.levels[boolVar] = Infinity;
|
|
50
|
-
this.justifications[boolVar] = null;
|
|
51
|
-
this.bwatches[boolVar] = [];
|
|
52
|
-
this.isDead[boolVar] = false;
|
|
53
|
-
},
|
|
54
|
-
onDelete: (boolVar) => {
|
|
55
|
-
this.isDead[boolVar] = true;
|
|
56
|
-
this.bvalues[boolVar] = L_UNDEF;
|
|
57
|
-
},
|
|
58
|
-
});
|
|
52
|
+
readonly atoms: AtomTable;
|
|
59
53
|
private assignment: (Anum | undefined)[] = [];
|
|
60
|
-
private evaluator
|
|
61
|
-
private ism
|
|
54
|
+
private evaluator: Evaluator;
|
|
55
|
+
private ism: IntervalSetManager;
|
|
62
56
|
private clauses: Clause[] = [];
|
|
63
57
|
private learned: Clause[] = [];
|
|
64
58
|
private nextClauseId = 0;
|
|
@@ -68,24 +62,16 @@ export class NlsatSolver {
|
|
|
68
62
|
private var2eq: (IneqAtom | null)[] = [];
|
|
69
63
|
private perm: number[] = [];
|
|
70
64
|
private invPerm: number[] = [];
|
|
71
|
-
readonly explain
|
|
72
|
-
|
|
73
|
-
sample: this.assignment,
|
|
74
|
-
getValue: (literal) => this.value(literal),
|
|
75
|
-
var2eq: this.var2eq,
|
|
76
|
-
getNumVars: () => this.isInt.length,
|
|
77
|
-
reorder: (permutation) => this.reorder(permutation),
|
|
78
|
-
restoreOrder: () => this.restoreOrder(),
|
|
79
|
-
});
|
|
80
|
-
readonly transcendentals = new NlsatTranscendentals(this);
|
|
65
|
+
readonly explain: Explain;
|
|
66
|
+
readonly transcendentals: NlsatTranscendentals;
|
|
81
67
|
private bk = 0;
|
|
82
68
|
private xk = NULL_VAR;
|
|
83
69
|
private scopeLevel = 0;
|
|
84
70
|
private trail: Trail[] = [];
|
|
85
71
|
private marks: boolean[] = [];
|
|
86
72
|
private markCount = 0;
|
|
87
|
-
private lemma
|
|
88
|
-
private lazyClause
|
|
73
|
+
private lemma: ScopedLiterals;
|
|
74
|
+
private lazyClause: ScopedLiterals;
|
|
89
75
|
private lemmaAssumptions: Dependency = null;
|
|
90
76
|
private randomSeed = 0;
|
|
91
77
|
private isReordered = false;
|
|
@@ -102,7 +88,37 @@ export class NlsatSolver {
|
|
|
102
88
|
irrationalAssignments: 0,
|
|
103
89
|
};
|
|
104
90
|
|
|
105
|
-
constructor(private limit: ResourceLimit
|
|
91
|
+
constructor(private limit: ResourceLimit) {
|
|
92
|
+
this.pm = new PolynomialManager(limit);
|
|
93
|
+
this.am = new AlgebraicManager(limit);
|
|
94
|
+
this.cache = new PolynomialCache(this.pm);
|
|
95
|
+
this.atoms = new AtomTable(this.pm, this.cache, {
|
|
96
|
+
onMk: (boolVar) => {
|
|
97
|
+
this.bvalues[boolVar] = L_UNDEF;
|
|
98
|
+
this.levels[boolVar] = Infinity;
|
|
99
|
+
this.justifications[boolVar] = null;
|
|
100
|
+
this.bwatches[boolVar] = [];
|
|
101
|
+
this.isDead[boolVar] = false;
|
|
102
|
+
},
|
|
103
|
+
onDelete: (boolVar) => {
|
|
104
|
+
this.isDead[boolVar] = true;
|
|
105
|
+
this.bvalues[boolVar] = L_UNDEF;
|
|
106
|
+
},
|
|
107
|
+
});
|
|
108
|
+
this.evaluator = new Evaluator(this.pm, this.am, this.assignment);
|
|
109
|
+
this.ism = this.evaluator.ism;
|
|
110
|
+
this.explain = new Explain(this.pm, this.am, this.cache, {
|
|
111
|
+
atoms: this.atoms,
|
|
112
|
+
sample: this.assignment,
|
|
113
|
+
getValue: (literal) => this.value(literal),
|
|
114
|
+
var2eq: this.var2eq,
|
|
115
|
+
getNumVars: () => this.isInt.length,
|
|
116
|
+
reorder: (permutation) => this.reorder(permutation),
|
|
117
|
+
restoreOrder: () => this.restoreOrder(),
|
|
118
|
+
});
|
|
119
|
+
this.transcendentals = new NlsatTranscendentals(this);
|
|
120
|
+
this.lemma = new ScopedLiterals(this.atoms);
|
|
121
|
+
this.lazyClause = new ScopedLiterals(this.atoms);
|
|
106
122
|
this.mkClause([TRUE_LITERAL], false, null);
|
|
107
123
|
}
|
|
108
124
|
|
|
@@ -112,10 +128,6 @@ export class NlsatSolver {
|
|
|
112
128
|
this.explain.isFactoring = isFactoring;
|
|
113
129
|
}
|
|
114
130
|
|
|
115
|
-
private checkpoint() {
|
|
116
|
-
if (this.limit !== null && !this.limit.inc()) throw new SmtCanceledError();
|
|
117
|
-
}
|
|
118
|
-
|
|
119
131
|
mkVar(isInt: boolean) {
|
|
120
132
|
const variable = this.isInt.length;
|
|
121
133
|
this.isInt.push(isInt);
|
|
@@ -394,7 +406,7 @@ export class NlsatSolver {
|
|
|
394
406
|
let selectedSet: IntervalSet | null = null;
|
|
395
407
|
const xkSet = this.infeasible[this.xk];
|
|
396
408
|
for (const [index, literal] of clause.literals.entries()) {
|
|
397
|
-
this.checkpoint();
|
|
409
|
+
this.limit.checkpoint();
|
|
398
410
|
if (this.value(literal) === L_FALSE) continue;
|
|
399
411
|
if (this.value(literal) === L_TRUE) return true;
|
|
400
412
|
const atom = this.atoms.getAtom(literal);
|
|
@@ -482,7 +494,7 @@ export class NlsatSolver {
|
|
|
482
494
|
} else this.newStage();
|
|
483
495
|
if (this.bk === NULL_BOOL_VAR && this.xk >= this.isInt.length) return L_TRUE;
|
|
484
496
|
while (true) {
|
|
485
|
-
this.checkpoint();
|
|
497
|
+
this.limit.checkpoint();
|
|
486
498
|
const conflict = this.processClauses(
|
|
487
499
|
this.xk === NULL_VAR ? this.bwatches[this.bk] : this.watches[this.xk],
|
|
488
500
|
);
|
|
@@ -502,7 +514,7 @@ export class NlsatSolver {
|
|
|
502
514
|
private gc() {
|
|
503
515
|
if (this.learned.length <= 4 * this.clauses.length) return;
|
|
504
516
|
this.resetWatches();
|
|
505
|
-
this.atoms.reinitCache();
|
|
517
|
+
this.atoms.reinitCache(this.clauses, this.learned);
|
|
506
518
|
let kept = 0;
|
|
507
519
|
for (const [index, clause] of this.learned.entries()) {
|
|
508
520
|
if (index - kept < this.clauses.length && clause.literals.length > 1 && !clause.isActive)
|
|
@@ -569,12 +581,14 @@ export class NlsatSolver {
|
|
|
569
581
|
}
|
|
570
582
|
this.initSearch();
|
|
571
583
|
for (const bound of bounds) {
|
|
584
|
+
const p = new PolynomialRef(this.pm);
|
|
572
585
|
this.lemma.reset();
|
|
573
|
-
|
|
574
|
-
this.lemma.push(this.mkIneqLiteral("GT", [
|
|
575
|
-
|
|
576
|
-
this.lemma.push(this.mkIneqLiteral("LT", [
|
|
586
|
+
p.set(this.pm.mkLinear([1n], [bound[0]], -bound[1].num));
|
|
587
|
+
this.lemma.push(this.mkIneqLiteral("GT", [p.get()], [false]) ^ 1);
|
|
588
|
+
p.set(this.pm.mkLinear([1n], [bound[0]], -bound[1].num - 1n));
|
|
589
|
+
this.lemma.push(this.mkIneqLiteral("LT", [p.get()], [false]) ^ 1);
|
|
577
590
|
this.mkClause(this.lemma.literals, true, null);
|
|
591
|
+
p.reset();
|
|
578
592
|
}
|
|
579
593
|
}
|
|
580
594
|
}
|
|
@@ -654,7 +668,7 @@ export class NlsatSolver {
|
|
|
654
668
|
private projectModel(cube: ScopedLiterals) {
|
|
655
669
|
const seen = new Set<number>();
|
|
656
670
|
for (const clause of this.clauses) {
|
|
657
|
-
this.checkpoint();
|
|
671
|
+
this.limit.checkpoint();
|
|
658
672
|
const witness = clause.literals.find((literal) => this.value(literal) === L_TRUE);
|
|
659
673
|
if (witness === undefined) throw new SmtInvariantError("nlsat's model falsifies a clause");
|
|
660
674
|
if (this.atoms.getAtom(witness) === null || seen.has(witness >> 1)) continue;
|
|
@@ -666,7 +680,7 @@ export class NlsatSolver {
|
|
|
666
680
|
const projected = new ScopedLiterals(this.atoms);
|
|
667
681
|
try {
|
|
668
682
|
for (let variable = this.isInt.length - 1; variable >= 1 && cube.size > 0; variable--) {
|
|
669
|
-
this.checkpoint();
|
|
683
|
+
this.limit.checkpoint();
|
|
670
684
|
projected.reset();
|
|
671
685
|
this.explain.projectVariable(variable, cube.literals, projected);
|
|
672
686
|
[cube.literals, projected.literals] = [projected.literals, cube.literals];
|
|
@@ -702,14 +716,16 @@ export class NlsatSolver {
|
|
|
702
716
|
try {
|
|
703
717
|
if (limit !== null) {
|
|
704
718
|
const isRational = this.am.isRational(limit);
|
|
705
|
-
const
|
|
719
|
+
const p = new PolynomialRef(this.pm);
|
|
720
|
+
p.set(this.pm.toPolynomial(this.am.getPolynomial(limit), variable));
|
|
706
721
|
const upper = isRational
|
|
707
|
-
? this.mkIneqLiteral("LT", [
|
|
708
|
-
: 2 * this.mkRootAtom("ROOT_LT", variable, this.am.getRootIndex(limit),
|
|
722
|
+
? this.mkIneqLiteral("LT", [p.get()], [false])
|
|
723
|
+
: 2 * this.mkRootAtom("ROOT_LT", variable, this.am.getRootIndex(limit), p.get());
|
|
709
724
|
this.mkExternalClause([upper], tag);
|
|
725
|
+
p.reset();
|
|
710
726
|
}
|
|
711
727
|
while (true) {
|
|
712
|
-
this.checkpoint();
|
|
728
|
+
this.limit.checkpoint();
|
|
713
729
|
const status = this.check();
|
|
714
730
|
if (status !== L_TRUE) return status;
|
|
715
731
|
const cube = new ScopedLiterals(this.atoms);
|
|
@@ -792,10 +808,10 @@ export class NlsatSolver {
|
|
|
792
808
|
}
|
|
793
809
|
|
|
794
810
|
private processAntecedent(antecedent: number) {
|
|
795
|
-
this.checkpoint();
|
|
811
|
+
this.limit.checkpoint();
|
|
796
812
|
const boolVar = antecedent >> 1;
|
|
797
813
|
if (this.getAssignedValue(antecedent) === L_UNDEF) {
|
|
798
|
-
this.checkpoint();
|
|
814
|
+
this.limit.checkpoint();
|
|
799
815
|
if (!this.marks[boolVar]) {
|
|
800
816
|
this.marks[boolVar] = true;
|
|
801
817
|
this.lemma.push(antecedent);
|
|
@@ -823,7 +839,7 @@ export class NlsatSolver {
|
|
|
823
839
|
this.lazyClause.reset();
|
|
824
840
|
this.explain.computeConflictExplanation(literals, this.lazyClause);
|
|
825
841
|
for (const literal of literals) this.lazyClause.push(literal ^ 1);
|
|
826
|
-
this.checkpoint();
|
|
842
|
+
this.limit.checkpoint();
|
|
827
843
|
this.resolveLiterals(boolVar, this.lazyClause.literals);
|
|
828
844
|
for (const clause of clauses)
|
|
829
845
|
this.lemmaAssumptions = mkJoin(clause.assumptions, this.lemmaAssumptions);
|
|
@@ -864,7 +880,7 @@ export class NlsatSolver {
|
|
|
864
880
|
let isDecision = false;
|
|
865
881
|
while (true) {
|
|
866
882
|
while (this.markCount > 0) {
|
|
867
|
-
this.checkpoint();
|
|
883
|
+
this.limit.checkpoint();
|
|
868
884
|
const entry = this.trail[top - 1];
|
|
869
885
|
if (entry.kind === "assignment" && this.marks[entry.boolVar]) {
|
|
870
886
|
const boolVar = entry.boolVar;
|
|
@@ -998,7 +1014,7 @@ export class NlsatSolver {
|
|
|
998
1014
|
else this.learned[kept++] = clause;
|
|
999
1015
|
}
|
|
1000
1016
|
this.learned.length = kept;
|
|
1001
|
-
this.atoms.reinitCache();
|
|
1017
|
+
this.atoms.reinitCache(this.clauses, this.learned);
|
|
1002
1018
|
this.resetWatches();
|
|
1003
1019
|
const assignment: (Anum | undefined)[] = [];
|
|
1004
1020
|
for (const [variable, value] of this.assignment.entries())
|
|
@@ -1011,15 +1027,9 @@ export class NlsatSolver {
|
|
|
1011
1027
|
for (const [variable, isIntVariable] of isInt.entries())
|
|
1012
1028
|
this.isInt[permutation[variable]] = isIntVariable;
|
|
1013
1029
|
this.invPerm = invPerm;
|
|
1014
|
-
|
|
1015
|
-
for (const atom of this.atoms.atoms) {
|
|
1016
|
-
if (atom === null) continue;
|
|
1017
|
-
if (isIneqAtom(atom)) for (const polynomial of atom.polynomials) polynomials.add(polynomial);
|
|
1018
|
-
else polynomials.add(atom.polynomial);
|
|
1019
|
-
}
|
|
1020
|
-
this.pm.rename(permutation, polynomials);
|
|
1030
|
+
this.pm.rename(permutation);
|
|
1021
1031
|
this.transcendentals.rename(permutation);
|
|
1022
|
-
this.atoms.reinitCache();
|
|
1032
|
+
this.atoms.reinitCache(this.clauses, this.learned);
|
|
1023
1033
|
this.setAssignment(assignment);
|
|
1024
1034
|
this.reattachArithClauses(this.clauses);
|
|
1025
1035
|
this.reattachArithClauses(this.learned);
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { getLcm, Rational } from "../rational";
|
|
2
2
|
import { Anum } from "./algebraic";
|
|
3
|
-
import { NULL_VAR } from "./polynomial";
|
|
3
|
+
import { NULL_VAR, PolynomialRef } from "./polynomial";
|
|
4
4
|
import type { NlsatSolver } from "./solver";
|
|
5
5
|
import {
|
|
6
6
|
getAtanTaylorBracket,
|
|
@@ -49,8 +49,11 @@ export class NlsatTranscendentals {
|
|
|
49
49
|
}
|
|
50
50
|
|
|
51
51
|
private mkBoundLiteral(variable: number, kind: "LT" | "GT", bound: Rational) {
|
|
52
|
-
const
|
|
53
|
-
|
|
52
|
+
const p = new PolynomialRef(this.solver.pm);
|
|
53
|
+
p.set(this.solver.pm.mkLinear([bound.den], [variable], -bound.num));
|
|
54
|
+
const literal = this.solver.mkIneqLiteral(kind, [p.get()], [false]);
|
|
55
|
+
p.reset();
|
|
56
|
+
return literal;
|
|
54
57
|
}
|
|
55
58
|
|
|
56
59
|
// first * firstCoeff + second * secondCoeff kind bound.
|
|
@@ -63,12 +66,17 @@ export class NlsatTranscendentals {
|
|
|
63
66
|
bound: Rational,
|
|
64
67
|
) {
|
|
65
68
|
const den = Rational.of(getLcm(firstCoeff.den, getLcm(secondCoeff.den, bound.den)));
|
|
66
|
-
const
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
69
|
+
const p = new PolynomialRef(this.solver.pm);
|
|
70
|
+
p.set(
|
|
71
|
+
this.solver.pm.mkLinear(
|
|
72
|
+
[firstCoeff.mul(den).num, secondCoeff.mul(den).num],
|
|
73
|
+
[first, second],
|
|
74
|
+
bound.mul(den).neg().num,
|
|
75
|
+
),
|
|
70
76
|
);
|
|
71
|
-
|
|
77
|
+
const literal = this.solver.mkIneqLiteral(kind, [p.get()], [false]);
|
|
78
|
+
p.reset();
|
|
79
|
+
return literal;
|
|
72
80
|
}
|
|
73
81
|
|
|
74
82
|
private mkClause(literals: readonly number[]) {
|
|
@@ -160,16 +168,32 @@ export class NlsatTranscendentals {
|
|
|
160
168
|
|
|
161
169
|
private addIdentityAxiom(kind: "sin" | "sinh" | "tanh", first: number, second: number) {
|
|
162
170
|
const pm = this.solver.pm;
|
|
163
|
-
const
|
|
164
|
-
const
|
|
165
|
-
const
|
|
166
|
-
const
|
|
171
|
+
const v1 = new PolynomialRef(pm);
|
|
172
|
+
const v2 = new PolynomialRef(pm);
|
|
173
|
+
const v1sq = new PolynomialRef(pm);
|
|
174
|
+
const v2sq = new PolynomialRef(pm);
|
|
175
|
+
const eq = new PolynomialRef(pm);
|
|
176
|
+
const product = new PolynomialRef(pm);
|
|
177
|
+
const difference = new PolynomialRef(pm);
|
|
178
|
+
v1.set(pm.mkVar(first));
|
|
179
|
+
v2.set(pm.mkVar(second));
|
|
180
|
+
v1sq.set(pm.mul(v1.get(), v1.get()));
|
|
181
|
+
v2sq.set(pm.mul(v2.get(), v2.get()));
|
|
182
|
+
if (kind === "tanh") product.set(pm.mul(v1sq.get(), v2sq.get()));
|
|
183
|
+
difference.set(
|
|
167
184
|
kind === "sin"
|
|
168
|
-
? pm.
|
|
169
|
-
: kind === "sinh"
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
185
|
+
? pm.add(v1sq.get(), v2sq.get())
|
|
186
|
+
: pm.sub(v1sq.get(), kind === "sinh" ? v2sq.get() : product.get()),
|
|
187
|
+
);
|
|
188
|
+
eq.set(pm.sub(difference.get(), pm.one));
|
|
189
|
+
difference.reset();
|
|
190
|
+
product.reset();
|
|
191
|
+
this.mkClause([this.solver.mkIneqLiteral("EQ", [eq.get()], [false])]);
|
|
192
|
+
eq.reset();
|
|
193
|
+
v2sq.reset();
|
|
194
|
+
v1sq.reset();
|
|
195
|
+
v2.reset();
|
|
196
|
+
v1.reset();
|
|
173
197
|
}
|
|
174
198
|
|
|
175
199
|
// Exact Taylor brackets: exp, log and atan are increasing where their series apply, and the
|
|
@@ -221,7 +221,7 @@ const henselLiftOnce = (
|
|
|
221
221
|
r: bigint,
|
|
222
222
|
polynomials: { u: Upolynomial; a: Upolynomial; v: Upolynomial; b: Upolynomial; c: Upolynomial },
|
|
223
223
|
) => {
|
|
224
|
-
const zr = new UpolynomialManager(r);
|
|
224
|
+
const zr = new UpolynomialManager(z.limit, r);
|
|
225
225
|
const f = zr.set(z.divConst(z.sub(polynomials.c, z.mul(polynomials.a, polynomials.b)), b));
|
|
226
226
|
const division = zr.divRem(zr.mul(polynomials.v, f), polynomials.a);
|
|
227
227
|
const t = zr.add(zr.mul(polynomials.u, f), zr.mul(polynomials.b, division.quotient));
|
|
@@ -239,13 +239,14 @@ const henselLiftQuadratic = (
|
|
|
239
239
|
b: Upolynomial,
|
|
240
240
|
e: number,
|
|
241
241
|
) => {
|
|
242
|
-
const zp = new UpolynomialManager(zpe.zp);
|
|
242
|
+
const zp = new UpolynomialManager(z.limit, zpe.zp);
|
|
243
243
|
const ext = zp.extGcd(a, b);
|
|
244
244
|
let u = ext.u;
|
|
245
245
|
let v = ext.v;
|
|
246
246
|
let currentA = [...a];
|
|
247
247
|
let currentB = [...b];
|
|
248
248
|
for (let k = 1; k < e; k *= 2) {
|
|
249
|
+
z.limit.checkpoint();
|
|
249
250
|
const modulus = zpe.zp as bigint;
|
|
250
251
|
const lifted = henselLiftOnce(z, modulus, modulus, {
|
|
251
252
|
u,
|
|
@@ -451,12 +452,13 @@ export const factorSquareFree = (
|
|
|
451
452
|
fPp = fPp.map((coeff) => -coeff);
|
|
452
453
|
if (k % 2 === 1) fs.constant = -fs.constant;
|
|
453
454
|
}
|
|
454
|
-
const zp = new UpolynomialManager(2n);
|
|
455
|
+
const zp = new UpolynomialManager(z.limit, 2n);
|
|
455
456
|
let zpFs = mkFactors();
|
|
456
457
|
let zpFsPrime = 2n;
|
|
457
458
|
let degreeSet = [true];
|
|
458
459
|
const getNextPrime = mkPrimeIterator();
|
|
459
460
|
for (let trials = 0; trials <= params.primeTrials;) {
|
|
461
|
+
z.limit.checkpoint();
|
|
460
462
|
const nextPrime = getNextPrime();
|
|
461
463
|
if (nextPrime > params.maxPrime) {
|
|
462
464
|
pushFactor(z, fs, fPp, k);
|
|
@@ -488,7 +490,7 @@ export const factorSquareFree = (
|
|
|
488
490
|
}
|
|
489
491
|
}
|
|
490
492
|
zp.setZp(zpFsPrime);
|
|
491
|
-
const zpe = new UpolynomialManager(zpFsPrime);
|
|
493
|
+
const zpe = new UpolynomialManager(z.limit, zpFsPrime);
|
|
492
494
|
const zpeFs = henselLiftFactors(z, fPp, zp, zpFs, getMignotteBound(fPp, zpFsPrime), zpe);
|
|
493
495
|
let leading = zpe.normalizeNumeral(fPp[fPp.length - 1]);
|
|
494
496
|
fPp = z.mulConst(fPp, leading);
|
|
@@ -497,6 +499,7 @@ export const factorSquareFree = (
|
|
|
497
499
|
let result = true;
|
|
498
500
|
let isRemoving = false;
|
|
499
501
|
for (let counter = 1; iterator.next(isRemoving); counter++) {
|
|
502
|
+
z.limit.checkpoint();
|
|
500
503
|
if (counter > params.maxSearchSize) {
|
|
501
504
|
result = false;
|
|
502
505
|
break;
|
|
@@ -584,6 +587,7 @@ export const factorUpolynomial = (
|
|
|
584
587
|
let isComplete = true;
|
|
585
588
|
let product = z.exactDiv(primitive, square) as bigint[];
|
|
586
589
|
for (let multiplicity = 1; product.length > 1; multiplicity++) {
|
|
590
|
+
z.limit.checkpoint();
|
|
587
591
|
const next = z.gcd(product, square);
|
|
588
592
|
const factor = z.exactDiv(product, next) as bigint[];
|
|
589
593
|
if (factor.length > 1) {
|
|
@@ -1,10 +1,11 @@
|
|
|
1
|
-
import { SmtInvariantError } from "../../../../errors";
|
|
1
|
+
import { SmtCanceledError, SmtInvariantError } from "../../../../errors";
|
|
2
2
|
import { getGcd, Rational } from "../rational";
|
|
3
|
+
import type { ResourceLimit } from "../rlimit";
|
|
3
4
|
import { getLog2, Mpbq, refineLower, refineUpper } from "./mpbq";
|
|
4
5
|
|
|
5
6
|
export type Upolynomial = readonly bigint[];
|
|
6
7
|
|
|
7
|
-
const BIG_PRIMES = [
|
|
8
|
+
export const BIG_PRIMES = [
|
|
8
9
|
39103, 39107, 39113, 39119, 39133, 39139, 39157, 39161, 39163, 39181, 39191, 39199, 39209, 39217,
|
|
9
10
|
39227, 39229, 39233, 39239, 39241, 39251, 39293, 39301, 39313, 39317, 39323, 39341, 39343, 39359,
|
|
10
11
|
39367, 39371, 39373, 39383, 39397, 39409, 39419, 39439, 39443, 39451, 39461, 39499, 39503, 39509,
|
|
@@ -26,12 +27,12 @@ const BIG_PRIMES = [
|
|
|
26
27
|
|
|
27
28
|
const getSign = (value: bigint) => (value > 0n ? 1 : value < 0n ? -1 : 0);
|
|
28
29
|
|
|
29
|
-
|
|
30
|
+
const floorDiv = (dividend: bigint, divisor: bigint) => {
|
|
30
31
|
const quotient = dividend / divisor;
|
|
31
32
|
return dividend % divisor !== 0n && dividend < 0n !== divisor < 0n ? quotient - 1n : quotient;
|
|
32
33
|
};
|
|
33
34
|
|
|
34
|
-
const getExtendedGcd = (first: bigint, second: bigint) => {
|
|
35
|
+
export const getExtendedGcd = (first: bigint, second: bigint) => {
|
|
35
36
|
let [oldR, r] = [first, second];
|
|
36
37
|
let [oldS, s] = [1n, 0n];
|
|
37
38
|
let [oldT, t] = [0n, 1n];
|
|
@@ -73,7 +74,10 @@ interface DrsFrame {
|
|
|
73
74
|
export class UpolynomialManager {
|
|
74
75
|
private isPrimeModulus = true;
|
|
75
76
|
|
|
76
|
-
constructor(
|
|
77
|
+
constructor(
|
|
78
|
+
readonly limit: ResourceLimit,
|
|
79
|
+
private modulus: bigint | null = null,
|
|
80
|
+
) {}
|
|
77
81
|
|
|
78
82
|
get zp() {
|
|
79
83
|
return this.modulus;
|
|
@@ -170,12 +174,15 @@ export class UpolynomialManager {
|
|
|
170
174
|
mul(first: Upolynomial, second: Upolynomial) {
|
|
171
175
|
if (first.length === 0 || second.length === 0) return [];
|
|
172
176
|
const result = Array.from({ length: first.length + second.length - 1 }, () => 0n);
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
+
const outer = first.length < second.length ? second : first;
|
|
178
|
+
const inner = first.length < second.length ? first : second;
|
|
179
|
+
for (let index = 0; index < outer.length; index++) {
|
|
180
|
+
this.limit.checkpoint();
|
|
181
|
+
if (outer[index] === 0n) continue;
|
|
182
|
+
for (let other = 0; other < inner.length; other++)
|
|
183
|
+
if (inner[other] !== 0n)
|
|
177
184
|
result[index + other] = this.normalizeNumeral(
|
|
178
|
-
result[index + other] +
|
|
185
|
+
result[index + other] + outer[index] * inner[other],
|
|
179
186
|
);
|
|
180
187
|
}
|
|
181
188
|
return trim(result);
|
|
@@ -231,8 +238,10 @@ export class UpolynomialManager {
|
|
|
231
238
|
const quotient = Array.from({ length: quotientSize }, () => 0n);
|
|
232
239
|
const leading = divisor[divisor.length - 1];
|
|
233
240
|
let power = 0;
|
|
234
|
-
while (
|
|
241
|
+
while (true) {
|
|
242
|
+
this.limit.checkpoint();
|
|
235
243
|
const size = remainder.length;
|
|
244
|
+
if (size < divisor.length) return { quotient: trim(quotient), remainder, power };
|
|
236
245
|
const shift = size - divisor.length;
|
|
237
246
|
if (isField) {
|
|
238
247
|
const ratio = this.divNumeral(remainder[size - 1], leading);
|
|
@@ -257,7 +266,6 @@ export class UpolynomialManager {
|
|
|
257
266
|
remainder.length = size - 1;
|
|
258
267
|
trim(remainder);
|
|
259
268
|
}
|
|
260
|
-
return { quotient: trim(quotient), remainder, power };
|
|
261
269
|
}
|
|
262
270
|
|
|
263
271
|
div(dividend: Upolynomial, divisor: Upolynomial) {
|
|
@@ -271,8 +279,9 @@ export class UpolynomialManager {
|
|
|
271
279
|
const isField = this.isField;
|
|
272
280
|
const leading = divisor[divisor.length - 1];
|
|
273
281
|
let power = 0;
|
|
274
|
-
while (
|
|
282
|
+
while (this.limit.inc()) {
|
|
275
283
|
const size = remainder.length;
|
|
284
|
+
if (size < divisor.length) break;
|
|
276
285
|
const shift = size - divisor.length;
|
|
277
286
|
if (isField) {
|
|
278
287
|
const ratio = this.divNumeral(remainder[size - 1], leading);
|
|
@@ -357,13 +366,16 @@ export class UpolynomialManager {
|
|
|
357
366
|
if (second.length === 0) return this.flipSignIfLmNeg(this.set(first));
|
|
358
367
|
let a = this.set(first);
|
|
359
368
|
let b = this.set(second);
|
|
360
|
-
while (
|
|
369
|
+
while (this.limit.inc()) {
|
|
370
|
+
if (b.length === 0) {
|
|
371
|
+
const normalized = this.normalize(a);
|
|
372
|
+
return this.isField ? this.mkMonic(normalized) : this.flipSignIfLmNeg(normalized);
|
|
373
|
+
}
|
|
361
374
|
const remainder = this.normalize(this.rem(a, b));
|
|
362
375
|
a = b;
|
|
363
376
|
b = remainder;
|
|
364
377
|
}
|
|
365
|
-
|
|
366
|
-
return this.isField ? this.mkMonic(normalized) : this.flipSignIfLmNeg(normalized);
|
|
378
|
+
throw new SmtCanceledError();
|
|
367
379
|
}
|
|
368
380
|
|
|
369
381
|
private combineImages(image: Upolynomial, prime: bigint, combined: Upolynomial, bound: bigint) {
|
|
@@ -497,6 +509,7 @@ export class UpolynomialManager {
|
|
|
497
509
|
let previous = 0;
|
|
498
510
|
let changes = 0;
|
|
499
511
|
for (let index = 0; index < work.length; index++) {
|
|
512
|
+
this.limit.checkpoint();
|
|
500
513
|
let position = 1;
|
|
501
514
|
for (; position < work.length - index; position++) work[position] += work[position - 1];
|
|
502
515
|
const current = getSign(work[position - 1]);
|
|
@@ -513,9 +526,11 @@ export class UpolynomialManager {
|
|
|
513
526
|
translate(coeffs: Upolynomial) {
|
|
514
527
|
const result = [...coeffs];
|
|
515
528
|
const degree = result.length - 1;
|
|
516
|
-
for (let step = 1; step <= degree; step++)
|
|
529
|
+
for (let step = 1; step <= degree; step++) {
|
|
530
|
+
this.limit.checkpoint();
|
|
517
531
|
for (let index = degree - step; index <= degree - 1; index++)
|
|
518
532
|
result[index] += result[index + 1];
|
|
533
|
+
}
|
|
519
534
|
return result;
|
|
520
535
|
}
|
|
521
536
|
|
|
@@ -524,6 +539,7 @@ export class UpolynomialManager {
|
|
|
524
539
|
const result = this.composeAnPxDivA(coeffs, value.den);
|
|
525
540
|
const degree = result.length - 1;
|
|
526
541
|
for (let step = 1; step <= degree; step++) {
|
|
542
|
+
this.limit.checkpoint();
|
|
527
543
|
result[degree - step] += value.num * result[degree - step + 1];
|
|
528
544
|
for (let index = degree - step + 1; index <= degree - 1; index++)
|
|
529
545
|
result[index] = result[index] * value.den + value.num * result[index + 1];
|
|
@@ -696,6 +712,7 @@ export class UpolynomialManager {
|
|
|
696
712
|
this.pushChildFrames(this.div(coeffs, twoXMinusOne), frames);
|
|
697
713
|
} else this.pushChildFrames(coeffs, frames);
|
|
698
714
|
while (frames.length > 0) {
|
|
715
|
+
this.limit.checkpoint();
|
|
699
716
|
const frame = frames[frames.length - 1];
|
|
700
717
|
if (!frame.isFirst) {
|
|
701
718
|
frames.pop();
|
|
@@ -758,11 +775,12 @@ export class UpolynomialManager {
|
|
|
758
775
|
}
|
|
759
776
|
|
|
760
777
|
private sturmSeqCore(sequence: bigint[][]) {
|
|
761
|
-
while (
|
|
778
|
+
while (this.limit.inc()) {
|
|
762
779
|
const remainder = this.srem(sequence[sequence.length - 2], sequence[sequence.length - 1]);
|
|
763
780
|
if (remainder.length === 0) return sequence;
|
|
764
781
|
sequence.push(this.normalize(remainder));
|
|
765
782
|
}
|
|
783
|
+
return sequence;
|
|
766
784
|
}
|
|
767
785
|
|
|
768
786
|
sturmSeq(coeffs: Upolynomial) {
|
|
@@ -774,6 +792,7 @@ export class UpolynomialManager {
|
|
|
774
792
|
}
|
|
775
793
|
|
|
776
794
|
isolating2refinable(coeffs: Upolynomial, lower: Mpbq, upper: Mpbq): Refinement {
|
|
795
|
+
this.limit.checkpoint();
|
|
777
796
|
const signLower = this.evalSignAtBq(coeffs, lower);
|
|
778
797
|
const signUpper = this.evalSignAtBq(coeffs, upper);
|
|
779
798
|
if (signLower !== 0 && signUpper !== 0) return { isInterval: true, lower, upper };
|
|
@@ -782,6 +801,7 @@ export class UpolynomialManager {
|
|
|
782
801
|
let b = upper;
|
|
783
802
|
let newA = a.add(b).div2();
|
|
784
803
|
while (true) {
|
|
804
|
+
this.limit.checkpoint();
|
|
785
805
|
const signNewA = this.evalSignAtBq(coeffs, newA);
|
|
786
806
|
if (signNewA !== signUpper) return { isInterval: signNewA !== 0, lower: newA, upper: b };
|
|
787
807
|
b = newA;
|
|
@@ -793,6 +813,7 @@ export class UpolynomialManager {
|
|
|
793
813
|
let b = upper;
|
|
794
814
|
let newB = a.add(b).div2();
|
|
795
815
|
while (true) {
|
|
816
|
+
this.limit.checkpoint();
|
|
796
817
|
const signNewB = this.evalSignAtBq(coeffs, newB);
|
|
797
818
|
if (signNewB !== signLower)
|
|
798
819
|
return signNewB === 0
|
|
@@ -812,6 +833,7 @@ export class UpolynomialManager {
|
|
|
812
833
|
let newA1 = a1.add(b1).div2();
|
|
813
834
|
let newB2 = a2.add(b2).div2();
|
|
814
835
|
while (true) {
|
|
836
|
+
this.limit.checkpoint();
|
|
815
837
|
const signNewA1 = this.evalSignAtBq(coeffs, newA1);
|
|
816
838
|
if (signNewA1 === 0) return { isInterval: false, lower: newA1, upper };
|
|
817
839
|
if (signNewA1 === -signB1) return { isInterval: true, lower: newA1, upper: b1 };
|
|
@@ -838,6 +860,7 @@ export class UpolynomialManager {
|
|
|
838
860
|
const signLower = this.evalSignAtBq(coeffs, lower);
|
|
839
861
|
let current: Refinement = { isInterval: true, lower, upper };
|
|
840
862
|
while (true) {
|
|
863
|
+
this.limit.checkpoint();
|
|
841
864
|
if (current.upper.sub(current.lower).isLessThanOneDiv2k(precision)) return current;
|
|
842
865
|
current = this.refineCore(coeffs, signLower, current.lower, current.upper);
|
|
843
866
|
if (!current.isInterval) return current;
|
|
@@ -30,7 +30,7 @@ const mkModel = (
|
|
|
30
30
|
t2x: ReadonlyMap<number, number>,
|
|
31
31
|
a2b: ReadonlyMap<number, number>,
|
|
32
32
|
) => {
|
|
33
|
-
const model = new ProtoModel(manager);
|
|
33
|
+
const model = new ProtoModel(manager).mkModel();
|
|
34
34
|
for (const [term, variable] of t2x) {
|
|
35
35
|
if (!manager.isUninterpretedConst(term)) continue;
|
|
36
36
|
const value = solver.getValue(variable);
|
|
@@ -14,6 +14,7 @@ import {
|
|
|
14
14
|
OP_OR,
|
|
15
15
|
OP_XOR,
|
|
16
16
|
SORT_BOOL,
|
|
17
|
+
type SmtSymbol,
|
|
17
18
|
QUANTIFIER_FORALL,
|
|
18
19
|
} from "./ast";
|
|
19
20
|
import { mkNot } from "./ast-util";
|
|
@@ -27,7 +28,10 @@ export class DefinedNames {
|
|
|
27
28
|
private nameRefs: RefVector;
|
|
28
29
|
private lims: number[] = [];
|
|
29
30
|
|
|
30
|
-
constructor(
|
|
31
|
+
constructor(
|
|
32
|
+
private manager: AstManager,
|
|
33
|
+
private prefix: SmtSymbol | null = "z3name",
|
|
34
|
+
) {
|
|
31
35
|
this.exprs = new RefVector(manager);
|
|
32
36
|
this.nameRefs = new RefVector(manager);
|
|
33
37
|
}
|
|
@@ -68,7 +72,7 @@ export class DefinedNames {
|
|
|
68
72
|
const varSorts = freeVarSorts.map((sort) => sort ?? SORT_BOOL);
|
|
69
73
|
const sort = manager.sorts[expr];
|
|
70
74
|
const name = manager.mkApp(
|
|
71
|
-
manager.mkFreshFuncDecl(
|
|
75
|
+
manager.mkFreshFuncDecl(this.prefix, varSorts, sort),
|
|
72
76
|
freeVarSorts.map((varSort, index) =>
|
|
73
77
|
varSort === undefined ? manager.trueExpr : manager.mkVar(index, varSort),
|
|
74
78
|
),
|