tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9
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 +13 -3
- package/dist/index.d.ts +13 -3
- 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 +68 -68
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +45 -43
- package/dist/transfer.js +45 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +11 -1
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +9 -6
- package/src/check-trace.ts +116 -64
- package/src/check.ts +356 -173
- package/src/cli/tlc-output.ts +1 -0
- package/src/cli/tlc.ts +4 -3
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +34 -13
- package/src/coverage.ts +3 -0
- package/src/dependencies.ts +61 -13
- package/src/dfid.ts +22 -10
- package/src/environment.ts +71 -35
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +149 -54
- package/src/exit-codes.ts +29 -15
- package/src/instances.ts +16 -6
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +186 -97
- package/src/liveness-checker.ts +131 -83
- package/src/liveness.ts +52 -11
- 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/parser.ts +115 -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 +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +67 -13
- 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 +26 -15
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
- 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 +148 -39
- 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/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 +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 +81 -28
- 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 +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
- 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-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +674 -195
- 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 +332 -189
- 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 +1071 -251
- package/src/runtime.ts +5 -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 +38 -30
- package/src/sany/generator-proofs.ts +6 -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 +197 -117
- package/src/simulate.ts +165 -102
- package/src/spec-description.ts +8 -6
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +518 -123
- package/src/successors.ts +10 -3
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +27 -14
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +9 -22
- package/src/typed-tier.ts +44 -27
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
|
@@ -12,105 +12,227 @@ import {
|
|
|
12
12
|
SORT_INT,
|
|
13
13
|
SORT_REAL,
|
|
14
14
|
} from "./ast";
|
|
15
|
-
import
|
|
15
|
+
import {
|
|
16
|
+
type Polynomial,
|
|
17
|
+
type PolynomialManager,
|
|
18
|
+
PolynomialRef,
|
|
19
|
+
PolynomialRefVector,
|
|
20
|
+
} from "./nlsat/polynomial";
|
|
16
21
|
import { getLcm, Rational } from "./rational";
|
|
17
22
|
import { RefVector } from "./ref-vector";
|
|
18
23
|
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
24
|
+
interface Frame {
|
|
25
|
+
term: number;
|
|
26
|
+
index: number;
|
|
22
27
|
}
|
|
23
28
|
|
|
24
|
-
export
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
29
|
+
export class Expr2Polynomial {
|
|
30
|
+
private cache = new Map<number, number>();
|
|
31
|
+
private cachedDomain: RefVector;
|
|
32
|
+
private cachedPolynomials: PolynomialRefVector;
|
|
33
|
+
private cachedDenominators: bigint[] = [];
|
|
34
|
+
private frames: Frame[] = [];
|
|
35
|
+
private presult: PolynomialRefVector;
|
|
36
|
+
private dresult: bigint[] = [];
|
|
37
|
+
private var2expr: RefVector;
|
|
38
|
+
|
|
39
|
+
constructor(
|
|
40
|
+
private manager: AstManager,
|
|
41
|
+
readonly pm: PolynomialManager,
|
|
42
|
+
private t2x: Map<number, number>,
|
|
43
|
+
private mkVar: (isInt: boolean) => number,
|
|
44
|
+
) {
|
|
45
|
+
this.cachedDomain = new RefVector(manager);
|
|
46
|
+
this.cachedPolynomials = new PolynomialRefVector(pm);
|
|
47
|
+
this.presult = new PolynomialRefVector(pm);
|
|
48
|
+
this.var2expr = new RefVector(manager);
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
private reset() {
|
|
52
|
+
this.frames.length = 0;
|
|
53
|
+
this.presult.reset();
|
|
54
|
+
this.dresult.length = 0;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
private cacheResult(term: number) {
|
|
58
|
+
if (this.manager.getRefCount(term) <= 1) return;
|
|
59
|
+
this.cache.set(term, this.cachedPolynomials.size);
|
|
60
|
+
this.cachedDomain.push(term);
|
|
61
|
+
this.cachedPolynomials.push(this.presult.get(this.presult.size - 1));
|
|
62
|
+
this.cachedDenominators.push(this.dresult[this.dresult.length - 1]);
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
private storeResult(term: number, polynomial: Polynomial, denominator: bigint) {
|
|
66
|
+
this.presult.push(polynomial);
|
|
67
|
+
this.dresult.push(denominator);
|
|
68
|
+
this.cacheResult(term);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
private storeVarPoly(term: number) {
|
|
72
|
+
let variable = this.t2x.get(term);
|
|
73
|
+
if (variable === undefined) {
|
|
74
|
+
variable = this.mkVar(this.manager.sorts[term] === SORT_INT);
|
|
75
|
+
this.t2x.set(term, variable);
|
|
76
|
+
if (variable >= this.var2expr.size) this.var2expr.resize(variable + 1);
|
|
77
|
+
this.var2expr.set(variable, term);
|
|
78
|
+
}
|
|
79
|
+
this.storeResult(term, this.pm.mkVar(variable), 1n);
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
private visitArithApp(term: number) {
|
|
83
|
+
const manager = this.manager;
|
|
84
|
+
switch (manager.getOp(term)) {
|
|
35
85
|
case OP_NUM: {
|
|
36
|
-
const value = manager.getRationalValue(
|
|
37
|
-
|
|
86
|
+
const value = manager.getRationalValue(term);
|
|
87
|
+
this.storeResult(term, this.pm.mkConst(value.num), value.den);
|
|
88
|
+
return true;
|
|
38
89
|
}
|
|
39
90
|
case OP_ADD:
|
|
40
|
-
case OP_SUB:
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
let polynomial = pm.zero;
|
|
44
|
-
for (const [index, arg] of args.entries()) {
|
|
45
|
-
const scaled = pm.mulConst(denominator / arg.denominator, arg.polynomial);
|
|
46
|
-
polynomial =
|
|
47
|
-
index === 0
|
|
48
|
-
? scaled
|
|
49
|
-
: op === OP_ADD
|
|
50
|
-
? pm.add(polynomial, scaled)
|
|
51
|
-
: pm.sub(polynomial, scaled);
|
|
52
|
-
}
|
|
53
|
-
return { polynomial, denominator };
|
|
54
|
-
}
|
|
55
|
-
case OP_MUL: {
|
|
56
|
-
let polynomial = pm.one;
|
|
57
|
-
let denominator = 1n;
|
|
58
|
-
for (const arg of manager.getArgs(expr).map(convert)) {
|
|
59
|
-
polynomial = pm.mul(polynomial, arg.polynomial);
|
|
60
|
-
denominator *= arg.denominator;
|
|
61
|
-
}
|
|
62
|
-
return { polynomial, denominator };
|
|
63
|
-
}
|
|
64
|
-
case OP_UMINUS: {
|
|
65
|
-
const arg = convert(manager.getArg(expr, 0));
|
|
66
|
-
return { polynomial: pm.neg(arg.polynomial), denominator: arg.denominator };
|
|
67
|
-
}
|
|
91
|
+
case OP_SUB:
|
|
92
|
+
case OP_MUL:
|
|
93
|
+
case OP_UMINUS:
|
|
68
94
|
case OP_TO_REAL:
|
|
69
|
-
|
|
95
|
+
this.frames.push({ term, index: 0 });
|
|
96
|
+
return false;
|
|
70
97
|
case OP_POWER: {
|
|
71
|
-
const exponent = manager.getArg(
|
|
98
|
+
const exponent = manager.getArg(term, 1);
|
|
72
99
|
const value = manager.isNumeral(exponent) ? manager.getRationalValue(exponent) : undefined;
|
|
73
|
-
if (value === undefined || !value.isInt() || value.num <= 0n || value.num > 0xffffffffn)
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
};
|
|
100
|
+
if (value === undefined || !value.isInt() || value.num <= 0n || value.num > 0xffffffffn) {
|
|
101
|
+
this.storeVarPoly(term);
|
|
102
|
+
return true;
|
|
103
|
+
}
|
|
104
|
+
this.frames.push({ term, index: 0 });
|
|
105
|
+
return false;
|
|
80
106
|
}
|
|
81
107
|
default:
|
|
82
|
-
|
|
108
|
+
this.storeVarPoly(term);
|
|
109
|
+
return true;
|
|
83
110
|
}
|
|
84
|
-
}
|
|
85
|
-
return convert(term);
|
|
86
|
-
};
|
|
111
|
+
}
|
|
87
112
|
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
113
|
+
private visit(term: number) {
|
|
114
|
+
const manager = this.manager;
|
|
115
|
+
const cached = manager.getRefCount(term) > 1 ? this.cache.get(term) : undefined;
|
|
116
|
+
if (cached !== undefined) {
|
|
117
|
+
this.presult.push(this.cachedPolynomials.get(cached));
|
|
118
|
+
this.dresult.push(this.cachedDenominators[cached]);
|
|
119
|
+
return true;
|
|
120
|
+
}
|
|
121
|
+
if (manager.kinds[term] !== KIND_APP || manager.getFamily(term) !== FAMILY_ARITH) {
|
|
122
|
+
this.storeVarPoly(term);
|
|
123
|
+
return true;
|
|
124
|
+
}
|
|
125
|
+
return this.visitArithApp(term);
|
|
126
|
+
}
|
|
91
127
|
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
) {
|
|
96
|
-
this.varToTerm = new RefVector(manager);
|
|
128
|
+
private pop(numArgs: number) {
|
|
129
|
+
this.presult.shrink(this.presult.size - numArgs);
|
|
130
|
+
this.dresult.length -= numArgs;
|
|
97
131
|
}
|
|
98
132
|
|
|
99
|
-
private
|
|
100
|
-
const
|
|
101
|
-
|
|
102
|
-
const
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
133
|
+
private processAddSub(term: number, numArgs: number, isAdd: boolean) {
|
|
134
|
+
const pm = this.pm;
|
|
135
|
+
const first = this.presult.size - numArgs;
|
|
136
|
+
const p = new PolynomialRef(pm);
|
|
137
|
+
const pAux = new PolynomialRef(pm);
|
|
138
|
+
let denominator = 1n;
|
|
139
|
+
for (let index = 0; index < numArgs; index++)
|
|
140
|
+
denominator = getLcm(denominator, this.dresult[first + index]);
|
|
141
|
+
p.set(pm.zero);
|
|
142
|
+
for (let index = 0; index < numArgs; index++) {
|
|
143
|
+
pAux.set(
|
|
144
|
+
pm.mulConst(denominator / this.dresult[first + index], this.presult.get(first + index)),
|
|
145
|
+
);
|
|
146
|
+
if (index === 0) p.copy(pAux);
|
|
147
|
+
else p.set(isAdd ? pm.add(p.get(), pAux.get()) : pm.sub(p.get(), pAux.get()));
|
|
148
|
+
}
|
|
149
|
+
this.pop(numArgs);
|
|
150
|
+
this.storeResult(term, p.get(), denominator);
|
|
151
|
+
pAux.reset();
|
|
152
|
+
p.reset();
|
|
106
153
|
}
|
|
107
154
|
|
|
108
|
-
private
|
|
109
|
-
|
|
155
|
+
private processMul(term: number, numArgs: number) {
|
|
156
|
+
const first = this.presult.size - numArgs;
|
|
157
|
+
const p = new PolynomialRef(this.pm);
|
|
158
|
+
let denominator = 1n;
|
|
159
|
+
p.set(this.pm.one);
|
|
160
|
+
for (let index = 0; index < numArgs; index++) {
|
|
161
|
+
p.set(this.pm.mul(p.get(), this.presult.get(first + index)));
|
|
162
|
+
denominator *= this.dresult[first + index];
|
|
163
|
+
}
|
|
164
|
+
this.pop(numArgs);
|
|
165
|
+
this.storeResult(term, p.get(), denominator);
|
|
166
|
+
p.reset();
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
private processUminus(term: number) {
|
|
170
|
+
const negP = new PolynomialRef(this.pm);
|
|
171
|
+
negP.set(this.pm.neg(this.presult.get(this.presult.size - 1)));
|
|
172
|
+
this.presult.shrink(this.presult.size - 1);
|
|
173
|
+
this.presult.push(negP.get());
|
|
174
|
+
this.cacheResult(term);
|
|
175
|
+
negP.reset();
|
|
110
176
|
}
|
|
111
177
|
|
|
112
|
-
|
|
113
|
-
|
|
178
|
+
private processPower(term: number, numArgs: number) {
|
|
179
|
+
const first = this.presult.size - numArgs;
|
|
180
|
+
const k = Number(this.manager.getRationalValue(this.manager.getArg(term, 1)).num);
|
|
181
|
+
const p = new PolynomialRef(this.pm);
|
|
182
|
+
this.pm.pw(this.presult.get(first), k, p);
|
|
183
|
+
const denominator = this.dresult[first] ** BigInt(k);
|
|
184
|
+
this.pop(numArgs);
|
|
185
|
+
this.storeResult(term, p.get(), denominator);
|
|
186
|
+
p.reset();
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
private processApp(term: number) {
|
|
190
|
+
const numArgs = this.manager.getNumArgs(term);
|
|
191
|
+
switch (this.manager.getOp(term)) {
|
|
192
|
+
case OP_ADD:
|
|
193
|
+
return this.processAddSub(term, numArgs, true);
|
|
194
|
+
case OP_SUB:
|
|
195
|
+
return this.processAddSub(term, numArgs, false);
|
|
196
|
+
case OP_MUL:
|
|
197
|
+
return this.processMul(term, numArgs);
|
|
198
|
+
case OP_POWER:
|
|
199
|
+
return this.processPower(term, numArgs);
|
|
200
|
+
case OP_UMINUS:
|
|
201
|
+
return this.processUminus(term);
|
|
202
|
+
default:
|
|
203
|
+
return this.cacheResult(term);
|
|
204
|
+
}
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
toPolynomial(term: number, p: PolynomialRef) {
|
|
208
|
+
this.reset();
|
|
209
|
+
if (!this.visit(term)) {
|
|
210
|
+
const frames = this.frames;
|
|
211
|
+
while (frames.length > 0) {
|
|
212
|
+
const frame = frames[frames.length - 1];
|
|
213
|
+
const numArgs = this.manager.getNumArgs(frame.term);
|
|
214
|
+
let isPushed = false;
|
|
215
|
+
while (frame.index < numArgs) {
|
|
216
|
+
const arg = this.manager.getArg(frame.term, frame.index);
|
|
217
|
+
frame.index++;
|
|
218
|
+
if (!this.visit(arg)) {
|
|
219
|
+
isPushed = true;
|
|
220
|
+
break;
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
if (isPushed) continue;
|
|
224
|
+
this.processApp(frame.term);
|
|
225
|
+
frames.pop();
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
p.set(this.presult.get(this.presult.size - 1));
|
|
229
|
+
const denominator = this.dresult[this.dresult.length - 1];
|
|
230
|
+
this.reset();
|
|
231
|
+
return denominator;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
private isIntVar(variable: number) {
|
|
235
|
+
return this.manager.sorts[this.var2expr.items[variable]] === SORT_INT;
|
|
114
236
|
}
|
|
115
237
|
|
|
116
238
|
toExpr(polynomial: Polynomial, isUsingPower: boolean) {
|
|
@@ -125,7 +247,7 @@ export class Expr2Polynomial {
|
|
|
125
247
|
const coeff = polynomial.as[index];
|
|
126
248
|
if (coeff !== 1n) factors.push(mkNumeral(coeff));
|
|
127
249
|
for (const [position, variable] of monomial.vars.entries()) {
|
|
128
|
-
const term = this.
|
|
250
|
+
const term = this.var2expr.items[variable];
|
|
129
251
|
const base =
|
|
130
252
|
this.isIntVar(variable) && !isInt ? manager.mkApp(OP_TO_REAL, [term], SORT_REAL) : term;
|
|
131
253
|
const degree = monomial.degrees[position];
|
|
@@ -141,6 +263,9 @@ export class Expr2Polynomial {
|
|
|
141
263
|
}
|
|
142
264
|
|
|
143
265
|
release() {
|
|
144
|
-
this.
|
|
266
|
+
this.presult.reset();
|
|
267
|
+
this.cachedPolynomials.reset();
|
|
268
|
+
this.cachedDomain.reset();
|
|
269
|
+
this.var2expr.reset();
|
|
145
270
|
}
|
|
146
271
|
}
|
|
@@ -18,7 +18,7 @@ import { runSimplifier } from "./dependent-expr-state";
|
|
|
18
18
|
import { Expr2Polynomial } from "./expr2polynomial";
|
|
19
19
|
import type { Goal } from "./goal";
|
|
20
20
|
import { getLcm, Rational } from "./rational";
|
|
21
|
-
import { PolynomialManager } from "./nlsat/polynomial";
|
|
21
|
+
import { Factors, type Polynomial, PolynomialManager, PolynomialRef } from "./nlsat/polynomial";
|
|
22
22
|
import type { Rewrite } from "./rewriter-tpl";
|
|
23
23
|
import { RewriterTpl } from "./rewriter-tpl";
|
|
24
24
|
|
|
@@ -37,7 +37,13 @@ class FactorRewriter extends RewriterTpl {
|
|
|
37
37
|
private isSplittingFactors: boolean,
|
|
38
38
|
) {
|
|
39
39
|
super(manager);
|
|
40
|
-
|
|
40
|
+
let variableCount = 0;
|
|
41
|
+
this.expr2poly = new Expr2Polynomial(
|
|
42
|
+
manager,
|
|
43
|
+
new PolynomialManager(manager.limit),
|
|
44
|
+
new Map(),
|
|
45
|
+
() => variableCount++,
|
|
46
|
+
);
|
|
41
47
|
}
|
|
42
48
|
|
|
43
49
|
private mkZeroFor(expr: number) {
|
|
@@ -51,20 +57,36 @@ class FactorRewriter extends RewriterTpl {
|
|
|
51
57
|
: this.manager.mkApp(OP_MUL, args, this.manager.sorts[args[0]]);
|
|
52
58
|
}
|
|
53
59
|
|
|
54
|
-
private factor(op: number, lhs: number, rhs: number)
|
|
55
|
-
const manager = this.manager;
|
|
60
|
+
private factor(op: number, lhs: number, rhs: number) {
|
|
56
61
|
const pm = this.expr2poly.pm;
|
|
57
|
-
const first =
|
|
58
|
-
const second =
|
|
59
|
-
const
|
|
60
|
-
const
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
62
|
+
const first = new PolynomialRef(pm);
|
|
63
|
+
const second = new PolynomialRef(pm);
|
|
64
|
+
const p = new PolynomialRef(pm);
|
|
65
|
+
const firstDenominator = this.expr2poly.toPolynomial(lhs, first);
|
|
66
|
+
const secondDenominator = this.expr2poly.toPolynomial(rhs, second);
|
|
67
|
+
const lcm = getLcm(firstDenominator, secondDenominator);
|
|
68
|
+
p.set(
|
|
69
|
+
pm.addmulTerms(
|
|
70
|
+
lcm / firstDenominator,
|
|
71
|
+
pm.unit,
|
|
72
|
+
first.get(),
|
|
73
|
+
-(lcm / secondDenominator),
|
|
74
|
+
pm.unit,
|
|
75
|
+
second.get(),
|
|
76
|
+
),
|
|
65
77
|
);
|
|
66
|
-
|
|
67
|
-
const
|
|
78
|
+
const factors = new Factors(pm);
|
|
79
|
+
const result = pm.isConst(p.get()) ? -1 : this.factorPolynomial(op, p.get(), factors);
|
|
80
|
+
factors.reset();
|
|
81
|
+
p.reset();
|
|
82
|
+
second.reset();
|
|
83
|
+
first.reset();
|
|
84
|
+
return result;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
private factorPolynomial(op: number, polynomial: Polynomial, factors: Factors): number {
|
|
88
|
+
const manager = this.manager;
|
|
89
|
+
this.expr2poly.pm.factor(polynomial, factors);
|
|
68
90
|
if (factors.factors.length === 1 && factors.degrees[0] === 1) return -1;
|
|
69
91
|
const terms = factors.factors.map((factor) => this.expr2poly.toExpr(factor, true));
|
|
70
92
|
if (op === OP_EQ) {
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { SmtCanceledError } from "../../../errors";
|
|
1
|
+
import { SmtCanceledError, SmtTacticError } from "../../../errors";
|
|
2
2
|
import {
|
|
3
3
|
type AstManager,
|
|
4
4
|
KIND_APP,
|
|
@@ -7,27 +7,29 @@ import {
|
|
|
7
7
|
OP_AND,
|
|
8
8
|
OP_EQ,
|
|
9
9
|
OP_IMPLIES,
|
|
10
|
+
OP_OR,
|
|
10
11
|
OP_UBV2INT,
|
|
11
12
|
OP_ULEQ,
|
|
12
13
|
SORT_BOOL,
|
|
13
14
|
SORT_INT,
|
|
14
15
|
} from "./ast";
|
|
16
|
+
import { mkNot } from "./ast-util";
|
|
15
17
|
import { BoundManager } from "./bound-manager";
|
|
16
18
|
import { mkBvApp } from "./bv-decl-plugin";
|
|
17
19
|
import { Bv2IntContext, Bv2IntRewriter } from "./bv2int-rewriter";
|
|
18
|
-
import {
|
|
20
|
+
import { createCard2Bv } from "./card2bv";
|
|
21
|
+
import { DependentExprState } from "./dependent-expr-state";
|
|
19
22
|
import { runEnum2Bv } from "./dt2bv-tactic";
|
|
23
|
+
import { release } from "./expr-ref";
|
|
20
24
|
import { ExprSafeReplace } from "./expr-safe-replace";
|
|
21
25
|
import { type Definition, Goal } from "./goal";
|
|
22
|
-
import {
|
|
23
|
-
import { L_FALSE, L_TRUE } from "./lbool";
|
|
26
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
24
27
|
import { RefVector } from "./ref-vector";
|
|
25
28
|
import { Rewriter } from "./rewriter";
|
|
26
29
|
import { convertModel, getRewriterOptions } from "./tactic";
|
|
27
30
|
import { UINT_MAX } from "./sat/clause";
|
|
28
31
|
import type { SatParams } from "./sat/config";
|
|
29
32
|
import { IncSatSolver } from "./sat/inc-sat-solver";
|
|
30
|
-
import { SubstReplacer } from "./solve-eqs";
|
|
31
33
|
|
|
32
34
|
const getNumBits = (value: bigint) => {
|
|
33
35
|
let bound = 1n;
|
|
@@ -50,9 +52,10 @@ const collectBounds = (manager: AstManager, bounds: BoundManager, form: number)
|
|
|
50
52
|
// bounded_int2bv_simplifier: an integer constant between two bounds becomes an unsigned
|
|
51
53
|
// bit-vector plus the lower bound.
|
|
52
54
|
const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
|
|
55
|
+
const state = new DependentExprState(manager, goal);
|
|
53
56
|
const bounds = new BoundManager(manager);
|
|
54
|
-
|
|
55
|
-
const substitution = new
|
|
57
|
+
state.forEachIndex((index) => collectBounds(manager, bounds, goal.forms.items[index]));
|
|
58
|
+
const substitution = new ExprSafeReplace(manager);
|
|
56
59
|
const trail = new RefVector(manager);
|
|
57
60
|
const sideConditions = new RefVector(manager);
|
|
58
61
|
const definitions: Definition[] = [];
|
|
@@ -77,7 +80,6 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
|
|
|
77
80
|
const replacement = offset.isZero()
|
|
78
81
|
? unsigned
|
|
79
82
|
: manager.mkApp(OP_ADD, [unsigned, manager.mkNumeral(offset.num)], SORT_INT);
|
|
80
|
-
trail.push(replacement);
|
|
81
83
|
definitions.push(
|
|
82
84
|
{ decl: manager.decls[bits], def: -1 },
|
|
83
85
|
{ decl: manager.decls[expr], def: replacement },
|
|
@@ -86,36 +88,118 @@ const runBoundedInt2Bv = (manager: AstManager, goal: Goal) => {
|
|
|
86
88
|
sideConditions.push(
|
|
87
89
|
mkBvApp(manager, OP_ULEQ, [bits, manager.mkBvNumeral(domainSize - 1n, numBits)]),
|
|
88
90
|
);
|
|
89
|
-
substitution.
|
|
91
|
+
substitution.insert(expr, replacement);
|
|
90
92
|
}
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
93
|
+
try {
|
|
94
|
+
if (substitution.sources.size > 0) {
|
|
95
|
+
const context = new Bv2IntContext(manager, UINT_MAX);
|
|
96
|
+
const rewriter = new Bv2IntRewriter(manager, context);
|
|
97
|
+
let replaced = -1;
|
|
98
|
+
let result = -1;
|
|
99
|
+
try {
|
|
100
|
+
state.forEachIndex((index) => {
|
|
101
|
+
const form = goal.forms.items[index];
|
|
102
|
+
const nextReplaced = substitution.apply(form);
|
|
103
|
+
release(manager, replaced);
|
|
104
|
+
replaced = nextReplaced;
|
|
105
|
+
const nextResult = rewriter.rewrite(replaced);
|
|
106
|
+
release(manager, result);
|
|
107
|
+
result = nextResult;
|
|
108
|
+
if (result !== form) goal.update(index, result);
|
|
109
|
+
});
|
|
110
|
+
} finally {
|
|
111
|
+
release(manager, result);
|
|
112
|
+
release(manager, replaced);
|
|
113
|
+
rewriter.release();
|
|
114
|
+
context.release();
|
|
115
|
+
}
|
|
102
116
|
}
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
117
|
+
for (const condition of sideConditions.items) goal.assert(condition);
|
|
118
|
+
if (definitions.length > 0) goal.addDefinitions(definitions);
|
|
119
|
+
} finally {
|
|
120
|
+
substitution.release();
|
|
121
|
+
sideConditions.reset();
|
|
122
|
+
trail.reset();
|
|
106
123
|
}
|
|
107
|
-
for (const condition of sideConditions.items) goal.assert(condition);
|
|
108
|
-
if (definitions.length > 0) goal.addDefinitions(definitions);
|
|
109
|
-
sideConditions.reset();
|
|
110
|
-
trail.reset();
|
|
111
124
|
};
|
|
112
125
|
|
|
126
|
+
class SolverFormulas extends Goal {
|
|
127
|
+
override assert(form: number) {
|
|
128
|
+
if (this.manager.isFalse(form)) this.isInconsistent = true;
|
|
129
|
+
this.forms.push(form);
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
override update(index: number, form: number) {
|
|
133
|
+
if (this.manager.isFalse(form)) this.isInconsistent = true;
|
|
134
|
+
this.forms.set(index, form);
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
flattenSuffix() {
|
|
138
|
+
const manager = this.manager;
|
|
139
|
+
const forms = this.forms;
|
|
140
|
+
const seen = new Set<number>();
|
|
141
|
+
const pinned = new RefVector(manager);
|
|
142
|
+
let kept = 0;
|
|
143
|
+
for (let index = 0; index < forms.size; index++) {
|
|
144
|
+
const form = forms.items[index];
|
|
145
|
+
pinned.push(form);
|
|
146
|
+
if (seen.has(form)) continue;
|
|
147
|
+
seen.add(form);
|
|
148
|
+
if (manager.isTrue(form)) continue;
|
|
149
|
+
if (manager.getOp(form) === OP_AND) {
|
|
150
|
+
const numArgs = manager.getNumArgs(form);
|
|
151
|
+
for (let argIndex = 0; argIndex < numArgs; argIndex++)
|
|
152
|
+
this.assert(manager.getArg(form, argIndex));
|
|
153
|
+
continue;
|
|
154
|
+
}
|
|
155
|
+
if (manager.isNot(form) && manager.getOp(manager.getArg(form, 0)) === OP_OR) {
|
|
156
|
+
const disjunction = manager.getArg(form, 0);
|
|
157
|
+
const numArgs = manager.getNumArgs(disjunction);
|
|
158
|
+
for (let argIndex = 0; argIndex < numArgs; argIndex++)
|
|
159
|
+
this.assert(mkNot(manager, manager.getArg(disjunction, argIndex)));
|
|
160
|
+
continue;
|
|
161
|
+
}
|
|
162
|
+
if (index !== kept) forms.set(kept, form);
|
|
163
|
+
kept++;
|
|
164
|
+
}
|
|
165
|
+
while (forms.size > kept) forms.pop();
|
|
166
|
+
pinned.reset();
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
|
|
113
170
|
const runFdSimplifier = (manager: AstManager, forms: readonly number[]) => {
|
|
114
|
-
const fmls = new
|
|
171
|
+
const fmls = new SolverFormulas(manager);
|
|
115
172
|
for (const form of forms) fmls.assert(form);
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
173
|
+
if (fmls.forms.size === 0) return fmls;
|
|
174
|
+
const state = new DependentExprState(manager, fmls);
|
|
175
|
+
const simplifiers = [
|
|
176
|
+
() => runBoundedInt2Bv(manager, fmls),
|
|
177
|
+
() => {
|
|
178
|
+
const simplifier = createCard2Bv(manager, getRewriterOptions(manager, new Map()))(state);
|
|
179
|
+
try {
|
|
180
|
+
simplifier.reduce();
|
|
181
|
+
} finally {
|
|
182
|
+
simplifier.release();
|
|
183
|
+
}
|
|
184
|
+
},
|
|
185
|
+
() => runEnum2Bv(manager, fmls, (visit) => state.forEachIndex(visit)),
|
|
186
|
+
];
|
|
187
|
+
try {
|
|
188
|
+
if (!fmls.isInconsistent && manager.limit.inc())
|
|
189
|
+
for (const simplify of simplifiers) {
|
|
190
|
+
if (fmls.isInconsistent || !manager.limit.inc()) break;
|
|
191
|
+
try {
|
|
192
|
+
simplify();
|
|
193
|
+
} catch (error) {
|
|
194
|
+
if (!(error instanceof SmtCanceledError)) throw error;
|
|
195
|
+
break;
|
|
196
|
+
}
|
|
197
|
+
fmls.flattenSuffix();
|
|
198
|
+
}
|
|
199
|
+
} finally {
|
|
200
|
+
state.release();
|
|
201
|
+
}
|
|
202
|
+
if (!manager.limit.inc()) fmls.reset();
|
|
119
203
|
return fmls;
|
|
120
204
|
};
|
|
121
205
|
|
|
@@ -176,7 +260,6 @@ export const getFdConsequences = (
|
|
|
176
260
|
const solver = new IncSatSolver(manager, params);
|
|
177
261
|
try {
|
|
178
262
|
for (const form of fmls.forms.items) solver.assertExpr(form);
|
|
179
|
-
if (fmls.isInconsistent) solver.assertExpr(manager.falseExpr);
|
|
180
263
|
const found = solver.getConsequences(asms1, queryVars);
|
|
181
264
|
const coreReplace = new ExprSafeReplace(manager);
|
|
182
265
|
asms1.forEach((assumption, index) => coreReplace.insert(assumption, assumptions[index]));
|
|
@@ -227,6 +310,8 @@ export const getFdConsequences = (
|
|
|
227
310
|
result: found.result,
|
|
228
311
|
consequences,
|
|
229
312
|
model: model === null ? undefined : convertModel(fmls, model),
|
|
313
|
+
core: solver.getUnsatCore().map((dep) => assumptions[asms1.indexOf(dep)] ?? dep),
|
|
314
|
+
reasonUnknown: solver.reasonUnknown,
|
|
230
315
|
};
|
|
231
316
|
} finally {
|
|
232
317
|
solver.release();
|
|
@@ -242,18 +327,16 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
|
|
|
242
327
|
const solver = new IncSatSolver(manager, params, false);
|
|
243
328
|
try {
|
|
244
329
|
for (const form of fmls.forms.items) solver.assertExpr(form);
|
|
245
|
-
const result =
|
|
330
|
+
const result = solver.check();
|
|
246
331
|
goal.reset();
|
|
247
332
|
if (result === L_TRUE) {
|
|
248
333
|
const model = solver.getModel();
|
|
249
|
-
model
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
goal.model = model;
|
|
253
|
-
}
|
|
334
|
+
const converted = model === null ? null : convertModel(fmls, model);
|
|
335
|
+
converted?.incRef();
|
|
336
|
+
if (converted !== null) goal.model = converted;
|
|
254
337
|
} else if (result === L_FALSE) goal.assert(manager.falseExpr);
|
|
255
338
|
else {
|
|
256
|
-
if (!manager.limit.inc()) throw new
|
|
339
|
+
if (!manager.limit.inc()) throw new SmtTacticError("canceled");
|
|
257
340
|
for (const form of solver.getAssertions()) goal.assert(form);
|
|
258
341
|
goal.converters = [...goal.converters, ...fmls.converters, ...solver.getConverters()];
|
|
259
342
|
}
|
|
@@ -263,3 +346,29 @@ export const createFdTactic = (manager: AstManager, params: SatParams) => (goal:
|
|
|
263
346
|
solver.release();
|
|
264
347
|
}
|
|
265
348
|
};
|
|
349
|
+
|
|
350
|
+
export const checkFdSolver = (manager: AstManager, params: SatParams, forms: readonly number[]) => {
|
|
351
|
+
const fmls = runFdSimplifier(manager, forms);
|
|
352
|
+
const solver = new IncSatSolver(manager, params);
|
|
353
|
+
const limit = manager.limit;
|
|
354
|
+
const wasSuspended = limit.isSuspended;
|
|
355
|
+
try {
|
|
356
|
+
for (const form of fmls.forms.items) solver.assertExpr(form);
|
|
357
|
+
const result = (() => {
|
|
358
|
+
try {
|
|
359
|
+
return solver.check();
|
|
360
|
+
} catch (error) {
|
|
361
|
+
if (!(error instanceof SmtCanceledError)) throw error;
|
|
362
|
+
return L_UNDEF;
|
|
363
|
+
}
|
|
364
|
+
})();
|
|
365
|
+
const model = result === L_TRUE ? solver.getModel() : null;
|
|
366
|
+
limit.isSuspended = true;
|
|
367
|
+
const converted = model === null ? undefined : convertModel(fmls, model);
|
|
368
|
+
converted?.incRef();
|
|
369
|
+
return { result, model: converted, reasonUnknown: solver.reasonUnknown };
|
|
370
|
+
} finally {
|
|
371
|
+
limit.isSuspended = wasSuspended;
|
|
372
|
+
solver.release();
|
|
373
|
+
}
|
|
374
|
+
};
|
|
@@ -97,8 +97,7 @@ class TargetFinder {
|
|
|
97
97
|
if (this.isArithApp(expr)) return this.processArith(expr, false);
|
|
98
98
|
this.todo.push(expr);
|
|
99
99
|
this.visited.add(expr);
|
|
100
|
-
|
|
101
|
-
const current = this.todo.pop() as number;
|
|
100
|
+
for (let current = this.todo.pop(); current !== undefined; current = this.todo.pop()) {
|
|
102
101
|
const isProcessed =
|
|
103
102
|
manager.kinds[current] !== KIND_APP
|
|
104
103
|
? false
|