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
|
@@ -3,6 +3,7 @@ import {
|
|
|
3
3
|
isStackOverflow,
|
|
4
4
|
SmtCanceledError,
|
|
5
5
|
SmtParseError,
|
|
6
|
+
SmtDefaultError,
|
|
6
7
|
SmtTacticError,
|
|
7
8
|
SmtUnsupportedError,
|
|
8
9
|
} from "../../../errors";
|
|
@@ -38,19 +39,23 @@ import {
|
|
|
38
39
|
createCommandReader,
|
|
39
40
|
createSmtlibReader,
|
|
40
41
|
DECLARATIONS,
|
|
42
|
+
expectClosed,
|
|
41
43
|
isSymbol,
|
|
44
|
+
isUnsigned,
|
|
42
45
|
type SExpr,
|
|
43
46
|
type SmtList,
|
|
44
47
|
type SmtlibReader,
|
|
48
|
+
type SmtToken,
|
|
45
49
|
} from "./smtlib-parser";
|
|
46
50
|
import { O_MAXIMIZE, O_MAXSMT, O_MINIMIZE, OptContext, type OptObjective } from "./opt-context";
|
|
47
51
|
import { getLogicStrategy } from "./logic-tactics";
|
|
48
52
|
import { isMbqiByFeatures, isMbqiByLogic } from "./smt-setup";
|
|
49
|
-
import { isSupportedLogic } from "./smt-logics";
|
|
53
|
+
import { isSupportedLogic, logicHasSeq } from "./smt-logics";
|
|
50
54
|
import { getVerdict, solveAssertions, solveAssuming } from "./solver";
|
|
51
55
|
import { getConsequences } from "./smt-consequences";
|
|
52
56
|
import { getFdConsequences } from "./fd-solver";
|
|
53
57
|
import { SmtKernel } from "./smt-kernel";
|
|
58
|
+
import { RefVector } from "./ref-vector";
|
|
54
59
|
import { IncSatSolver } from "./sat/inc-sat-solver";
|
|
55
60
|
import { mkThSolver } from "./euf/th-solvers";
|
|
56
61
|
import { isAstLess } from "./ast-lt";
|
|
@@ -61,6 +66,7 @@ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
|
61
66
|
import type { DatalogContext } from "./muz/dl-context";
|
|
62
67
|
import { createDatalogContext } from "./muz/horn-tactic";
|
|
63
68
|
import { printModel } from "./model-printer";
|
|
69
|
+
import { ModelEvaluator } from "./model-evaluator";
|
|
64
70
|
import { FuncInterp, getManagerSomeValue, ProtoModel } from "./proto-model";
|
|
65
71
|
import {
|
|
66
72
|
applyTactic,
|
|
@@ -69,9 +75,61 @@ import {
|
|
|
69
75
|
compileTactic,
|
|
70
76
|
getRewriterOptions,
|
|
71
77
|
getSatParams,
|
|
78
|
+
getSmtTacticFailure,
|
|
72
79
|
type TacticParam,
|
|
73
80
|
} from "./tactic";
|
|
74
81
|
|
|
82
|
+
const UNPORTED_COMMANDS = new Set([
|
|
83
|
+
"assert-not",
|
|
84
|
+
"assume",
|
|
85
|
+
"dbg-bool-rewriter",
|
|
86
|
+
"dbg-elim-and",
|
|
87
|
+
"dbg-get-qbody",
|
|
88
|
+
"dbg-params",
|
|
89
|
+
"dbg-pp-var",
|
|
90
|
+
"dbg-set",
|
|
91
|
+
"dbg-set-next-id",
|
|
92
|
+
"dbg-sexpr",
|
|
93
|
+
"dbg-shift-vars",
|
|
94
|
+
"dbg-size",
|
|
95
|
+
"dbg-subst",
|
|
96
|
+
"dbg-th-rewriter",
|
|
97
|
+
"dbg-translator",
|
|
98
|
+
"declare-map",
|
|
99
|
+
"declare-tactic",
|
|
100
|
+
"declare-type-var",
|
|
101
|
+
"del",
|
|
102
|
+
"display-dimacs",
|
|
103
|
+
"euf-project",
|
|
104
|
+
"eufi",
|
|
105
|
+
"ff-boolean-certify",
|
|
106
|
+
"ff-certify",
|
|
107
|
+
"ff-check-native-proof",
|
|
108
|
+
"ff-integrated-certify",
|
|
109
|
+
"get-interpolant",
|
|
110
|
+
"get-proof",
|
|
111
|
+
"get-proof-graph",
|
|
112
|
+
"get-unsat-assumptions",
|
|
113
|
+
"get-user-tactics",
|
|
114
|
+
"help",
|
|
115
|
+
"help-simplifier",
|
|
116
|
+
"help-tactic",
|
|
117
|
+
"include",
|
|
118
|
+
"infer",
|
|
119
|
+
"labels",
|
|
120
|
+
"mbi",
|
|
121
|
+
"mbp",
|
|
122
|
+
"mbp-qel",
|
|
123
|
+
"model-add",
|
|
124
|
+
"model-del",
|
|
125
|
+
"prefer",
|
|
126
|
+
"qe-lite",
|
|
127
|
+
"qel",
|
|
128
|
+
"reset-preferences",
|
|
129
|
+
"set-initial-value",
|
|
130
|
+
"set-simplifier",
|
|
131
|
+
]);
|
|
132
|
+
|
|
75
133
|
const SILENT_COMMANDS = new Set([
|
|
76
134
|
...DECLARATIONS,
|
|
77
135
|
"assert",
|
|
@@ -81,8 +139,6 @@ const SILENT_COMMANDS = new Set([
|
|
|
81
139
|
"reset-assertions",
|
|
82
140
|
"set-option",
|
|
83
141
|
"set-info",
|
|
84
|
-
"minimize",
|
|
85
|
-
"maximize",
|
|
86
142
|
"assert-soft",
|
|
87
143
|
"declare-rel",
|
|
88
144
|
"declare-var",
|
|
@@ -121,6 +177,7 @@ const SIMPLIFY_PARAMETERS = new Set([
|
|
|
121
177
|
"som",
|
|
122
178
|
"sort_sums",
|
|
123
179
|
"arith_lhs",
|
|
180
|
+
"arith_ineq_lhs",
|
|
124
181
|
"gcd_rounding",
|
|
125
182
|
"hi_div0",
|
|
126
183
|
"mul2concat",
|
|
@@ -175,7 +232,9 @@ const getSoftParameters = (items: SExpr[]) => {
|
|
|
175
232
|
const parameters = { weight: Rational.one, id: null as string | null };
|
|
176
233
|
for (let index = 0; index < items.length; index += 2) {
|
|
177
234
|
const keyword = items[index];
|
|
178
|
-
|
|
235
|
+
if (keyword.kind !== "keyword")
|
|
236
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
237
|
+
const name = getParameterName(keyword.text);
|
|
179
238
|
const value = items[index + 1];
|
|
180
239
|
if (name === "weight" && (value?.kind === "numeral" || value?.kind === "decimal")) {
|
|
181
240
|
const [whole, fraction = ""] = value.text.split(".");
|
|
@@ -193,7 +252,9 @@ const getSimplifyParams = (items: SExpr[]) => {
|
|
|
193
252
|
const params = new Map<string, TacticParam>();
|
|
194
253
|
for (let index = 0; index < items.length; index += 2) {
|
|
195
254
|
const keyword = items[index];
|
|
196
|
-
|
|
255
|
+
if (keyword.kind !== "keyword")
|
|
256
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
257
|
+
const name = getParameterName(keyword.text);
|
|
197
258
|
const value = items[index + 1];
|
|
198
259
|
if (SIMPLIFY_UINT_PARAMETERS.has(name) && value?.kind === "numeral") {
|
|
199
260
|
params.set(name, Number(value.text));
|
|
@@ -245,12 +306,29 @@ const getCommandParams = (items: SExpr[], isBooleans: ReadonlyMap<string, boolea
|
|
|
245
306
|
"invalid command argument, unsigned integer expected",
|
|
246
307
|
value ?? keyword,
|
|
247
308
|
);
|
|
309
|
+
if (!isUnsigned(value.text))
|
|
310
|
+
throw new SmtParseError(
|
|
311
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
312
|
+
value,
|
|
313
|
+
);
|
|
248
314
|
params.set(name, Number(value.text));
|
|
249
315
|
}
|
|
250
316
|
}
|
|
251
317
|
return params;
|
|
252
318
|
};
|
|
253
319
|
|
|
320
|
+
const getFirstArgument = (list: SmtList) => {
|
|
321
|
+
const argument = list.items[1];
|
|
322
|
+
if (argument === undefined)
|
|
323
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
324
|
+
return argument;
|
|
325
|
+
};
|
|
326
|
+
|
|
327
|
+
const checkArgumentCount = (list: SmtList, count: number) => {
|
|
328
|
+
const extra = list.items[count + 1];
|
|
329
|
+
if (extra !== undefined) throw new SmtParseError("invalid command, too many arguments", extra);
|
|
330
|
+
};
|
|
331
|
+
|
|
254
332
|
// Z3's parse_opt_unsigned names the push command for pop as well.
|
|
255
333
|
const getScopeCount = (list: SmtList) => {
|
|
256
334
|
const argument = list.items[1];
|
|
@@ -272,12 +350,19 @@ interface CheckResult {
|
|
|
272
350
|
status: number;
|
|
273
351
|
context: Context | undefined;
|
|
274
352
|
isOptimizing: boolean;
|
|
353
|
+
isFromTactic: boolean;
|
|
275
354
|
model: ProtoModel | undefined;
|
|
276
355
|
core: number[] | undefined;
|
|
277
356
|
// check_sat_result::reason_unknown, where the port tracks it.
|
|
278
357
|
reasonUnknown?: string;
|
|
279
358
|
}
|
|
280
359
|
|
|
360
|
+
interface SolverAnswer {
|
|
361
|
+
result: number;
|
|
362
|
+
context: Context | undefined;
|
|
363
|
+
reasonUnknown: string | undefined;
|
|
364
|
+
}
|
|
365
|
+
|
|
281
366
|
interface ScriptState {
|
|
282
367
|
manager: AstManager;
|
|
283
368
|
logic: string | undefined;
|
|
@@ -299,9 +384,7 @@ interface ScriptState {
|
|
|
299
384
|
// combined_solver's incremental smt kernel, which keeps one context across the checks, or
|
|
300
385
|
// undefined while Z3 has made no such kernel.
|
|
301
386
|
kernel: SmtKernel | undefined;
|
|
302
|
-
|
|
303
|
-
// an unported theory and the smt kernel answers in its place.
|
|
304
|
-
eufSolver: IncSatSolver | undefined;
|
|
387
|
+
satSolver: IncSatSolver | undefined;
|
|
305
388
|
}
|
|
306
389
|
|
|
307
390
|
// Z3 fixes the proof mode at the first command that needs terms.
|
|
@@ -311,6 +394,7 @@ const MANAGERLESS_COMMANDS = new Set([
|
|
|
311
394
|
"set-logic",
|
|
312
395
|
"get-option",
|
|
313
396
|
"get-info",
|
|
397
|
+
"get-assertions",
|
|
314
398
|
"echo",
|
|
315
399
|
]);
|
|
316
400
|
|
|
@@ -343,11 +427,11 @@ export const runSmtlibScript = (
|
|
|
343
427
|
rlimit: 0,
|
|
344
428
|
printOptions: { ...DEFAULT_PRINT_OPTIONS },
|
|
345
429
|
parserOptions: { isIgnoringBadPatterns: true },
|
|
430
|
+
// Z3 keeps set-info's :status across reset.
|
|
431
|
+
status: L_UNDEF,
|
|
346
432
|
};
|
|
347
433
|
const createState = (): ScriptState => {
|
|
348
|
-
const manager = new AstManager(
|
|
349
|
-
new ResourceLimit(Date.now() + options.timeLimitMs, options.signal),
|
|
350
|
-
);
|
|
434
|
+
const manager = new AstManager(new ResourceLimit(Infinity, options.signal));
|
|
351
435
|
manager.isHiDiv0 = settings.isHiDiv0;
|
|
352
436
|
manager.maxChar = settings.encoding.maxChar;
|
|
353
437
|
manager.charBits = settings.encoding.charBits;
|
|
@@ -368,7 +452,7 @@ export const runSmtlibScript = (
|
|
|
368
452
|
hasChecked: false,
|
|
369
453
|
datalog: undefined,
|
|
370
454
|
kernel: undefined,
|
|
371
|
-
|
|
455
|
+
satSolver: undefined,
|
|
372
456
|
};
|
|
373
457
|
};
|
|
374
458
|
let state = createState();
|
|
@@ -409,7 +493,7 @@ export const runSmtlibScript = (
|
|
|
409
493
|
paretoMaxLemmas: Number(parameters.get("opt.pareto_nlsat_max_lemmas") ?? 128),
|
|
410
494
|
};
|
|
411
495
|
};
|
|
412
|
-
const optimize = (extra: number[]) => {
|
|
496
|
+
const optimize = (extra: number[], end: SmtToken) => {
|
|
413
497
|
const manager = state.manager;
|
|
414
498
|
const objectives = state.objectives;
|
|
415
499
|
const hard = [...getNamedAssertions(), ...state.names.filter((name) => name !== -1), ...extra];
|
|
@@ -452,7 +536,11 @@ export const runSmtlibScript = (
|
|
|
452
536
|
!hasAssumptions &&
|
|
453
537
|
settings.parameters.get("opt.incremental") !== "true",
|
|
454
538
|
});
|
|
455
|
-
setCheck(status, {
|
|
539
|
+
setCheck(status, {
|
|
540
|
+
isOptimizing: true,
|
|
541
|
+
model: optimizer.model ?? undefined,
|
|
542
|
+
reasonUnknown: optimizer.getReasonUnknown(),
|
|
543
|
+
});
|
|
456
544
|
print(getVerdict(status));
|
|
457
545
|
return true;
|
|
458
546
|
} catch (error) {
|
|
@@ -461,9 +549,14 @@ export const runSmtlibScript = (
|
|
|
461
549
|
resetOptimizer();
|
|
462
550
|
return false;
|
|
463
551
|
}
|
|
552
|
+
if (error instanceof SmtDefaultError) {
|
|
553
|
+
setCheck(L_UNDEF, { isFromTactic: true, reasonUnknown: "unknown" });
|
|
554
|
+
throw new SmtParseError(error.message, end);
|
|
555
|
+
}
|
|
464
556
|
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
557
|
+
const reasonUnknown = optimizer.getReasonUnknown();
|
|
465
558
|
optimizer.release();
|
|
466
|
-
setCheck(L_UNDEF, { isOptimizing: true });
|
|
559
|
+
setCheck(L_UNDEF, { isOptimizing: true, reasonUnknown });
|
|
467
560
|
print("unknown");
|
|
468
561
|
return true;
|
|
469
562
|
} finally {
|
|
@@ -483,27 +576,56 @@ export const runSmtlibScript = (
|
|
|
483
576
|
getLogicStrategy(state.logic, goal.isProofsEnabled);
|
|
484
577
|
try {
|
|
485
578
|
const checked = checkSatUsing(compileInternalTactic(getTacticEnvironment(), strategy), goal);
|
|
486
|
-
return {
|
|
579
|
+
return {
|
|
580
|
+
result: checked.status,
|
|
581
|
+
context: undefined,
|
|
582
|
+
model: checked.model,
|
|
583
|
+
// The finite-domain solver is an inc_sat_solver, whose reason stays "no reason given" after an answer.
|
|
584
|
+
reasonUnknown:
|
|
585
|
+
isUsingFdSolver() && checked.status !== L_UNDEF
|
|
586
|
+
? "no reason given"
|
|
587
|
+
: checked.reasonUnknown,
|
|
588
|
+
};
|
|
487
589
|
} catch (error) {
|
|
488
590
|
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
489
591
|
const hasQuantifiers = state.assertions.some(
|
|
490
592
|
(assertion) => state.manager.hasQuantifierFlags[assertion],
|
|
491
593
|
);
|
|
594
|
+
const solved = solveAssertions(state.manager, state.assertions, {
|
|
595
|
+
isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
|
|
596
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
597
|
+
isFindingMacros: settings.isFindingMacros,
|
|
598
|
+
setup: getSetup(),
|
|
599
|
+
});
|
|
492
600
|
return {
|
|
493
|
-
...
|
|
494
|
-
isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
|
|
495
|
-
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
496
|
-
isFindingMacros: settings.isFindingMacros,
|
|
497
|
-
setup: getSetup(),
|
|
498
|
-
}),
|
|
601
|
+
...solved,
|
|
499
602
|
model: undefined,
|
|
603
|
+
reasonUnknown:
|
|
604
|
+
solved.result === L_UNDEF && solved.context !== undefined
|
|
605
|
+
? getSmtTacticFailure(solved.context)
|
|
606
|
+
: "",
|
|
500
607
|
};
|
|
501
608
|
}
|
|
502
609
|
};
|
|
503
|
-
|
|
504
|
-
|
|
610
|
+
// Deviation from Z3: the heap guard and a stack overflow, which Z3 lacks, read as an exhausted rlimit.
|
|
611
|
+
const getCancelMessage = (deadline: number) =>
|
|
612
|
+
Date.now() > deadline || options.signal?.aborted === true
|
|
613
|
+
? "canceled"
|
|
614
|
+
: "max. resource limit exceeded";
|
|
615
|
+
// As in Z3, a timeout leaves "timeout" in the kernel, which reports it while its last search hasn't failed.
|
|
616
|
+
const getReasonUnknown = (solved: SolverAnswer, deadline: number) => {
|
|
617
|
+
const isTimedOut = solved.result === L_UNDEF && Date.now() > deadline;
|
|
618
|
+
const context = state.kernel?.context;
|
|
619
|
+
if (isTimedOut && context !== undefined) context.reasonUnknown = "timeout";
|
|
620
|
+
if (context !== undefined && solved.context === context) return context.getLastFailureMessage();
|
|
621
|
+
return isTimedOut ? "timeout" : (solved.reasonUnknown ?? getCancelMessage(deadline));
|
|
622
|
+
};
|
|
623
|
+
// As in Z3, a kernel loses the mbqi its logic turned on once it reads the parameters again.
|
|
624
|
+
const getKernelParams = (isSetUp = false) => ({
|
|
625
|
+
isMbqi: settings.isMbqi || (!isSetUp && isMbqiByLogic(getSetup())),
|
|
505
626
|
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
506
627
|
isFindingMacros: settings.isFindingMacros,
|
|
628
|
+
isCoreMinimizing: settings.parameters.get("smt.core.minimize") === "true",
|
|
507
629
|
setup: getSetup(),
|
|
508
630
|
});
|
|
509
631
|
// mk_special_solver_for_logic gives these logics the finite-domain solver, incremental or not.
|
|
@@ -511,45 +633,60 @@ export const runSmtlibScript = (
|
|
|
511
633
|
(state.logic === "QF_FD" || state.logic === "SAT") &&
|
|
512
634
|
!settings.isProducingProofs &&
|
|
513
635
|
!settings.parameters.has("tactic.default_tactic");
|
|
514
|
-
const checkSat = (extra: number[]) => {
|
|
515
|
-
|
|
636
|
+
const checkSat = (extra: number[], end: SmtToken) => {
|
|
637
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
638
|
+
state.manager.limit.restart(deadline);
|
|
516
639
|
// opt::context::optimize answers as the search of the hard constraints does: once they are
|
|
517
640
|
// satisfiable, optsmt and maxsmt only improve the model. The unported parts of optimization
|
|
518
641
|
// only get that answer.
|
|
519
|
-
if (state.objectives.length > 0 && optimize(extra)) return;
|
|
642
|
+
if (state.objectives.length > 0 && optimize(extra, end)) return;
|
|
520
643
|
state.manager.limit.push(settings.rlimit);
|
|
521
644
|
const isOptimizing = state.objectives.length > 0;
|
|
645
|
+
const manager = state.manager;
|
|
646
|
+
const names = state.names.filter((name) => name !== -1);
|
|
647
|
+
const isNamed = names.length > 0;
|
|
648
|
+
const isAssuming = isNamed || extra.length > 0;
|
|
649
|
+
if (isAssuming) state.isIncremental = true;
|
|
650
|
+
if (!isOptimizing) state.hasChecked = true;
|
|
651
|
+
const isKernelChecking =
|
|
652
|
+
isAssuming || (state.isIncremental && !isOptimizing && !isUsingFdSolver());
|
|
522
653
|
try {
|
|
523
|
-
const
|
|
524
|
-
const names = state.names.filter((name) => name !== -1);
|
|
525
|
-
const isNamed = names.length > 0;
|
|
526
|
-
const isAssuming = isNamed || extra.length > 0;
|
|
527
|
-
if (isAssuming) state.isIncremental = true;
|
|
528
|
-
if (!isOptimizing) state.hasChecked = true;
|
|
529
|
-
const assumptions = isNamed ? [...names, ...extra] : extra;
|
|
530
|
-
const kernel =
|
|
531
|
-
isAssuming || (state.isIncremental && !isOptimizing && !isUsingFdSolver())
|
|
532
|
-
? checkKernel(assumptions)
|
|
533
|
-
: undefined;
|
|
654
|
+
const kernel = isKernelChecking ? checkKernel(names, extra) : undefined;
|
|
534
655
|
// Z3 retries a quantifier-free problem with its tactic when the incremental kernel gives up.
|
|
535
|
-
const
|
|
656
|
+
const isFromTactic =
|
|
536
657
|
kernel === undefined ||
|
|
537
658
|
(!isAssuming &&
|
|
538
659
|
kernel.result === L_UNDEF &&
|
|
539
660
|
!state.assertions.some((assertion) => manager.hasQuantifierFlags[assertion]) &&
|
|
540
|
-
manager.limit.inc())
|
|
541
|
-
|
|
542
|
-
: kernel;
|
|
661
|
+
manager.limit.inc());
|
|
662
|
+
const solved = isFromTactic ? { ...solveWithStrategy(), core: undefined } : kernel;
|
|
543
663
|
setCheck(solved.result, {
|
|
544
664
|
context: solved.context,
|
|
545
665
|
isOptimizing,
|
|
666
|
+
isFromTactic: isFromTactic && !isUsingFdSolver(),
|
|
546
667
|
model: solved.model,
|
|
547
668
|
core: solved.core ?? solved.context?.unsatCore ?? [],
|
|
669
|
+
reasonUnknown: getReasonUnknown(solved, deadline),
|
|
548
670
|
});
|
|
549
671
|
print(getVerdict(solved.result));
|
|
550
672
|
} catch (error) {
|
|
551
|
-
if (
|
|
552
|
-
|
|
673
|
+
if (
|
|
674
|
+
!(
|
|
675
|
+
error instanceof SmtCanceledError ||
|
|
676
|
+
error instanceof SmtDefaultError ||
|
|
677
|
+
isStackOverflow(error)
|
|
678
|
+
)
|
|
679
|
+
)
|
|
680
|
+
throw error;
|
|
681
|
+
const context = isKernelChecking ? state.kernel?.context : undefined;
|
|
682
|
+
setCheck(L_UNDEF, {
|
|
683
|
+
isOptimizing,
|
|
684
|
+
isFromTactic: !isKernelChecking && !isUsingFdSolver(),
|
|
685
|
+
reasonUnknown:
|
|
686
|
+
error instanceof SmtDefaultError
|
|
687
|
+
? error.message
|
|
688
|
+
: getReasonUnknown({ result: L_UNDEF, context, reasonUnknown: undefined }, deadline),
|
|
689
|
+
});
|
|
553
690
|
print("unknown");
|
|
554
691
|
} finally {
|
|
555
692
|
state.manager.limit.release();
|
|
@@ -563,7 +700,9 @@ export const runSmtlibScript = (
|
|
|
563
700
|
if (check.model !== undefined) return check.model;
|
|
564
701
|
if (check.isOptimizing) throw new SmtUnsupportedError("the models of optimization");
|
|
565
702
|
if (check.context === undefined && check.status !== L_TRUE)
|
|
566
|
-
throw
|
|
703
|
+
throw check.isFromTactic
|
|
704
|
+
? new SmtParseError("model is not available", list.end)
|
|
705
|
+
: new SmtUnsupportedError("the model of a canceled search");
|
|
567
706
|
const model = check.context?.getModel() ?? new ProtoModel(state.manager);
|
|
568
707
|
model.incRef();
|
|
569
708
|
check.model = model;
|
|
@@ -573,6 +712,12 @@ export const runSmtlibScript = (
|
|
|
573
712
|
state.check?.model?.decRef();
|
|
574
713
|
state.check = undefined;
|
|
575
714
|
};
|
|
715
|
+
// cmd_context::validate_check_sat_result runs after the answer is printed.
|
|
716
|
+
const validateCheck = (end: SmtToken) => {
|
|
717
|
+
const status = state.check?.status ?? L_UNDEF;
|
|
718
|
+
if (status !== L_UNDEF && settings.status !== L_UNDEF && status !== settings.status)
|
|
719
|
+
throw new SmtParseError(`check annotation that says ${getVerdict(settings.status)}`, end);
|
|
720
|
+
};
|
|
576
721
|
// The check holds a reference to its model until clearCheck.
|
|
577
722
|
const setCheck = (status: number, result: Partial<Omit<CheckResult, "status">> = {}) => {
|
|
578
723
|
result.model?.incRef();
|
|
@@ -580,14 +725,12 @@ export const runSmtlibScript = (
|
|
|
580
725
|
status,
|
|
581
726
|
context: undefined,
|
|
582
727
|
isOptimizing: false,
|
|
728
|
+
isFromTactic: false,
|
|
583
729
|
model: undefined,
|
|
584
730
|
core: undefined,
|
|
585
731
|
...result,
|
|
586
732
|
};
|
|
587
733
|
};
|
|
588
|
-
// cmd_context::mk_solver: mk_solver_for_logic makes the incremental solver the smt kernel unless
|
|
589
|
-
// the logic, the default tactic or the sat parameters pick a sat solver. Under sat.euf that
|
|
590
|
-
// solver is inc_sat_solver in euf mode; the other sat solvers only store their assertions.
|
|
591
734
|
const resetKernel = () => {
|
|
592
735
|
const logic = state.logic;
|
|
593
736
|
const parameters = settings.parameters;
|
|
@@ -601,48 +744,54 @@ export const runSmtlibScript = (
|
|
|
601
744
|
parameters.get("tactic.default_tactic") === "sat" ||
|
|
602
745
|
parameters.get("sat.smt") === "true" ||
|
|
603
746
|
isEuf;
|
|
604
|
-
state.
|
|
747
|
+
state.satSolver?.release();
|
|
605
748
|
state.kernel = isSatSolver ? undefined : new SmtKernel(state.manager, getKernelParams());
|
|
606
|
-
state.
|
|
607
|
-
|
|
608
|
-
? new IncSatSolver(state.manager, getSatParams(parameters), true, mkThSolver)
|
|
749
|
+
state.satSolver =
|
|
750
|
+
isSatSolver && !isFdSolver && parameters.get("sat.smt") !== "true"
|
|
751
|
+
? new IncSatSolver(state.manager, getSatParams(parameters), true, isEuf ? mkThSolver : null)
|
|
609
752
|
: undefined;
|
|
610
753
|
for (let index = 0; index < state.scopes.length; index++) {
|
|
611
754
|
state.kernel?.push();
|
|
612
|
-
|
|
755
|
+
useSatSolver((solver) => solver.push());
|
|
613
756
|
}
|
|
614
757
|
};
|
|
615
|
-
// The parts of
|
|
616
|
-
const
|
|
617
|
-
const solver = state.
|
|
758
|
+
// The parts of inc_sat_solver that are not ported leave its answers to the smt kernel.
|
|
759
|
+
const useSatSolver = <Result>(action: (solver: IncSatSolver) => Result) => {
|
|
760
|
+
const solver = state.satSolver;
|
|
618
761
|
if (solver === undefined) return undefined;
|
|
619
762
|
try {
|
|
620
763
|
return action(solver);
|
|
621
764
|
} catch (error) {
|
|
622
765
|
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
623
766
|
solver.release();
|
|
624
|
-
state.
|
|
767
|
+
state.satSolver = undefined;
|
|
625
768
|
return undefined;
|
|
626
769
|
}
|
|
627
770
|
};
|
|
628
771
|
// solver_na2as asserts a named assertion as an implication from its name.
|
|
629
772
|
const assertInKernel = (formula: number, name: number) => {
|
|
630
773
|
const manager = state.manager;
|
|
774
|
+
useSatSolver((solver) =>
|
|
775
|
+
name === -1 ? solver.assertExpr(formula) : solver.assertNamed(formula, name),
|
|
776
|
+
);
|
|
777
|
+
const kernel = state.kernel;
|
|
778
|
+
if (kernel === undefined) return;
|
|
631
779
|
const asserted = name === -1 ? formula : manager.mkApp(OP_IMPLIES, [name, formula], SORT_BOOL);
|
|
632
780
|
manager.incRef(asserted);
|
|
633
|
-
|
|
634
|
-
useEufSolver((solver) => solver.assertExpr(asserted));
|
|
781
|
+
kernel.assertExpr(asserted);
|
|
635
782
|
manager.decRef(asserted);
|
|
636
783
|
};
|
|
637
|
-
const checkKernel = (
|
|
784
|
+
const checkKernel = (names: number[], extra: number[]) => {
|
|
638
785
|
const kernel = state.kernel;
|
|
639
|
-
const
|
|
640
|
-
|
|
786
|
+
const assumptions = [...names, ...extra];
|
|
787
|
+
const found = useSatSolver((solver) => {
|
|
788
|
+
const result = solver.check(extra);
|
|
641
789
|
return {
|
|
642
790
|
result,
|
|
643
791
|
context: undefined,
|
|
644
792
|
model: result === L_TRUE ? (solver.getModel() ?? undefined) : undefined,
|
|
645
793
|
core: result === L_FALSE ? [...solver.getUnsatCore()] : undefined,
|
|
794
|
+
reasonUnknown: solver.reasonUnknown,
|
|
646
795
|
};
|
|
647
796
|
});
|
|
648
797
|
if (found !== undefined) return found;
|
|
@@ -652,11 +801,21 @@ export const runSmtlibScript = (
|
|
|
652
801
|
context: kernel.context,
|
|
653
802
|
model: undefined,
|
|
654
803
|
core: undefined,
|
|
804
|
+
reasonUnknown: undefined,
|
|
655
805
|
};
|
|
806
|
+
const solved = solveAssuming(
|
|
807
|
+
state.manager,
|
|
808
|
+
getNamedAssertions(),
|
|
809
|
+
assumptions,
|
|
810
|
+
getKernelParams(),
|
|
811
|
+
);
|
|
656
812
|
return {
|
|
657
|
-
...
|
|
813
|
+
...solved,
|
|
658
814
|
model: undefined,
|
|
659
815
|
core: undefined,
|
|
816
|
+
// inc_sat_solver, which these logics use, keeps "no reason given" after an answer.
|
|
817
|
+
reasonUnknown:
|
|
818
|
+
solved.result === L_UNDEF ? solved.context.getLastFailureMessage() : "no reason given",
|
|
660
819
|
};
|
|
661
820
|
};
|
|
662
821
|
const printDiagnostic = (line: string) => print(line, !settings.isDiagnosticOnStdout);
|
|
@@ -690,11 +849,10 @@ export const runSmtlibScript = (
|
|
|
690
849
|
);
|
|
691
850
|
return state.datalog;
|
|
692
851
|
};
|
|
693
|
-
const getTactic = (sexpr: SExpr, end: SmtList["end"]) =>
|
|
694
|
-
compileTactic(getTacticEnvironment(), sexpr, end);
|
|
695
852
|
const getGoal = (isTrackingDependencies = false) => {
|
|
696
853
|
const goal = new Goal(state.manager);
|
|
697
854
|
goal.isProofsEnabled = settings.isProducingProofs || state.isProofsEnabled === true;
|
|
855
|
+
goal.isModelsEnabled = settings.isProducingModels;
|
|
698
856
|
goal.isCoresEnabled = settings.isProducingUnsatCores;
|
|
699
857
|
for (const [index, assertion] of state.assertions.entries())
|
|
700
858
|
goal.assert(
|
|
@@ -705,22 +863,43 @@ export const runSmtlibScript = (
|
|
|
705
863
|
);
|
|
706
864
|
return goal;
|
|
707
865
|
};
|
|
866
|
+
const getCommandGoal = (isTrackingDependencies: boolean, end: SmtToken) => {
|
|
867
|
+
if (
|
|
868
|
+
settings.isProducingUnsatCores &&
|
|
869
|
+
(settings.isProducingProofs || state.isProofsEnabled === true)
|
|
870
|
+
)
|
|
871
|
+
throw new SmtParseError(
|
|
872
|
+
"Frontend does not support simultaneous generation of proofs and unsat cores",
|
|
873
|
+
end,
|
|
874
|
+
);
|
|
875
|
+
return getGoal(isTrackingDependencies);
|
|
876
|
+
};
|
|
708
877
|
const hasNames = () => state.names.some((name) => name !== -1);
|
|
709
878
|
// parse_check_sat shrinks the expression stack once the check has run.
|
|
710
|
-
const checkSatAssuming = (items: SmtList["items"]) => {
|
|
879
|
+
const checkSatAssuming = (items: SmtList["items"], itemsEnd: SmtToken, end: SmtToken) => {
|
|
711
880
|
const literals: number[] = [];
|
|
712
881
|
try {
|
|
713
|
-
for (const item of items
|
|
714
|
-
|
|
882
|
+
for (const [index, item] of items.entries())
|
|
883
|
+
literals.push(
|
|
884
|
+
state.reader.parseFormula(
|
|
885
|
+
item,
|
|
886
|
+
items[index + 1] ?? itemsEnd,
|
|
887
|
+
"invalid check-sat command, argument must be a Boolean literal",
|
|
888
|
+
),
|
|
889
|
+
);
|
|
890
|
+
checkSat(literals, end);
|
|
715
891
|
} finally {
|
|
716
892
|
for (const literal of literals) state.manager.decRef(literal);
|
|
717
893
|
}
|
|
718
894
|
};
|
|
719
895
|
const addObjective = (list: SmtList, isMax: boolean) => {
|
|
720
|
-
const term = state.reader.parseTerm(list
|
|
896
|
+
const term = state.reader.parseTerm(getFirstArgument(list));
|
|
721
897
|
const sort = state.manager.sorts[term];
|
|
722
898
|
if (sort !== SORT_INT && sort !== SORT_REAL && !state.manager.isBvSort(sort))
|
|
723
|
-
throw new SmtParseError(
|
|
899
|
+
throw new SmtParseError(
|
|
900
|
+
"Objective must be bit-vector, integer or real",
|
|
901
|
+
list.items[2] ?? list.end,
|
|
902
|
+
);
|
|
724
903
|
resetOptimizer();
|
|
725
904
|
state.manager.incRef(term);
|
|
726
905
|
state.objectives.push({
|
|
@@ -730,6 +909,8 @@ export const runSmtlibScript = (
|
|
|
730
909
|
weights: [],
|
|
731
910
|
id: null,
|
|
732
911
|
});
|
|
912
|
+
if (settings.isPrintingSuccess) print("success");
|
|
913
|
+
checkArgumentCount(list, 1);
|
|
733
914
|
};
|
|
734
915
|
const releaseObjectives = (size: number, softSize: number) => {
|
|
735
916
|
for (const index of state.softTrail.splice(softSize).reverse()) {
|
|
@@ -798,14 +979,14 @@ export const runSmtlibScript = (
|
|
|
798
979
|
if (name.kind === "list")
|
|
799
980
|
throw new SmtUnsupportedError("an indexed function declaration reference");
|
|
800
981
|
throw new SmtParseError(
|
|
801
|
-
|
|
982
|
+
`invalid function declaration reference, symbol or '(' expected got ${name.lastId}`,
|
|
802
983
|
name,
|
|
803
984
|
);
|
|
804
985
|
}
|
|
805
986
|
const domain = reference.items[1] ?? reference.end;
|
|
806
987
|
if (domain.kind !== "list")
|
|
807
988
|
throw new SmtParseError(
|
|
808
|
-
`Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.
|
|
989
|
+
`Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.lastId}`,
|
|
809
990
|
domain,
|
|
810
991
|
);
|
|
811
992
|
const sorts = domain.items.map((sort) => state.reader.parseSort(sort));
|
|
@@ -835,11 +1016,12 @@ export const runSmtlibScript = (
|
|
|
835
1016
|
"assert",
|
|
836
1017
|
(list) => {
|
|
837
1018
|
const term = list.items[1] ?? list.end;
|
|
838
|
-
const
|
|
1019
|
+
const follower = list.items[2] ?? list.end;
|
|
1020
|
+
const assertion = state.reader.parseAssertion(term, follower);
|
|
839
1021
|
const logicError = state.reader.getLogicError(assertion.formula);
|
|
840
1022
|
if (logicError !== undefined) {
|
|
841
1023
|
state.manager.decRef(assertion.formula);
|
|
842
|
-
throw new SmtParseError(logicError,
|
|
1024
|
+
throw new SmtParseError(logicError, follower);
|
|
843
1025
|
}
|
|
844
1026
|
state.assertions.push(assertion.formula);
|
|
845
1027
|
state.assertionTexts.push(
|
|
@@ -860,9 +1042,17 @@ export const runSmtlibScript = (
|
|
|
860
1042
|
}
|
|
861
1043
|
assertInKernel(assertion.formula, state.names[state.names.length - 1]);
|
|
862
1044
|
clearCheck();
|
|
1045
|
+
if (follower !== list.end)
|
|
1046
|
+
throw new SmtParseError("invalid assert command, ')' expected", follower);
|
|
1047
|
+
},
|
|
1048
|
+
],
|
|
1049
|
+
[
|
|
1050
|
+
"check-sat",
|
|
1051
|
+
(list) => {
|
|
1052
|
+
checkSatAssuming(list.items.slice(1), list.end, list.end);
|
|
1053
|
+
validateCheck(list.end);
|
|
863
1054
|
},
|
|
864
1055
|
],
|
|
865
|
-
["check-sat", (list) => checkSatAssuming(list.items.slice(1))],
|
|
866
1056
|
[
|
|
867
1057
|
"declare-rel",
|
|
868
1058
|
(list) => {
|
|
@@ -902,7 +1092,10 @@ export const runSmtlibScript = (
|
|
|
902
1092
|
const rule = list.items[1];
|
|
903
1093
|
if (rule === undefined) throw new SmtParseError("invalid rule, expected formula", list.end);
|
|
904
1094
|
const name = list.items[2];
|
|
905
|
-
getDatalog().addRule(
|
|
1095
|
+
getDatalog().addRule(
|
|
1096
|
+
state.reader.parseFormula(rule, rule),
|
|
1097
|
+
isSymbol(name) ? name.text : "",
|
|
1098
|
+
);
|
|
906
1099
|
},
|
|
907
1100
|
],
|
|
908
1101
|
[
|
|
@@ -924,15 +1117,17 @@ export const runSmtlibScript = (
|
|
|
924
1117
|
for (const assertion of state.assertions) datalog.assertExpr(assertion);
|
|
925
1118
|
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
926
1119
|
state.manager.limit.push(settings.rlimit);
|
|
1120
|
+
let status = L_UNDEF;
|
|
927
1121
|
try {
|
|
928
|
-
|
|
1122
|
+
status = datalog.relQuery(relation);
|
|
929
1123
|
} catch (error) {
|
|
930
1124
|
if (!(error instanceof SmtTacticError)) throw error;
|
|
931
1125
|
print(`(error "query failed: ${error.message}")`);
|
|
932
|
-
print("unknown");
|
|
933
1126
|
} finally {
|
|
934
1127
|
state.manager.limit.pop();
|
|
935
1128
|
}
|
|
1129
|
+
print(status === L_UNDEF && datalog.isBounded ? "bounded" : getVerdict(status));
|
|
1130
|
+
datalog.isBounded = false;
|
|
936
1131
|
},
|
|
937
1132
|
],
|
|
938
1133
|
[
|
|
@@ -941,37 +1136,48 @@ export const runSmtlibScript = (
|
|
|
941
1136
|
const params = getCommandParams(list.items, CHECK_SAT_USING_PARAMETERS);
|
|
942
1137
|
if (list.items[1] === undefined)
|
|
943
1138
|
throw new SmtParseError("check-sat-using needs a tactic argument", list.end);
|
|
944
|
-
|
|
1139
|
+
expectClosed(list.items[1]);
|
|
1140
|
+
const builder = compileTactic(getTacticEnvironment(), list.items[1]);
|
|
945
1141
|
const tactic = builder.build(params);
|
|
1142
|
+
const goal = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
946
1143
|
clearCheck();
|
|
947
|
-
|
|
1144
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1145
|
+
state.manager.limit.restart(deadline);
|
|
948
1146
|
state.manager.limit.push(settings.rlimit);
|
|
949
1147
|
try {
|
|
950
|
-
const checked = checkSatUsing(tactic,
|
|
1148
|
+
const checked = checkSatUsing(tactic, goal);
|
|
951
1149
|
setCheck(checked.status, {
|
|
1150
|
+
isFromTactic: true,
|
|
952
1151
|
model: checked.model,
|
|
953
1152
|
core:
|
|
954
1153
|
builder.isTrackingDependencies || !hasNames()
|
|
955
1154
|
? getDependencyValues(checked.core)
|
|
956
1155
|
: undefined,
|
|
957
|
-
reasonUnknown: checked.reasonUnknown,
|
|
1156
|
+
reasonUnknown: checked.reasonUnknown ?? getCancelMessage(deadline),
|
|
958
1157
|
});
|
|
959
1158
|
print(getVerdict(checked.status));
|
|
1159
|
+
} catch (error) {
|
|
1160
|
+
if (!(error instanceof SmtCanceledError)) throw error;
|
|
1161
|
+
const message = getCancelMessage(deadline);
|
|
1162
|
+
setCheck(L_UNDEF, { isFromTactic: true, reasonUnknown: message });
|
|
1163
|
+
print(`(error "tactic failed: ${message}")`);
|
|
960
1164
|
} finally {
|
|
961
1165
|
state.manager.limit.pop();
|
|
962
1166
|
}
|
|
1167
|
+
validateCheck(list.end);
|
|
963
1168
|
},
|
|
964
1169
|
],
|
|
965
1170
|
[
|
|
966
1171
|
"check-sat-assuming",
|
|
967
1172
|
(list) => {
|
|
968
|
-
const literals = list.items[1];
|
|
969
|
-
if (literals
|
|
1173
|
+
const literals = list.items[1] ?? list.end;
|
|
1174
|
+
if (literals.kind !== "list")
|
|
970
1175
|
throw new SmtParseError(
|
|
971
|
-
|
|
972
|
-
literals
|
|
1176
|
+
`invalid check-sat-assuming command, '(', expected got ${literals.lastId}`,
|
|
1177
|
+
literals,
|
|
973
1178
|
);
|
|
974
|
-
checkSatAssuming(literals.items);
|
|
1179
|
+
checkSatAssuming(literals.items, literals.end, list.end);
|
|
1180
|
+
validateCheck(list.end);
|
|
975
1181
|
},
|
|
976
1182
|
],
|
|
977
1183
|
[
|
|
@@ -982,13 +1188,17 @@ export const runSmtlibScript = (
|
|
|
982
1188
|
if (terms === undefined)
|
|
983
1189
|
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
984
1190
|
if (terms.kind !== "list")
|
|
985
|
-
throw new SmtParseError(
|
|
1191
|
+
throw new SmtParseError(
|
|
1192
|
+
`invalid list of terms, '(' expected got ${terms.lastId}`,
|
|
1193
|
+
terms,
|
|
1194
|
+
);
|
|
986
1195
|
return terms.items.map((item) => state.reader.parseTerm(item));
|
|
987
1196
|
});
|
|
988
1197
|
if (list.items.length > 3)
|
|
989
1198
|
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
990
1199
|
clearCheck();
|
|
991
|
-
|
|
1200
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1201
|
+
manager.limit.restart(deadline);
|
|
992
1202
|
manager.limit.push(settings.rlimit);
|
|
993
1203
|
const names = state.names.filter((name) => name !== -1);
|
|
994
1204
|
try {
|
|
@@ -1002,7 +1212,11 @@ export const runSmtlibScript = (
|
|
|
1002
1212
|
assumptions,
|
|
1003
1213
|
vars,
|
|
1004
1214
|
);
|
|
1005
|
-
setCheck(found.result, {
|
|
1215
|
+
setCheck(found.result, {
|
|
1216
|
+
model: found.model,
|
|
1217
|
+
core: found.core,
|
|
1218
|
+
reasonUnknown: found.reasonUnknown,
|
|
1219
|
+
});
|
|
1006
1220
|
print(getVerdict(found.result));
|
|
1007
1221
|
print("");
|
|
1008
1222
|
for (const consequence of found.consequences.items) display(consequence);
|
|
@@ -1013,11 +1227,22 @@ export const runSmtlibScript = (
|
|
|
1013
1227
|
if (state.kernel === undefined)
|
|
1014
1228
|
for (const assertion of getNamedAssertions()) kernel.assertExpr(assertion);
|
|
1015
1229
|
const found = getConsequences(kernel, [...names, ...assumptions], vars);
|
|
1016
|
-
setCheck(found.result, {
|
|
1230
|
+
setCheck(found.result, {
|
|
1231
|
+
context: kernel.context,
|
|
1232
|
+
core: kernel.context.unsatCore,
|
|
1233
|
+
reasonUnknown: kernel.context.getLastFailureMessage(),
|
|
1234
|
+
});
|
|
1017
1235
|
print(getVerdict(found.result));
|
|
1018
1236
|
print("");
|
|
1019
1237
|
for (const consequence of found.consequences.items) display(consequence);
|
|
1020
1238
|
found.consequences.reset();
|
|
1239
|
+
} catch (error) {
|
|
1240
|
+
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
1241
|
+
const reasonUnknown = getCancelMessage(deadline);
|
|
1242
|
+
if (state.kernel !== undefined) state.kernel.context.reasonUnknown = reasonUnknown;
|
|
1243
|
+
setCheck(L_UNDEF, { reasonUnknown });
|
|
1244
|
+
print("unknown");
|
|
1245
|
+
print("");
|
|
1021
1246
|
} finally {
|
|
1022
1247
|
manager.limit.pop();
|
|
1023
1248
|
}
|
|
@@ -1065,35 +1290,43 @@ export const runSmtlibScript = (
|
|
|
1065
1290
|
state.reader.push();
|
|
1066
1291
|
state.isIncremental = true;
|
|
1067
1292
|
state.kernel?.push();
|
|
1068
|
-
|
|
1293
|
+
useSatSolver((solver) => solver.push());
|
|
1069
1294
|
}
|
|
1295
|
+
if (list.items[2] !== undefined)
|
|
1296
|
+
throw new SmtParseError("invalid push command, ')' expected", list.items[2]);
|
|
1070
1297
|
},
|
|
1071
1298
|
],
|
|
1072
1299
|
[
|
|
1073
1300
|
"pop",
|
|
1074
1301
|
(list) => {
|
|
1075
1302
|
const count = getScopeCount(list);
|
|
1303
|
+
const follower = list.items[2] ?? list.end;
|
|
1304
|
+
clearCheck();
|
|
1076
1305
|
if (count > state.scopes.length)
|
|
1077
1306
|
throw new SmtParseError(
|
|
1078
1307
|
"invalid pop command, argument is greater than the current stack depth",
|
|
1079
|
-
|
|
1308
|
+
follower,
|
|
1080
1309
|
);
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1310
|
+
if (count > 0) {
|
|
1311
|
+
state.isIncremental = true;
|
|
1312
|
+
const scope = state.scopes[state.scopes.length - count];
|
|
1313
|
+
state.kernel?.pop(count);
|
|
1314
|
+
useSatSolver((solver) => solver.pop(count));
|
|
1315
|
+
state.reader.pop(count);
|
|
1316
|
+
restoreAssertions(scope.assertions);
|
|
1317
|
+
resetOptimizer();
|
|
1318
|
+
releaseObjectives(scope.objectives, scope.softTrail);
|
|
1319
|
+
state.scopes.length -= count;
|
|
1320
|
+
}
|
|
1321
|
+
if (follower !== list.end)
|
|
1322
|
+
throw new SmtParseError("invalid pop command, ')' expected", follower);
|
|
1092
1323
|
},
|
|
1093
1324
|
],
|
|
1094
1325
|
[
|
|
1095
1326
|
"reset",
|
|
1096
|
-
() => {
|
|
1327
|
+
(list) => {
|
|
1328
|
+
if (list.items[1] !== undefined)
|
|
1329
|
+
throw new SmtParseError("invalid reset command, ')' expected", list.items[1]);
|
|
1097
1330
|
clearCheck();
|
|
1098
1331
|
resetOptimizer();
|
|
1099
1332
|
state = createState();
|
|
@@ -1101,8 +1334,8 @@ export const runSmtlibScript = (
|
|
|
1101
1334
|
],
|
|
1102
1335
|
[
|
|
1103
1336
|
"reset-assertions",
|
|
1104
|
-
() => {
|
|
1105
|
-
|
|
1337
|
+
(list) => {
|
|
1338
|
+
checkArgumentCount(list, 0);
|
|
1106
1339
|
restoreAssertions(0);
|
|
1107
1340
|
resetOptimizer();
|
|
1108
1341
|
releaseObjectives(0, 0);
|
|
@@ -1124,7 +1357,17 @@ export const runSmtlibScript = (
|
|
|
1124
1357
|
manager,
|
|
1125
1358
|
getRewriterOptions(manager, getSimplifyParams(list.items.slice(2))),
|
|
1126
1359
|
);
|
|
1127
|
-
|
|
1360
|
+
// simplify_cmd prints a failure of the rewriter and then the term as it was.
|
|
1361
|
+
const simplified = (() => {
|
|
1362
|
+
try {
|
|
1363
|
+
return rewriter.rewrite(term);
|
|
1364
|
+
} catch (error) {
|
|
1365
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
1366
|
+
print(`(error "simplifier failed: ${error.message}")`);
|
|
1367
|
+
manager.incRef(term);
|
|
1368
|
+
return term;
|
|
1369
|
+
}
|
|
1370
|
+
})();
|
|
1128
1371
|
rewriter.cleanup();
|
|
1129
1372
|
display(simplified);
|
|
1130
1373
|
rewriter.release();
|
|
@@ -1143,8 +1386,7 @@ export const runSmtlibScript = (
|
|
|
1143
1386
|
manager.incRef(term);
|
|
1144
1387
|
const visited = new Set<number>();
|
|
1145
1388
|
const todo = [term];
|
|
1146
|
-
|
|
1147
|
-
const expr = todo.pop() as number;
|
|
1389
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1148
1390
|
if (visited.has(expr)) continue;
|
|
1149
1391
|
visited.add(expr);
|
|
1150
1392
|
const family = manager.kinds[expr] === KIND_APP ? manager.getFamily(expr) : -1;
|
|
@@ -1168,13 +1410,18 @@ export const runSmtlibScript = (
|
|
|
1168
1410
|
const params = getCommandParams(list.items, APPLY_PARAMETERS);
|
|
1169
1411
|
if (list.items[1] === undefined)
|
|
1170
1412
|
throw new SmtParseError("apply needs a tactic argument", list.end);
|
|
1171
|
-
|
|
1413
|
+
expectClosed(list.items[1]);
|
|
1414
|
+
// apply_tactic_cmd, unlike check-sat-using, gives the tactic no logic.
|
|
1415
|
+
const builder = compileTactic(
|
|
1416
|
+
{ ...getTacticEnvironment(), setup: { ...getSetup(), logic: undefined } },
|
|
1417
|
+
list.items[1],
|
|
1418
|
+
);
|
|
1172
1419
|
const tactic = builder.build(params);
|
|
1420
|
+
const input = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
1173
1421
|
const isPrintingDependencies = params.get("print_dependencies") === true;
|
|
1174
1422
|
if (isPrintingDependencies && !builder.isTrackingDependencies && hasNames())
|
|
1175
1423
|
throw new SmtUnsupportedError("the dependencies of a tactic that drops dependencies");
|
|
1176
1424
|
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1177
|
-
const input = getGoal(builder.isTrackingDependencies);
|
|
1178
1425
|
const goals = (() => {
|
|
1179
1426
|
try {
|
|
1180
1427
|
return applyTactic(tactic, input);
|
|
@@ -1239,8 +1486,7 @@ export const runSmtlibScript = (
|
|
|
1239
1486
|
const decls = new Set<number>();
|
|
1240
1487
|
for (const assertion of assertions) {
|
|
1241
1488
|
const todo = [assertion];
|
|
1242
|
-
|
|
1243
|
-
const expr = todo.pop() as number;
|
|
1489
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1244
1490
|
if (visited.has(expr)) continue;
|
|
1245
1491
|
visited.add(expr);
|
|
1246
1492
|
if (manager.kinds[expr] === KIND_QUANTIFIER) {
|
|
@@ -1281,6 +1527,7 @@ export const runSmtlibScript = (
|
|
|
1281
1527
|
[
|
|
1282
1528
|
"get-assertions",
|
|
1283
1529
|
(list) => {
|
|
1530
|
+
checkArgumentCount(list, 0);
|
|
1284
1531
|
if (!settings.isInteractive)
|
|
1285
1532
|
throw new SmtParseError(
|
|
1286
1533
|
"command is only available in interactive mode, use command (set-option :interactive-mode true)",
|
|
@@ -1292,6 +1539,7 @@ export const runSmtlibScript = (
|
|
|
1292
1539
|
[
|
|
1293
1540
|
"get-unsat-core",
|
|
1294
1541
|
(list) => {
|
|
1542
|
+
checkArgumentCount(list, 0);
|
|
1295
1543
|
if (!settings.isProducingUnsatCores)
|
|
1296
1544
|
throw new SmtParseError(
|
|
1297
1545
|
"unsat core construction is not enabled, use command (set-option :produce-unsat-cores true)",
|
|
@@ -1302,7 +1550,16 @@ export const runSmtlibScript = (
|
|
|
1302
1550
|
throw new SmtParseError("unsat core is not available", list.end);
|
|
1303
1551
|
if (check.core === undefined)
|
|
1304
1552
|
throw new SmtUnsupportedError("the unsat core of a tactic that drops dependencies");
|
|
1305
|
-
|
|
1553
|
+
const kernel = state.kernel;
|
|
1554
|
+
if (kernel === undefined || check.context !== kernel.context) {
|
|
1555
|
+
print(`(${check.core.map(format).join(" ")})`);
|
|
1556
|
+
return;
|
|
1557
|
+
}
|
|
1558
|
+
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1559
|
+
const core = new RefVector(state.manager);
|
|
1560
|
+
kernel.getUnsatCore(core);
|
|
1561
|
+
print(`(${core.items.map(format).join(" ")})`);
|
|
1562
|
+
core.reset();
|
|
1306
1563
|
},
|
|
1307
1564
|
],
|
|
1308
1565
|
[
|
|
@@ -1310,44 +1567,76 @@ export const runSmtlibScript = (
|
|
|
1310
1567
|
(list) => {
|
|
1311
1568
|
const target = list.items[1];
|
|
1312
1569
|
const term = target === undefined ? -1 : state.reader.parseTerm(target);
|
|
1313
|
-
|
|
1570
|
+
const parameter = list.items[2];
|
|
1571
|
+
if (parameter !== undefined && parameter.kind !== "keyword")
|
|
1572
|
+
throw new SmtParseError("invalid command argument, keyword expected", parameter);
|
|
1573
|
+
if (parameter !== undefined) throw new SmtUnsupportedError("the parameters of eval");
|
|
1314
1574
|
const model = getModel(list);
|
|
1315
1575
|
if (term === -1) throw new SmtParseError("no arguments passed to eval", list.end);
|
|
1316
1576
|
const manager = state.manager;
|
|
1317
1577
|
manager.incRef(term);
|
|
1318
|
-
const
|
|
1578
|
+
const evaluator = new ModelEvaluator(manager, model);
|
|
1579
|
+
const value = evaluator.rewrite(term);
|
|
1319
1580
|
display(value);
|
|
1320
1581
|
manager.decRef(value);
|
|
1582
|
+
evaluator.release();
|
|
1321
1583
|
manager.decRef(term);
|
|
1322
1584
|
},
|
|
1323
1585
|
],
|
|
1324
1586
|
[
|
|
1325
1587
|
"get-value",
|
|
1326
1588
|
(list) => {
|
|
1327
|
-
const terms = list.items[1];
|
|
1328
|
-
if (terms
|
|
1329
|
-
throw new SmtParseError(
|
|
1589
|
+
const terms = list.items[1] ?? list.end;
|
|
1590
|
+
if (terms.kind !== "list")
|
|
1591
|
+
throw new SmtParseError(
|
|
1592
|
+
`invalid get-value command, '(' expected got ${terms.lastId}`,
|
|
1593
|
+
terms,
|
|
1594
|
+
);
|
|
1330
1595
|
const manager = state.manager;
|
|
1331
1596
|
const exprs = terms.items.map((item) => state.reader.parseTerm(item));
|
|
1332
1597
|
if (exprs.length === 0)
|
|
1333
1598
|
throw new SmtParseError("invalid get-value command, empty list of terms", terms.end);
|
|
1334
|
-
|
|
1599
|
+
const extra = list.items[2];
|
|
1600
|
+
if (
|
|
1601
|
+
extra?.kind === "keyword" &&
|
|
1602
|
+
(extra.text === ":model-index" || extra.text === ":model_index")
|
|
1603
|
+
)
|
|
1604
|
+
throw new SmtUnsupportedError("the model index of get-value");
|
|
1605
|
+
if (extra !== undefined)
|
|
1606
|
+
throw new SmtParseError("invalid get-value command, ')' expected", extra);
|
|
1335
1607
|
const model = getModel(list);
|
|
1608
|
+
pendingText += "(";
|
|
1336
1609
|
model.compact();
|
|
1337
1610
|
// Z3 prints each term as the script spells it, from the end of the term before.
|
|
1338
1611
|
const offsets = [
|
|
1339
1612
|
terms.offset + 1,
|
|
1340
1613
|
...terms.items.map((item) => (item.kind === "list" ? item.end : item).endOffset),
|
|
1341
1614
|
];
|
|
1342
|
-
|
|
1615
|
+
exprs.forEach((expr, index) => {
|
|
1343
1616
|
manager.incRef(expr);
|
|
1344
1617
|
const value = model.eval(expr, true);
|
|
1345
|
-
|
|
1618
|
+
pendingText += `${index > 0 ? "\n " : ""}(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
|
|
1346
1619
|
manager.decRef(value);
|
|
1347
1620
|
manager.decRef(expr);
|
|
1348
|
-
return line;
|
|
1349
1621
|
});
|
|
1350
|
-
print(
|
|
1622
|
+
print(")");
|
|
1623
|
+
},
|
|
1624
|
+
],
|
|
1625
|
+
[
|
|
1626
|
+
"get-assignment",
|
|
1627
|
+
(list) => {
|
|
1628
|
+
checkArgumentCount(list, 0);
|
|
1629
|
+
const manager = state.manager;
|
|
1630
|
+
const model = getModel(list);
|
|
1631
|
+
const assignments = state.reader.getConstantMacros().flatMap((macro) => {
|
|
1632
|
+
if (manager.sorts[macro.body] !== SORT_BOOL) return [];
|
|
1633
|
+
const value = model.eval(macro.body, true);
|
|
1634
|
+
const assignment = `(${getQuotedName(macro.name)} ${manager.isTrue(value)})`;
|
|
1635
|
+
const isDecided = manager.isTrue(value) || manager.isFalse(value);
|
|
1636
|
+
manager.decRef(value);
|
|
1637
|
+
return isDecided ? [assignment] : [];
|
|
1638
|
+
});
|
|
1639
|
+
print(`(${assignments.join(" ")})`);
|
|
1351
1640
|
},
|
|
1352
1641
|
],
|
|
1353
1642
|
[
|
|
@@ -1362,14 +1651,27 @@ export const runSmtlibScript = (
|
|
|
1362
1651
|
[
|
|
1363
1652
|
"get-model",
|
|
1364
1653
|
(list) => {
|
|
1365
|
-
|
|
1654
|
+
for (const index of list.items.slice(1)) {
|
|
1655
|
+
if (index.kind !== "numeral")
|
|
1656
|
+
throw new SmtParseError("invalid command argument, unsigned integer expected", index);
|
|
1657
|
+
if (!isUnsigned(index.text))
|
|
1658
|
+
throw new SmtParseError(
|
|
1659
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
1660
|
+
index,
|
|
1661
|
+
);
|
|
1662
|
+
}
|
|
1366
1663
|
const manager = state.manager;
|
|
1367
1664
|
const model = getModel(list);
|
|
1665
|
+
const last = list.items[list.items.length - 1];
|
|
1666
|
+
// get_model_cmd takes any number of indices and keeps the last.
|
|
1667
|
+
if (last.kind === "numeral" && BigInt(last.text) > 0n)
|
|
1668
|
+
throw new SmtUnsupportedError("the index of get-model");
|
|
1368
1669
|
model.compact();
|
|
1369
1670
|
for (const decl of state.reader.getDeclaredFuncs()) {
|
|
1370
1671
|
const funcDecl = manager.funcDecls[decl];
|
|
1371
1672
|
if (
|
|
1372
1673
|
funcDecl.family !== FAMILY_USER ||
|
|
1674
|
+
manager.macros.has(decl) ||
|
|
1373
1675
|
model.constInterps.has(decl) ||
|
|
1374
1676
|
model.funcInterps.has(decl)
|
|
1375
1677
|
)
|
|
@@ -1387,7 +1689,13 @@ export const runSmtlibScript = (
|
|
|
1387
1689
|
print(`(\n${printModel(manager, getPrintEnvironment(), model, 2)})`);
|
|
1388
1690
|
},
|
|
1389
1691
|
],
|
|
1390
|
-
[
|
|
1692
|
+
[
|
|
1693
|
+
"display",
|
|
1694
|
+
(list) => {
|
|
1695
|
+
display(state.reader.parseTerm(getFirstArgument(list)));
|
|
1696
|
+
checkArgumentCount(list, 1);
|
|
1697
|
+
},
|
|
1698
|
+
],
|
|
1391
1699
|
[
|
|
1392
1700
|
"dbg-lt",
|
|
1393
1701
|
(list) => {
|
|
@@ -1436,10 +1744,11 @@ export const runSmtlibScript = (
|
|
|
1436
1744
|
[
|
|
1437
1745
|
"echo",
|
|
1438
1746
|
(list) => {
|
|
1439
|
-
const message = list
|
|
1440
|
-
if (message
|
|
1441
|
-
throw new SmtParseError("invalid
|
|
1747
|
+
const message = getFirstArgument(list);
|
|
1748
|
+
if (message.kind !== "string")
|
|
1749
|
+
throw new SmtParseError("invalid command argument, string expected", message);
|
|
1442
1750
|
print(message.text);
|
|
1751
|
+
checkArgumentCount(list, 1);
|
|
1443
1752
|
},
|
|
1444
1753
|
],
|
|
1445
1754
|
[
|
|
@@ -1453,7 +1762,14 @@ export const runSmtlibScript = (
|
|
|
1453
1762
|
if (keyword === ":produce-models") settings.isProducingModels = isTrue;
|
|
1454
1763
|
if (keyword === ":produce-unsat-cores") settings.isProducingUnsatCores = isTrue;
|
|
1455
1764
|
if (keyword === ":produce-proofs") settings.isProducingProofs = isTrue;
|
|
1456
|
-
if (keyword === ":interactive-mode"
|
|
1765
|
+
if (keyword === ":interactive-mode" || keyword === ":produce-assertions") {
|
|
1766
|
+
if (state.isProofsEnabled !== undefined)
|
|
1767
|
+
throw new SmtParseError(
|
|
1768
|
+
"error setting ':produce-assertions', option value cannot be modified after initialization",
|
|
1769
|
+
value ?? list.end,
|
|
1770
|
+
);
|
|
1771
|
+
settings.isInteractive = isTrue;
|
|
1772
|
+
}
|
|
1457
1773
|
if (keyword === ":diagnostic-output-channel")
|
|
1458
1774
|
settings.isDiagnosticOnStdout = value?.kind === "string" && value.text === "stdout";
|
|
1459
1775
|
if (keyword === ":int-real-coercions" && !isTrue)
|
|
@@ -1466,13 +1782,12 @@ export const runSmtlibScript = (
|
|
|
1466
1782
|
);
|
|
1467
1783
|
settings.isExitingOnError = isSymbol(value, "immediate-exit");
|
|
1468
1784
|
}
|
|
1469
|
-
|
|
1785
|
+
const isParameter =
|
|
1470
1786
|
keyword !== "" &&
|
|
1471
1787
|
!BUILTIN_OPTIONS.has(keyword) &&
|
|
1472
1788
|
value !== undefined &&
|
|
1473
|
-
value.kind !== "list"
|
|
1474
|
-
)
|
|
1475
|
-
settings.parameters.set(getParameterName(keyword), value.text);
|
|
1789
|
+
value.kind !== "list";
|
|
1790
|
+
if (isParameter) settings.parameters.set(getParameterName(keyword), value.text);
|
|
1476
1791
|
if (optionName === ":print_success") settings.isPrintingSuccess = isTrue;
|
|
1477
1792
|
if (
|
|
1478
1793
|
!BUILTIN_OPTIONS.has(keyword) &&
|
|
@@ -1485,6 +1800,9 @@ export const runSmtlibScript = (
|
|
|
1485
1800
|
settings.mbqiMaxIterations = Number(value.text);
|
|
1486
1801
|
if (optionName === ":rlimit" && value?.kind === "numeral")
|
|
1487
1802
|
settings.rlimit = Number(value.text);
|
|
1803
|
+
const kernel = state.kernel;
|
|
1804
|
+
if (isParameter && kernel !== undefined)
|
|
1805
|
+
kernel.updateParams(getKernelParams(kernel.isSetUp));
|
|
1488
1806
|
if (optionName === ":rewriter.hi_div0") {
|
|
1489
1807
|
settings.isHiDiv0 = isTrue;
|
|
1490
1808
|
state.manager.isHiDiv0 = isTrue;
|
|
@@ -1519,6 +1837,8 @@ export const runSmtlibScript = (
|
|
|
1519
1837
|
[":print-success", settings.isPrintingSuccess],
|
|
1520
1838
|
[":produce-models", settings.isProducingModels],
|
|
1521
1839
|
[":produce-unsat-cores", settings.isProducingUnsatCores],
|
|
1840
|
+
[":interactive-mode", settings.isInteractive],
|
|
1841
|
+
[":produce-assertions", settings.isInteractive],
|
|
1522
1842
|
[":int-real-coercions", true],
|
|
1523
1843
|
[":error-behavior", settings.isExitingOnError ? "immediate-exit" : "continued-execution"],
|
|
1524
1844
|
]);
|
|
@@ -1538,17 +1858,7 @@ export const runSmtlibScript = (
|
|
|
1538
1858
|
const info = list.items[1];
|
|
1539
1859
|
if (info?.kind !== "keyword")
|
|
1540
1860
|
throw new SmtParseError("invalid command argument, keyword expected", info ?? list.end);
|
|
1541
|
-
const optimizer = state.optimizer;
|
|
1542
1861
|
const check = state.check;
|
|
1543
|
-
if (
|
|
1544
|
-
info.text === ":reason-unknown" &&
|
|
1545
|
-
check?.status === L_UNDEF &&
|
|
1546
|
-
optimizer !== undefined &&
|
|
1547
|
-
optimizer.reasonUnknown !== ""
|
|
1548
|
-
) {
|
|
1549
|
-
print(`(:reason-unknown "${optimizer.reasonUnknown}")`);
|
|
1550
|
-
return;
|
|
1551
|
-
}
|
|
1552
1862
|
const reasonUnknown =
|
|
1553
1863
|
check === undefined
|
|
1554
1864
|
? "state of the most recent check-sat command is not known"
|
|
@@ -1571,9 +1881,9 @@ export const runSmtlibScript = (
|
|
|
1571
1881
|
[
|
|
1572
1882
|
"set-logic",
|
|
1573
1883
|
(list) => {
|
|
1574
|
-
const logic = list
|
|
1884
|
+
const logic = getFirstArgument(list);
|
|
1575
1885
|
if (!isSymbol(logic))
|
|
1576
|
-
throw new SmtParseError("invalid
|
|
1886
|
+
throw new SmtParseError("invalid command argument, symbol expected", logic);
|
|
1577
1887
|
if (state.logic !== undefined)
|
|
1578
1888
|
throw new SmtParseError("the logic has already been set", logic);
|
|
1579
1889
|
if (state.assertions.length > 0)
|
|
@@ -1583,6 +1893,7 @@ export const runSmtlibScript = (
|
|
|
1583
1893
|
printDiagnostic(
|
|
1584
1894
|
`; ignoring unsupported logic ${logic.text} line: ${list.line} position: ${list.column}`,
|
|
1585
1895
|
);
|
|
1896
|
+
checkArgumentCount(list, 1);
|
|
1586
1897
|
return;
|
|
1587
1898
|
}
|
|
1588
1899
|
state.logic = logic.text;
|
|
@@ -1590,14 +1901,37 @@ export const runSmtlibScript = (
|
|
|
1590
1901
|
state.reader = createSmtlibReader(state.manager, logic.text, settings.parserOptions);
|
|
1591
1902
|
else {
|
|
1592
1903
|
state.reader.restrictSorts(logic.text);
|
|
1593
|
-
// Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop
|
|
1594
|
-
// and keeps what they asserted.
|
|
1904
|
+
// Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop and keeps what they asserted.
|
|
1595
1905
|
resetKernel();
|
|
1596
1906
|
}
|
|
1597
1907
|
if (settings.isPrintingSuccess) print("success");
|
|
1908
|
+
checkArgumentCount(list, 1);
|
|
1909
|
+
},
|
|
1910
|
+
],
|
|
1911
|
+
[
|
|
1912
|
+
"set-info",
|
|
1913
|
+
(list) => {
|
|
1914
|
+
const info = list.items[1];
|
|
1915
|
+
if (info === undefined)
|
|
1916
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
1917
|
+
if (info.kind !== "keyword")
|
|
1918
|
+
throw new SmtParseError("invalid command argument, keyword expected", info);
|
|
1919
|
+
const value = list.items[2];
|
|
1920
|
+
if (value === undefined)
|
|
1921
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
1922
|
+
if (value.kind === "list" || value.kind === "keyword" || value.kind === "eof")
|
|
1923
|
+
throw new SmtParseError("invalid option value", value);
|
|
1924
|
+
if (info.text === ":status" && value.kind === "symbol") {
|
|
1925
|
+
const status = [L_TRUE, L_FALSE, L_UNDEF].find(
|
|
1926
|
+
(innerStatus) => getVerdict(innerStatus) === value.text,
|
|
1927
|
+
);
|
|
1928
|
+
if (status === undefined) throw new SmtParseError("invalid ':status' attribute", value);
|
|
1929
|
+
settings.status = status;
|
|
1930
|
+
}
|
|
1931
|
+
if (list.items[3] !== undefined)
|
|
1932
|
+
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
1598
1933
|
},
|
|
1599
1934
|
],
|
|
1600
|
-
["set-info", () => {}],
|
|
1601
1935
|
]);
|
|
1602
1936
|
const run = (list: SmtList) => {
|
|
1603
1937
|
const head = list.items[0];
|
|
@@ -1606,18 +1940,39 @@ export const runSmtlibScript = (
|
|
|
1606
1940
|
const command = DECLARATIONS.has(head.text)
|
|
1607
1941
|
? (declaration: SmtList) => state.reader.declareCommand(declaration)
|
|
1608
1942
|
: runCommand.get(head.text);
|
|
1609
|
-
if (command === undefined
|
|
1943
|
+
if (command === undefined && UNPORTED_COMMANDS.has(head.text))
|
|
1944
|
+
throw new SmtUnsupportedError(`the command ${head.text}`);
|
|
1945
|
+
if (command === undefined) {
|
|
1946
|
+
expectClosed(list);
|
|
1947
|
+
print("unsupported");
|
|
1948
|
+
printDiagnostic(`; ${head.text} line: ${list.end.line} position: ${list.end.column}`);
|
|
1949
|
+
return;
|
|
1950
|
+
}
|
|
1951
|
+
// Z3's scoped_timer ends with the command that set it, so a command starts without one.
|
|
1952
|
+
state.manager.limit.restart(Infinity);
|
|
1610
1953
|
if (!MANAGERLESS_COMMANDS.has(head.text) && state.isProofsEnabled === undefined) {
|
|
1611
1954
|
state.isProofsEnabled = settings.parameters.get("proof") === "true";
|
|
1955
|
+
if (state.logic === undefined || logicHasSeq(state.logic)) state.manager.initSeqPlugin();
|
|
1956
|
+
if (state.logic === undefined) state.reader.registerList();
|
|
1612
1957
|
resetKernel();
|
|
1613
1958
|
}
|
|
1614
|
-
|
|
1959
|
+
try {
|
|
1960
|
+
command(list);
|
|
1961
|
+
} catch (error) {
|
|
1962
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
1963
|
+
throw new SmtParseError(error.message, list.end);
|
|
1964
|
+
}
|
|
1615
1965
|
if (settings.isPrintingSuccess && SILENT_COMMANDS.has(head.text)) print("success");
|
|
1616
1966
|
};
|
|
1617
1967
|
for (;;) {
|
|
1618
1968
|
try {
|
|
1619
|
-
const list = commands.
|
|
1620
|
-
if (list === undefined
|
|
1969
|
+
const list = commands.readCommand();
|
|
1970
|
+
if (list === undefined) break;
|
|
1971
|
+
if (isSymbol(list.items[0], "exit")) {
|
|
1972
|
+
checkArgumentCount(list, 0);
|
|
1973
|
+
if (settings.isPrintingSuccess) print("success");
|
|
1974
|
+
break;
|
|
1975
|
+
}
|
|
1621
1976
|
run(list);
|
|
1622
1977
|
} catch (error) {
|
|
1623
1978
|
if (!(error instanceof SmtParseError)) throw error;
|