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.
Files changed (226) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +3 -2
  7. package/dist/index.d.ts +3 -2
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +60 -60
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -44
  16. package/dist/run.js +44 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +43 -43
  20. package/dist/transfer.js +39 -39
  21. package/dist/worker.cjs +6 -6
  22. package/dist/worker.js +6 -6
  23. package/package.json +1 -1
  24. package/src/ast.ts +1 -0
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +1 -1
  28. package/src/check-trace.ts +90 -51
  29. package/src/check.ts +367 -178
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +1 -2
  33. package/src/cli/tlc.ts +16 -10
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +26 -9
  36. package/src/dependencies.ts +49 -9
  37. package/src/dfid.ts +22 -10
  38. package/src/environment.ts +58 -33
  39. package/src/errors.ts +7 -0
  40. package/src/evaluate.ts +117 -41
  41. package/src/exit-codes.ts +4 -2
  42. package/src/instances.ts +5 -5
  43. package/src/java-hash.ts +14 -0
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/liveness-checker.ts +81 -33
  47. package/src/liveness.ts +49 -11
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/parallel-worker.ts +8 -2
  52. package/src/parallel.ts +5 -0
  53. package/src/parser.ts +112 -145
  54. package/src/prover/isabelle/isar/attrib.ts +4 -4
  55. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  56. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  57. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  58. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  59. package/src/prover/isabelle/pure/term.ts +3 -3
  60. package/src/prover/prep/md5.ts +26 -29
  61. package/src/prover/smt/rewrite.ts +2 -7
  62. package/src/prover/smt/simplify.ts +1 -1
  63. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  64. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  65. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  66. package/src/prover/smt/solver/ast-lt.ts +1 -1
  67. package/src/prover/smt/solver/ast.ts +63 -14
  68. package/src/prover/smt/solver/auf-solver.ts +23 -12
  69. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  70. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  71. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  72. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  73. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  74. package/src/prover/smt/solver/card2bv.ts +32 -18
  75. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  76. package/src/prover/smt/solver/context.ts +47 -9
  77. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  78. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  79. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  80. package/src/prover/smt/solver/diff-neq.ts +1 -2
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  93. package/src/prover/smt/solver/factor.ts +36 -14
  94. package/src/prover/smt/solver/fd-solver.ts +2 -0
  95. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  96. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  97. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  98. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  99. package/src/prover/smt/solver/goal.ts +6 -3
  100. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  101. package/src/prover/smt/solver/hashtable.ts +4 -0
  102. package/src/prover/smt/solver/internalizer.ts +1 -1
  103. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  104. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  105. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  106. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  107. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  108. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  109. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  110. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  111. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  112. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  113. package/src/prover/smt/solver/model-generator.ts +85 -43
  114. package/src/prover/smt/solver/mpf.ts +2 -4
  115. package/src/prover/smt/solver/mus.ts +2 -3
  116. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  117. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  118. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  121. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  122. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  123. package/src/prover/smt/solver/nlqsat.ts +1 -1
  124. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  125. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  126. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  127. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  128. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  129. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  130. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  131. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  132. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  133. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  134. package/src/prover/smt/solver/nnf.ts +6 -2
  135. package/src/prover/smt/solver/opt-context.ts +20 -7
  136. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  137. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  138. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  139. package/src/prover/smt/solver/opt-solver.ts +9 -5
  140. package/src/prover/smt/solver/optsmt.ts +1 -1
  141. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  142. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  143. package/src/prover/smt/solver/probes.ts +88 -23
  144. package/src/prover/smt/solver/proto-model.ts +8 -8
  145. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  146. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  147. package/src/prover/smt/solver/qe-lite.ts +2 -2
  148. package/src/prover/smt/solver/qe.ts +3 -2
  149. package/src/prover/smt/solver/qsat.ts +16 -6
  150. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  151. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  152. package/src/prover/smt/solver/rewriter.ts +31 -25
  153. package/src/prover/smt/solver/rlimit.ts +4 -0
  154. package/src/prover/smt/solver/sat/config.ts +1 -1
  155. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  156. package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
  157. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  158. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  159. package/src/prover/smt/solver/sat/sat-tactic.ts +13 -5
  160. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  161. package/src/prover/smt/solver/sat/solver.ts +25 -47
  162. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  163. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  164. package/src/prover/smt/solver/seq-derive.ts +2 -2
  165. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  166. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  167. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  168. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  169. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  170. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  171. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  172. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  173. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  174. package/src/prover/smt/solver/smt-kernel.ts +39 -5
  175. package/src/prover/smt/solver/smt-setup.ts +96 -10
  176. package/src/prover/smt/solver/smtlib-parser.ts +584 -223
  177. package/src/prover/smt/solver/smtlib-script.ts +509 -154
  178. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  179. package/src/prover/smt/solver/solver.ts +18 -3
  180. package/src/prover/smt/solver/tactic.ts +284 -168
  181. package/src/prover/smt/solver/theory-bv.ts +13 -3
  182. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  183. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  184. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  185. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  191. package/src/prover/tlapm/cache.ts +8 -8
  192. package/src/prover/zenon/index-table.ts +5 -2
  193. package/src/prover/zenon/isar-case.ts +1 -1
  194. package/src/prover/zenon/isar.ts +2 -2
  195. package/src/prover/zenon/phrase.ts +1 -1
  196. package/src/resolve.ts +959 -243
  197. package/src/runtime.ts +7 -1
  198. package/src/sany/builtins.ts +10 -10
  199. package/src/sany/generation.ts +2 -13
  200. package/src/sany/generator-definitions.ts +3 -1
  201. package/src/sany/generator-expressions.ts +36 -30
  202. package/src/sany/generator-proofs.ts +5 -3
  203. package/src/sany/generator.ts +2 -1
  204. package/src/sany/lexer.ts +3 -3
  205. package/src/sany/modules.ts +4 -2
  206. package/src/sany/nodes.ts +1 -1
  207. package/src/sany/selectors.ts +11 -6
  208. package/src/sany/xml.ts +2 -3
  209. package/src/search.ts +166 -101
  210. package/src/simulate.ts +110 -50
  211. package/src/spec-description.ts +5 -6
  212. package/src/standard-modules.ts +15 -6
  213. package/src/subexpressions.ts +398 -108
  214. package/src/successors.ts +4 -2
  215. package/src/symmetry.ts +1 -1
  216. package/src/tlc/jar-data.ts +10 -0
  217. package/src/tlc/messages.ts +3 -3
  218. package/src/tlc/order.ts +14 -3
  219. package/src/tlc/random.ts +2 -1
  220. package/src/tlc/replay.ts +3 -2
  221. package/src/tlc/tlc-operators.ts +10 -8
  222. package/src/tlc/tlcext-operators.ts +44 -15
  223. package/src/tlc/trace-spec.ts +9 -22
  224. package/src/typed-tier.ts +32 -25
  225. package/src/typescript/types.ts +2 -2
  226. 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
- const name = keyword.kind === "keyword" ? getParameterName(keyword.text) : "";
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
- const name = keyword.kind === "keyword" ? getParameterName(keyword.text) : "";
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
- // The incremental solver of sat.euf, inc_sat_solver in euf mode, or undefined once it reached
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
- eufSolver: undefined,
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, { isOptimizing: true, model: optimizer.model ?? undefined });
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 { result: checked.status, context: undefined, model: checked.model };
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
- ...solveAssertions(state.manager, state.assertions, {
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
- const getKernelParams = () => ({
504
- isMbqi: settings.isMbqi || isMbqiByLogic(getSetup()),
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
- state.manager.limit.restart(Date.now() + options.timeLimitMs);
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 manager = state.manager;
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 solved =
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
- ? { ...solveWithStrategy(), core: undefined }
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 (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
552
- setCheck(L_UNDEF, { isOptimizing });
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 new SmtUnsupportedError("the model of a canceled search");
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.eufSolver?.release();
747
+ state.satSolver?.release();
605
748
  state.kernel = isSatSolver ? undefined : new SmtKernel(state.manager, getKernelParams());
606
- state.eufSolver =
607
- isEuf && !isFdSolver && parameters.get("sat.smt") !== "true"
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
- useEufSolver((solver) => solver.push());
755
+ useSatSolver((solver) => solver.push());
613
756
  }
614
757
  };
615
- // The parts of sat.euf that are not ported leave its answers to the smt kernel.
616
- const useEufSolver = <Result>(action: (solver: IncSatSolver) => Result) => {
617
- const solver = state.eufSolver;
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.eufSolver = undefined;
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
- state.kernel?.assertExpr(asserted);
634
- useEufSolver((solver) => solver.assertExpr(asserted));
781
+ kernel.assertExpr(asserted);
635
782
  manager.decRef(asserted);
636
783
  };
637
- const checkKernel = (assumptions: number[]) => {
784
+ const checkKernel = (names: number[], extra: number[]) => {
638
785
  const kernel = state.kernel;
639
- const found = useEufSolver((solver) => {
640
- const result = solver.check(assumptions);
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
- ...solveAssuming(state.manager, getNamedAssertions(), assumptions, getKernelParams()),
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) literals.push(state.reader.parseFormula(item));
714
- checkSat(literals);
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.items[1] ?? list.end);
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("Objective must be bit-vector, integer or real", list.end);
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
- "invalid function declaration reference, symbol or '(' expected got query",
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.kind === "symbol" || domain.kind === "keyword" ? domain.text : name.text}`,
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 assertion = state.reader.parseAssertion(term);
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, list.end);
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(state.reader.parseFormula(rule), isSymbol(name) ? name.text : "");
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
- print(getVerdict(datalog.relQuery(relation)));
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
- const builder = getTactic(list.items[1], list.end);
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
- state.manager.limit.restart(Date.now() + options.timeLimitMs);
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, getGoal(builder.isTrackingDependencies));
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?.kind !== "list")
1173
+ const literals = list.items[1] ?? list.end;
1174
+ if (literals.kind !== "list")
970
1175
  throw new SmtParseError(
971
- "invalid check-sat-assuming command, '(' expected",
972
- literals ?? list.end,
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("invalid list of terms, '(' expected", terms);
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
- manager.limit.restart(Date.now() + options.timeLimitMs);
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, { model: found.model });
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, { context: kernel.context, core: kernel.context.unsatCore });
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
- useEufSolver((solver) => solver.push());
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
- list.end,
1308
+ follower,
1080
1309
  );
1081
- clearCheck();
1082
- if (count === 0) return;
1083
- state.isIncremental = true;
1084
- const scope = state.scopes[state.scopes.length - count];
1085
- state.kernel?.pop(count);
1086
- useEufSolver((solver) => solver.pop(count));
1087
- for (let index = 0; index < count; index++) state.reader.pop();
1088
- restoreAssertions(scope.assertions);
1089
- resetOptimizer();
1090
- releaseObjectives(scope.objectives, scope.softTrail);
1091
- state.scopes.length -= count;
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
- clearCheck();
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
- const simplified = rewriter.rewrite(term);
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
- while (todo.length > 0) {
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
- const builder = getTactic(list.items[1], list.end);
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
- while (todo.length > 0) {
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
- print(`(${check.core.map(format).join(" ")})`);
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
- if (list.items.length > 2) throw new SmtUnsupportedError("the parameters of eval");
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 value = model.eval(term, false);
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?.kind !== "list")
1329
- throw new SmtParseError("invalid get-value command, '(' expected", terms ?? list.end);
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
- if (list.items.length > 2) throw new SmtUnsupportedError("the parameters of get-value");
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
- const lines = exprs.map((expr, index) => {
1615
+ exprs.forEach((expr, index) => {
1343
1616
  manager.incRef(expr);
1344
1617
  const value = model.eval(expr, true);
1345
- const line = `(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
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(`(${lines.join("\n ")})`);
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
- if (list.items.length > 1) throw new SmtUnsupportedError("the index of get-model");
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
- ["display", (list) => display(state.reader.parseTerm(list.items[1] ?? list.end))],
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.items[1];
1440
- if (message?.kind !== "string")
1441
- throw new SmtParseError("invalid echo command, string expected", message ?? list.end);
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") settings.isInteractive = isTrue;
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
- if (
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.items[1];
1884
+ const logic = getFirstArgument(list);
1575
1885
  if (!isSymbol(logic))
1576
- throw new SmtParseError("invalid logic name, symbol expected", logic ?? list.end);
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) throw new SmtUnsupportedError(`the command ${head.text}`);
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
- command(list);
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.read();
1620
- if (list === undefined || isSymbol(list.items[0], "exit")) break;
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;