tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (235) 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 +13 -3
  7. package/dist/index.d.ts +13 -3
  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 +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. 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
- import { getFdConsequences } from "./fd-solver";
56
+ import { checkFdSolver, 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,60 @@ 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-user-tactics",
113
+ "help",
114
+ "help-simplifier",
115
+ "help-tactic",
116
+ "include",
117
+ "infer",
118
+ "labels",
119
+ "mbi",
120
+ "mbp",
121
+ "mbp-qel",
122
+ "model-add",
123
+ "model-del",
124
+ "prefer",
125
+ "qe-lite",
126
+ "qel",
127
+ "reset-preferences",
128
+ "set-initial-value",
129
+ "set-simplifier",
130
+ ]);
131
+
75
132
  const SILENT_COMMANDS = new Set([
76
133
  ...DECLARATIONS,
77
134
  "assert",
@@ -81,8 +138,6 @@ const SILENT_COMMANDS = new Set([
81
138
  "reset-assertions",
82
139
  "set-option",
83
140
  "set-info",
84
- "minimize",
85
- "maximize",
86
141
  "assert-soft",
87
142
  "declare-rel",
88
143
  "declare-var",
@@ -121,6 +176,7 @@ const SIMPLIFY_PARAMETERS = new Set([
121
176
  "som",
122
177
  "sort_sums",
123
178
  "arith_lhs",
179
+ "arith_ineq_lhs",
124
180
  "gcd_rounding",
125
181
  "hi_div0",
126
182
  "mul2concat",
@@ -175,7 +231,9 @@ const getSoftParameters = (items: SExpr[]) => {
175
231
  const parameters = { weight: Rational.one, id: null as string | null };
176
232
  for (let index = 0; index < items.length; index += 2) {
177
233
  const keyword = items[index];
178
- const name = keyword.kind === "keyword" ? getParameterName(keyword.text) : "";
234
+ if (keyword.kind !== "keyword")
235
+ throw new SmtParseError("invalid command argument, keyword expected", keyword);
236
+ const name = getParameterName(keyword.text);
179
237
  const value = items[index + 1];
180
238
  if (name === "weight" && (value?.kind === "numeral" || value?.kind === "decimal")) {
181
239
  const [whole, fraction = ""] = value.text.split(".");
@@ -193,7 +251,9 @@ const getSimplifyParams = (items: SExpr[]) => {
193
251
  const params = new Map<string, TacticParam>();
194
252
  for (let index = 0; index < items.length; index += 2) {
195
253
  const keyword = items[index];
196
- const name = keyword.kind === "keyword" ? getParameterName(keyword.text) : "";
254
+ if (keyword.kind !== "keyword")
255
+ throw new SmtParseError("invalid command argument, keyword expected", keyword);
256
+ const name = getParameterName(keyword.text);
197
257
  const value = items[index + 1];
198
258
  if (SIMPLIFY_UINT_PARAMETERS.has(name) && value?.kind === "numeral") {
199
259
  params.set(name, Number(value.text));
@@ -206,6 +266,17 @@ const getSimplifyParams = (items: SExpr[]) => {
206
266
  return params;
207
267
  };
208
268
 
269
+ const GET_INFO_KEYWORDS = [
270
+ ":reason-unknown",
271
+ ":status",
272
+ ":version",
273
+ ":authors",
274
+ ":error-behavior",
275
+ ":parameters",
276
+ ":rlimit",
277
+ ":assertion-stack-levels",
278
+ ];
279
+
209
280
  const APPLY_PARAMETERS = new Map([
210
281
  ["print", true],
211
282
  ["print_model_converter", true],
@@ -245,12 +316,29 @@ const getCommandParams = (items: SExpr[], isBooleans: ReadonlyMap<string, boolea
245
316
  "invalid command argument, unsigned integer expected",
246
317
  value ?? keyword,
247
318
  );
319
+ if (!isUnsigned(value.text))
320
+ throw new SmtParseError(
321
+ "invalid indexed identifier, index is too big to fit in an unsigned machine integer",
322
+ value,
323
+ );
248
324
  params.set(name, Number(value.text));
249
325
  }
250
326
  }
251
327
  return params;
252
328
  };
253
329
 
330
+ const getFirstArgument = (list: SmtList) => {
331
+ const argument = list.items[1];
332
+ if (argument === undefined)
333
+ throw new SmtParseError("invalid command, argument(s) missing", list.end);
334
+ return argument;
335
+ };
336
+
337
+ const checkArgumentCount = (list: SmtList, count: number) => {
338
+ const extra = list.items[count + 1];
339
+ if (extra !== undefined) throw new SmtParseError("invalid command, too many arguments", extra);
340
+ };
341
+
254
342
  // Z3's parse_opt_unsigned names the push command for pop as well.
255
343
  const getScopeCount = (list: SmtList) => {
256
344
  const argument = list.items[1];
@@ -266,18 +354,26 @@ interface Scope {
266
354
  assertions: number;
267
355
  objectives: number;
268
356
  softTrail: number;
357
+ rlimit: number;
269
358
  }
270
359
 
271
360
  interface CheckResult {
272
361
  status: number;
273
362
  context: Context | undefined;
274
363
  isOptimizing: boolean;
364
+ isFromTactic: boolean;
275
365
  model: ProtoModel | undefined;
276
366
  core: number[] | undefined;
277
367
  // check_sat_result::reason_unknown, where the port tracks it.
278
368
  reasonUnknown?: string;
279
369
  }
280
370
 
371
+ interface SolverAnswer {
372
+ result: number;
373
+ context: Context | undefined;
374
+ reasonUnknown: string | undefined;
375
+ }
376
+
281
377
  interface ScriptState {
282
378
  manager: AstManager;
283
379
  logic: string | undefined;
@@ -299,9 +395,7 @@ interface ScriptState {
299
395
  // combined_solver's incremental smt kernel, which keeps one context across the checks, or
300
396
  // undefined while Z3 has made no such kernel.
301
397
  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;
398
+ satSolver: IncSatSolver | undefined;
305
399
  }
306
400
 
307
401
  // Z3 fixes the proof mode at the first command that needs terms.
@@ -311,6 +405,7 @@ const MANAGERLESS_COMMANDS = new Set([
311
405
  "set-logic",
312
406
  "get-option",
313
407
  "get-info",
408
+ "get-assertions",
314
409
  "echo",
315
410
  ]);
316
411
 
@@ -330,6 +425,7 @@ export const runSmtlibScript = (
330
425
  isPrintingSuccess: false,
331
426
  isProducingModels: true,
332
427
  isProducingUnsatCores: false,
428
+ isProducingUnsatAssumptions: false,
333
429
  isProducingProofs: false,
334
430
  isExitingOnError: false,
335
431
  isInteractive: false,
@@ -343,11 +439,11 @@ export const runSmtlibScript = (
343
439
  rlimit: 0,
344
440
  printOptions: { ...DEFAULT_PRINT_OPTIONS },
345
441
  parserOptions: { isIgnoringBadPatterns: true },
442
+ // Z3 keeps set-info's :status across reset.
443
+ status: L_UNDEF,
346
444
  };
347
445
  const createState = (): ScriptState => {
348
- const manager = new AstManager(
349
- new ResourceLimit(Date.now() + options.timeLimitMs, options.signal),
350
- );
446
+ const manager = new AstManager(new ResourceLimit(Infinity, options.signal));
351
447
  manager.isHiDiv0 = settings.isHiDiv0;
352
448
  manager.maxChar = settings.encoding.maxChar;
353
449
  manager.charBits = settings.encoding.charBits;
@@ -368,7 +464,7 @@ export const runSmtlibScript = (
368
464
  hasChecked: false,
369
465
  datalog: undefined,
370
466
  kernel: undefined,
371
- eufSolver: undefined,
467
+ satSolver: undefined,
372
468
  };
373
469
  };
374
470
  let state = createState();
@@ -409,7 +505,7 @@ export const runSmtlibScript = (
409
505
  paretoMaxLemmas: Number(parameters.get("opt.pareto_nlsat_max_lemmas") ?? 128),
410
506
  };
411
507
  };
412
- const optimize = (extra: number[]) => {
508
+ const optimize = (extra: number[], end: SmtToken) => {
413
509
  const manager = state.manager;
414
510
  const objectives = state.objectives;
415
511
  const hard = [...getNamedAssertions(), ...state.names.filter((name) => name !== -1), ...extra];
@@ -452,7 +548,11 @@ export const runSmtlibScript = (
452
548
  !hasAssumptions &&
453
549
  settings.parameters.get("opt.incremental") !== "true",
454
550
  });
455
- setCheck(status, { isOptimizing: true, model: optimizer.model ?? undefined });
551
+ setCheck(status, {
552
+ isOptimizing: true,
553
+ model: optimizer.model ?? undefined,
554
+ reasonUnknown: optimizer.getReasonUnknown(),
555
+ });
456
556
  print(getVerdict(status));
457
557
  return true;
458
558
  } catch (error) {
@@ -461,9 +561,16 @@ export const runSmtlibScript = (
461
561
  resetOptimizer();
462
562
  return false;
463
563
  }
564
+ if (error instanceof SmtDefaultError) {
565
+ setCheck(L_UNDEF, { isFromTactic: true, reasonUnknown: optimizer.getReasonUnknown() });
566
+ throw new SmtParseError(error.message, end);
567
+ }
464
568
  if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
569
+ const reasonUnknown = optimizer.getReasonUnknown();
465
570
  optimizer.release();
466
- setCheck(L_UNDEF, { isOptimizing: true });
571
+ setCheck(L_UNDEF, { isOptimizing: true, reasonUnknown });
572
+ if (error instanceof SmtCanceledError)
573
+ throw new SmtParseError(manager.limit.getCancelMessage(), end);
467
574
  print("unknown");
468
575
  return true;
469
576
  } finally {
@@ -477,33 +584,63 @@ export const runSmtlibScript = (
477
584
  };
478
585
  // The port keeps answering with the smt kernel where it lacks a piece of the logic's strategy.
479
586
  const solveWithStrategy = () => {
480
- const goal = getGoal();
481
- const strategy =
482
- settings.parameters.get("tactic.default_tactic") ??
483
- getLogicStrategy(state.logic, goal.isProofsEnabled);
484
587
  try {
588
+ if (isUsingFdSolver())
589
+ return {
590
+ ...checkFdSolver(state.manager, getSatParams(settings.parameters), state.assertions),
591
+ context: undefined,
592
+ };
593
+ const goal = getGoal();
594
+ const strategy =
595
+ settings.parameters.get("tactic.default_tactic") ??
596
+ getLogicStrategy(state.logic, goal.isProofsEnabled);
485
597
  const checked = checkSatUsing(compileInternalTactic(getTacticEnvironment(), strategy), goal);
486
- return { result: checked.status, context: undefined, model: checked.model };
598
+ return {
599
+ result: checked.status,
600
+ context: undefined,
601
+ model: checked.model,
602
+ reasonUnknown: checked.reasonUnknown,
603
+ };
487
604
  } catch (error) {
488
605
  if (!(error instanceof SmtUnsupportedError)) throw error;
489
606
  const hasQuantifiers = state.assertions.some(
490
607
  (assertion) => state.manager.hasQuantifierFlags[assertion],
491
608
  );
609
+ const solved = solveAssertions(state.manager, state.assertions, {
610
+ isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
611
+ mbqiMaxIterations: settings.mbqiMaxIterations,
612
+ isFindingMacros: settings.isFindingMacros,
613
+ setup: getSetup(),
614
+ });
492
615
  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
- }),
616
+ ...solved,
499
617
  model: undefined,
618
+ reasonUnknown:
619
+ solved.result === L_UNDEF && solved.context !== undefined
620
+ ? getSmtTacticFailure(solved.context)
621
+ : "",
500
622
  };
501
623
  }
502
624
  };
503
- const getKernelParams = () => ({
504
- isMbqi: settings.isMbqi || isMbqiByLogic(getSetup()),
625
+ // Deviation from Z3: the heap guard and a stack overflow, which Z3 lacks, read as an exhausted rlimit.
626
+ const getCancelMessage = (deadline: number) =>
627
+ Date.now() > deadline || options.signal?.aborted === true
628
+ ? "canceled"
629
+ : "max. resource limit exceeded";
630
+ // As in Z3, a timeout leaves "timeout" in the kernel, which reports it while its last search hasn't failed.
631
+ const getReasonUnknown = (solved: SolverAnswer, deadline: number) => {
632
+ const isTimedOut = solved.result === L_UNDEF && Date.now() > deadline;
633
+ const context = state.kernel?.context;
634
+ if (isTimedOut && context !== undefined) context.reasonUnknown = "timeout";
635
+ if (context !== undefined && solved.context === context) return context.getLastFailureMessage();
636
+ return isTimedOut ? "timeout" : (solved.reasonUnknown ?? getCancelMessage(deadline));
637
+ };
638
+ // As in Z3, a kernel loses the mbqi its logic turned on once it reads the parameters again.
639
+ const getKernelParams = (isSetUp = false) => ({
640
+ isMbqi: settings.isMbqi || (!isSetUp && isMbqiByLogic(getSetup())),
505
641
  mbqiMaxIterations: settings.mbqiMaxIterations,
506
642
  isFindingMacros: settings.isFindingMacros,
643
+ isCoreMinimizing: settings.parameters.get("smt.core.minimize") === "true",
507
644
  setup: getSetup(),
508
645
  });
509
646
  // mk_special_solver_for_logic gives these logics the finite-domain solver, incremental or not.
@@ -511,45 +648,62 @@ export const runSmtlibScript = (
511
648
  (state.logic === "QF_FD" || state.logic === "SAT") &&
512
649
  !settings.isProducingProofs &&
513
650
  !settings.parameters.has("tactic.default_tactic");
514
- const checkSat = (extra: number[]) => {
515
- state.manager.limit.restart(Date.now() + options.timeLimitMs);
651
+ const checkSat = (extra: number[], end: SmtToken) => {
652
+ const deadline = Date.now() + options.timeLimitMs;
653
+ state.manager.limit.restart(deadline);
516
654
  // opt::context::optimize answers as the search of the hard constraints does: once they are
517
655
  // satisfiable, optsmt and maxsmt only improve the model. The unported parts of optimization
518
656
  // only get that answer.
519
- if (state.objectives.length > 0 && optimize(extra)) return;
657
+ if (state.objectives.length > 0 && optimize(extra, end)) return;
520
658
  state.manager.limit.push(settings.rlimit);
521
659
  const isOptimizing = state.objectives.length > 0;
660
+ const manager = state.manager;
661
+ const names = state.names.filter((name) => name !== -1);
662
+ const isNamed = names.length > 0;
663
+ const isAssuming = isNamed || extra.length > 0;
664
+ if (isAssuming) state.isIncremental = true;
665
+ if (!isOptimizing) state.hasChecked = true;
666
+ const isKernelChecking =
667
+ isAssuming || (state.isIncremental && !isOptimizing && !isUsingFdSolver());
522
668
  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;
669
+ const kernel = isKernelChecking ? checkKernel(names, extra) : undefined;
534
670
  // Z3 retries a quantifier-free problem with its tactic when the incremental kernel gives up.
535
- const solved =
671
+ const isFromTactic =
536
672
  kernel === undefined ||
537
673
  (!isAssuming &&
538
674
  kernel.result === L_UNDEF &&
539
675
  !state.assertions.some((assertion) => manager.hasQuantifierFlags[assertion]) &&
540
- manager.limit.inc())
541
- ? { ...solveWithStrategy(), core: undefined }
542
- : kernel;
676
+ manager.limit.inc());
677
+ const solved = isFromTactic ? { ...solveWithStrategy(), core: undefined } : kernel;
543
678
  setCheck(solved.result, {
544
679
  context: solved.context,
545
680
  isOptimizing,
681
+ isFromTactic,
546
682
  model: solved.model,
547
683
  core: solved.core ?? solved.context?.unsatCore ?? [],
684
+ reasonUnknown: getReasonUnknown(solved, deadline),
548
685
  });
686
+ if (isFromTactic && isUsingFdSolver()) solved.model?.decRef();
549
687
  print(getVerdict(solved.result));
550
688
  } catch (error) {
551
- if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
552
- setCheck(L_UNDEF, { isOptimizing });
689
+ if (
690
+ !(
691
+ error instanceof SmtCanceledError ||
692
+ error instanceof SmtDefaultError ||
693
+ isStackOverflow(error)
694
+ )
695
+ )
696
+ throw error;
697
+ const context = isKernelChecking ? state.kernel?.context : undefined;
698
+ const reasonUnknown = isKernelChecking ? state.satSolver?.reasonUnknown : undefined;
699
+ setCheck(L_UNDEF, {
700
+ isOptimizing,
701
+ isFromTactic: !isKernelChecking,
702
+ reasonUnknown:
703
+ error instanceof SmtDefaultError
704
+ ? error.message
705
+ : getReasonUnknown({ result: L_UNDEF, context, reasonUnknown }, deadline),
706
+ });
553
707
  print("unknown");
554
708
  } finally {
555
709
  state.manager.limit.release();
@@ -563,8 +717,12 @@ export const runSmtlibScript = (
563
717
  if (check.model !== undefined) return check.model;
564
718
  if (check.isOptimizing) throw new SmtUnsupportedError("the models of optimization");
565
719
  if (check.context === undefined && check.status !== L_TRUE)
566
- throw new SmtUnsupportedError("the model of a canceled search");
567
- const model = check.context?.getModel() ?? new ProtoModel(state.manager);
720
+ throw check.isFromTactic
721
+ ? new SmtParseError("model is not available", list.end)
722
+ : new SmtUnsupportedError("the model of a canceled search");
723
+ const context = check.context;
724
+ const model = context === undefined ? new ProtoModel(state.manager) : context.getModel();
725
+ if (model === undefined) throw new SmtParseError("model is not available", list.end);
568
726
  model.incRef();
569
727
  check.model = model;
570
728
  return model;
@@ -573,6 +731,12 @@ export const runSmtlibScript = (
573
731
  state.check?.model?.decRef();
574
732
  state.check = undefined;
575
733
  };
734
+ // cmd_context::validate_check_sat_result runs after the answer is printed.
735
+ const validateCheck = (end: SmtToken) => {
736
+ const status = state.check?.status ?? L_UNDEF;
737
+ if (status !== L_UNDEF && settings.status !== L_UNDEF && status !== settings.status)
738
+ throw new SmtParseError(`check annotation that says ${getVerdict(settings.status)}`, end);
739
+ };
576
740
  // The check holds a reference to its model until clearCheck.
577
741
  const setCheck = (status: number, result: Partial<Omit<CheckResult, "status">> = {}) => {
578
742
  result.model?.incRef();
@@ -580,14 +744,12 @@ export const runSmtlibScript = (
580
744
  status,
581
745
  context: undefined,
582
746
  isOptimizing: false,
747
+ isFromTactic: false,
583
748
  model: undefined,
584
749
  core: undefined,
585
750
  ...result,
586
751
  };
587
752
  };
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
753
  const resetKernel = () => {
592
754
  const logic = state.logic;
593
755
  const parameters = settings.parameters;
@@ -601,48 +763,61 @@ export const runSmtlibScript = (
601
763
  parameters.get("tactic.default_tactic") === "sat" ||
602
764
  parameters.get("sat.smt") === "true" ||
603
765
  isEuf;
604
- state.eufSolver?.release();
766
+ state.satSolver?.release();
605
767
  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)
768
+ state.satSolver =
769
+ isSatSolver && !isFdSolver && parameters.get("sat.smt") !== "true"
770
+ ? new IncSatSolver(state.manager, getSatParams(parameters), true, isEuf ? mkThSolver : null)
609
771
  : undefined;
610
772
  for (let index = 0; index < state.scopes.length; index++) {
611
773
  state.kernel?.push();
612
- useEufSolver((solver) => solver.push());
774
+ useSatSolver((solver) => solver.push());
613
775
  }
614
776
  };
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;
777
+ const initManager = () => {
778
+ if (state.isProofsEnabled !== undefined) return;
779
+ state.isProofsEnabled = settings.parameters.get("proof") === "true";
780
+ if (state.logic === undefined || logicHasSeq(state.logic)) state.manager.initSeqPlugin();
781
+ if (state.logic === undefined) state.reader.registerList();
782
+ resetKernel();
783
+ };
784
+ // The parts of inc_sat_solver that are not ported leave its answers to the smt kernel.
785
+ const useSatSolver = <Result>(action: (solver: IncSatSolver) => Result) => {
786
+ const solver = state.satSolver;
618
787
  if (solver === undefined) return undefined;
619
788
  try {
620
789
  return action(solver);
621
790
  } catch (error) {
622
791
  if (!(error instanceof SmtUnsupportedError)) throw error;
623
792
  solver.release();
624
- state.eufSolver = undefined;
793
+ state.satSolver = undefined;
625
794
  return undefined;
626
795
  }
627
796
  };
628
797
  // solver_na2as asserts a named assertion as an implication from its name.
629
798
  const assertInKernel = (formula: number, name: number) => {
630
799
  const manager = state.manager;
800
+ useSatSolver((solver) =>
801
+ name === -1 ? solver.assertExpr(formula) : solver.assertNamed(formula, name),
802
+ );
803
+ const kernel = state.kernel;
804
+ if (kernel === undefined) return;
631
805
  const asserted = name === -1 ? formula : manager.mkApp(OP_IMPLIES, [name, formula], SORT_BOOL);
632
806
  manager.incRef(asserted);
633
- state.kernel?.assertExpr(asserted);
634
- useEufSolver((solver) => solver.assertExpr(asserted));
807
+ kernel.assertExpr(asserted);
635
808
  manager.decRef(asserted);
636
809
  };
637
- const checkKernel = (assumptions: number[]) => {
810
+ const checkKernel = (names: number[], extra: number[]) => {
638
811
  const kernel = state.kernel;
639
- const found = useEufSolver((solver) => {
640
- const result = solver.check(assumptions);
812
+ const assumptions = [...names, ...extra];
813
+ const found = useSatSolver((solver) => {
814
+ const result = solver.check(extra);
641
815
  return {
642
816
  result,
643
817
  context: undefined,
644
818
  model: result === L_TRUE ? (solver.getModel() ?? undefined) : undefined,
645
819
  core: result === L_FALSE ? [...solver.getUnsatCore()] : undefined,
820
+ reasonUnknown: solver.reasonUnknown,
646
821
  };
647
822
  });
648
823
  if (found !== undefined) return found;
@@ -652,11 +827,21 @@ export const runSmtlibScript = (
652
827
  context: kernel.context,
653
828
  model: undefined,
654
829
  core: undefined,
830
+ reasonUnknown: undefined,
655
831
  };
832
+ const solved = solveAssuming(
833
+ state.manager,
834
+ getNamedAssertions(),
835
+ assumptions,
836
+ getKernelParams(),
837
+ );
656
838
  return {
657
- ...solveAssuming(state.manager, getNamedAssertions(), assumptions, getKernelParams()),
839
+ ...solved,
658
840
  model: undefined,
659
841
  core: undefined,
842
+ // inc_sat_solver, which these logics use, keeps "no reason given" after an answer.
843
+ reasonUnknown:
844
+ solved.result === L_UNDEF ? solved.context.getLastFailureMessage() : "no reason given",
660
845
  };
661
846
  };
662
847
  const printDiagnostic = (line: string) => print(line, !settings.isDiagnosticOnStdout);
@@ -690,11 +875,10 @@ export const runSmtlibScript = (
690
875
  );
691
876
  return state.datalog;
692
877
  };
693
- const getTactic = (sexpr: SExpr, end: SmtList["end"]) =>
694
- compileTactic(getTacticEnvironment(), sexpr, end);
695
878
  const getGoal = (isTrackingDependencies = false) => {
696
879
  const goal = new Goal(state.manager);
697
880
  goal.isProofsEnabled = settings.isProducingProofs || state.isProofsEnabled === true;
881
+ goal.isModelsEnabled = settings.isProducingModels;
698
882
  goal.isCoresEnabled = settings.isProducingUnsatCores;
699
883
  for (const [index, assertion] of state.assertions.entries())
700
884
  goal.assert(
@@ -705,22 +889,43 @@ export const runSmtlibScript = (
705
889
  );
706
890
  return goal;
707
891
  };
892
+ const getCommandGoal = (isTrackingDependencies: boolean, end: SmtToken) => {
893
+ if (
894
+ settings.isProducingUnsatCores &&
895
+ (settings.isProducingProofs || state.isProofsEnabled === true)
896
+ )
897
+ throw new SmtParseError(
898
+ "Frontend does not support simultaneous generation of proofs and unsat cores",
899
+ end,
900
+ );
901
+ return getGoal(isTrackingDependencies);
902
+ };
708
903
  const hasNames = () => state.names.some((name) => name !== -1);
709
904
  // parse_check_sat shrinks the expression stack once the check has run.
710
- const checkSatAssuming = (items: SmtList["items"]) => {
905
+ const checkSatAssuming = (items: SmtList["items"], itemsEnd: SmtToken, end: SmtToken) => {
711
906
  const literals: number[] = [];
712
907
  try {
713
- for (const item of items) literals.push(state.reader.parseFormula(item));
714
- checkSat(literals);
908
+ for (const [index, item] of items.entries())
909
+ literals.push(
910
+ state.reader.parseFormula(
911
+ item,
912
+ items[index + 1] ?? itemsEnd,
913
+ "invalid check-sat command, argument must be a Boolean literal",
914
+ ),
915
+ );
916
+ checkSat(literals, end);
715
917
  } finally {
716
918
  for (const literal of literals) state.manager.decRef(literal);
717
919
  }
718
920
  };
719
921
  const addObjective = (list: SmtList, isMax: boolean) => {
720
- const term = state.reader.parseTerm(list.items[1] ?? list.end);
922
+ const term = state.reader.parseTerm(getFirstArgument(list));
721
923
  const sort = state.manager.sorts[term];
722
924
  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);
925
+ throw new SmtParseError(
926
+ "Objective must be bit-vector, integer or real",
927
+ list.items[2] ?? list.end,
928
+ );
724
929
  resetOptimizer();
725
930
  state.manager.incRef(term);
726
931
  state.objectives.push({
@@ -730,6 +935,8 @@ export const runSmtlibScript = (
730
935
  weights: [],
731
936
  id: null,
732
937
  });
938
+ if (settings.isPrintingSuccess) print("success");
939
+ checkArgumentCount(list, 1);
733
940
  };
734
941
  const releaseObjectives = (size: number, softSize: number) => {
735
942
  for (const index of state.softTrail.splice(softSize).reverse()) {
@@ -798,20 +1005,25 @@ export const runSmtlibScript = (
798
1005
  if (name.kind === "list")
799
1006
  throw new SmtUnsupportedError("an indexed function declaration reference");
800
1007
  throw new SmtParseError(
801
- "invalid function declaration reference, symbol or '(' expected got query",
1008
+ `invalid function declaration reference, symbol or '(' expected got ${name.lastId}`,
802
1009
  name,
803
1010
  );
804
1011
  }
805
1012
  const domain = reference.items[1] ?? reference.end;
806
1013
  if (domain.kind !== "list")
807
1014
  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}`,
1015
+ `Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.lastId}`,
809
1016
  domain,
810
1017
  );
811
- const sorts = domain.items.map((sort) => state.reader.parseSort(sort));
1018
+ const sorts = domain.items.map((sort) =>
1019
+ state.reader.parseSort(
1020
+ sort,
1021
+ "Invalid function name. Expecting sort list starting with '(' to disambiguate function name",
1022
+ ),
1023
+ );
812
1024
  if (reference.items[2] === undefined)
813
1025
  throw new SmtParseError("Invalid function name invalid sort, unexpected ')'", reference.end);
814
- const range = state.reader.parseSort(reference.items[2]);
1026
+ const range = state.reader.parseSort(reference.items[2], "Invalid function name");
815
1027
  const follower = reference.items[3] ?? reference.end;
816
1028
  const found = state.reader.getFuncs(name.text).find((decl) => {
817
1029
  const funcDecl = state.manager.funcDecls[decl];
@@ -830,16 +1042,87 @@ export const runSmtlibScript = (
830
1042
  throw new SmtUnsupportedError("a function declaration reference with trailing terms");
831
1043
  return found;
832
1044
  };
1045
+ // get_info_cmd prints in set_next_arg, before the parser checks the rest of the command.
1046
+ const printInfo = (list: SmtList, keyword: string) => {
1047
+ if (keyword === ":reason-unknown") {
1048
+ const check = state.check;
1049
+ const reasonUnknown =
1050
+ check === undefined
1051
+ ? "state of the most recent check-sat command is not known"
1052
+ : check.reasonUnknown;
1053
+ if (reasonUnknown === undefined)
1054
+ throw new SmtUnsupportedError("the information :reason-unknown");
1055
+ print(`(:reason-unknown "${reasonUnknown.replaceAll('"', '\\"')}")`);
1056
+ return;
1057
+ }
1058
+ if (keyword === ":rlimit") {
1059
+ initManager();
1060
+ print(`(:rlimit ${state.manager.limit.count})`);
1061
+ return;
1062
+ }
1063
+ if (keyword === ":error-behavior") {
1064
+ print(
1065
+ `(:error-behavior ${settings.isExitingOnError ? "immediate-exit" : "continued-execution"})`,
1066
+ );
1067
+ return;
1068
+ }
1069
+ if (keyword === ":name") {
1070
+ print('(:name "Z3")');
1071
+ return;
1072
+ }
1073
+ if (keyword === ":authors") {
1074
+ print(
1075
+ '(:authors "Leonardo de Moura, Nikolaj Bjorner, Lev Nachmanson and Christoph Wintersteiger")',
1076
+ );
1077
+ return;
1078
+ }
1079
+ if (keyword === ":version") {
1080
+ print('(:version "5.3.2")');
1081
+ return;
1082
+ }
1083
+ if (keyword === ":status") {
1084
+ print(`(:status ${getVerdict(settings.status)})`);
1085
+ return;
1086
+ }
1087
+ if (keyword === ":assertion-stack-levels") {
1088
+ print(`(:assertion-stack-levels ${state.scopes.length})`);
1089
+ return;
1090
+ }
1091
+ if (keyword === ":all-statistics" || keyword === ":parameters")
1092
+ throw new SmtUnsupportedError(`the information ${keyword}`);
1093
+ if (keyword !== ":?") {
1094
+ print("unsupported");
1095
+ printDiagnostic(`; ${keyword} line: ${list.line} position: ${list.column}`);
1096
+ }
1097
+ print("; Suppported get-info parameters:");
1098
+ for (const supported of GET_INFO_KEYWORDS) print(`; (get-info ${supported})`);
1099
+ };
1100
+ const printCore = () => {
1101
+ const check = state.check;
1102
+ if (check?.core === undefined)
1103
+ throw new SmtUnsupportedError("the unsat core of a tactic that drops dependencies");
1104
+ const kernel = state.kernel;
1105
+ if (kernel === undefined || check.context !== kernel.context) {
1106
+ print(`(${check.core.map(format).join(" ")})`);
1107
+ return;
1108
+ }
1109
+ state.manager.limit.restart(Date.now() + options.timeLimitMs);
1110
+ const core = new RefVector(state.manager);
1111
+ kernel.getUnsatCore(core);
1112
+ print(`(${core.items.map(format).join(" ")})`);
1113
+ core.reset();
1114
+ };
833
1115
  const runCommand = new Map<string, (list: SmtList) => void>([
834
1116
  [
835
1117
  "assert",
836
1118
  (list) => {
837
1119
  const term = list.items[1] ?? list.end;
838
- const assertion = state.reader.parseAssertion(term);
1120
+ const follower = list.items[2] ?? list.end;
1121
+ const assertion = state.reader.parseAssertion(term, follower);
839
1122
  const logicError = state.reader.getLogicError(assertion.formula);
840
1123
  if (logicError !== undefined) {
841
1124
  state.manager.decRef(assertion.formula);
842
- throw new SmtParseError(logicError, list.end);
1125
+ throw new SmtParseError(logicError, follower);
843
1126
  }
844
1127
  state.assertions.push(assertion.formula);
845
1128
  state.assertionTexts.push(
@@ -860,9 +1143,17 @@ export const runSmtlibScript = (
860
1143
  }
861
1144
  assertInKernel(assertion.formula, state.names[state.names.length - 1]);
862
1145
  clearCheck();
1146
+ if (follower !== list.end)
1147
+ throw new SmtParseError("invalid assert command, ')' expected", follower);
1148
+ },
1149
+ ],
1150
+ [
1151
+ "check-sat",
1152
+ (list) => {
1153
+ checkSatAssuming(list.items.slice(1), list.end, list.end);
1154
+ validateCheck(list.end);
863
1155
  },
864
1156
  ],
865
- ["check-sat", (list) => checkSatAssuming(list.items.slice(1))],
866
1157
  [
867
1158
  "declare-rel",
868
1159
  (list) => {
@@ -872,7 +1163,9 @@ export const runSmtlibScript = (
872
1163
  throw new SmtParseError("at least 2 arguments expected", list.end);
873
1164
  const decl = state.manager.mkFuncDecl(
874
1165
  name.text,
875
- domain.items.map((sort) => state.reader.parseSort(sort)),
1166
+ domain.items.map((sort) =>
1167
+ state.reader.parseSort(sort, "expecting sort list starting with '('"),
1168
+ ),
876
1169
  SORT_BOOL,
877
1170
  );
878
1171
  state.reader.insertFunc(decl, list.end);
@@ -890,7 +1183,7 @@ export const runSmtlibScript = (
890
1183
  list.end,
891
1184
  );
892
1185
  const manager = state.manager;
893
- const range = state.reader.parseSort(sort);
1186
+ const range = state.reader.parseSort(sort, "invalid command argument, sort expected");
894
1187
  const decl = manager.mkFuncDecl(name.text, [], range);
895
1188
  state.reader.insertFunc(decl, list.end);
896
1189
  getDatalog().registerVariable(manager.mkApp(decl, [], range));
@@ -902,7 +1195,10 @@ export const runSmtlibScript = (
902
1195
  const rule = list.items[1];
903
1196
  if (rule === undefined) throw new SmtParseError("invalid rule, expected formula", list.end);
904
1197
  const name = list.items[2];
905
- getDatalog().addRule(state.reader.parseFormula(rule), isSymbol(name) ? name.text : "");
1198
+ getDatalog().addRule(
1199
+ state.reader.parseFormula(rule, rule),
1200
+ isSymbol(name) ? name.text : undefined,
1201
+ );
906
1202
  },
907
1203
  ],
908
1204
  [
@@ -924,15 +1220,17 @@ export const runSmtlibScript = (
924
1220
  for (const assertion of state.assertions) datalog.assertExpr(assertion);
925
1221
  state.manager.limit.restart(Date.now() + options.timeLimitMs);
926
1222
  state.manager.limit.push(settings.rlimit);
1223
+ let status = L_UNDEF;
927
1224
  try {
928
- print(getVerdict(datalog.relQuery(relation)));
1225
+ status = datalog.relQuery(relation);
929
1226
  } catch (error) {
930
1227
  if (!(error instanceof SmtTacticError)) throw error;
931
1228
  print(`(error "query failed: ${error.message}")`);
932
- print("unknown");
933
1229
  } finally {
934
1230
  state.manager.limit.pop();
935
1231
  }
1232
+ print(status === L_UNDEF && datalog.isBounded ? "bounded" : getVerdict(status));
1233
+ datalog.isBounded = false;
936
1234
  },
937
1235
  ],
938
1236
  [
@@ -941,37 +1239,48 @@ export const runSmtlibScript = (
941
1239
  const params = getCommandParams(list.items, CHECK_SAT_USING_PARAMETERS);
942
1240
  if (list.items[1] === undefined)
943
1241
  throw new SmtParseError("check-sat-using needs a tactic argument", list.end);
944
- const builder = getTactic(list.items[1], list.end);
1242
+ expectClosed(list.items[1]);
1243
+ const builder = compileTactic(getTacticEnvironment(), list.items[1]);
945
1244
  const tactic = builder.build(params);
1245
+ const goal = getCommandGoal(builder.isTrackingDependencies, list.end);
946
1246
  clearCheck();
947
- state.manager.limit.restart(Date.now() + options.timeLimitMs);
1247
+ const deadline = Date.now() + options.timeLimitMs;
1248
+ state.manager.limit.restart(deadline);
948
1249
  state.manager.limit.push(settings.rlimit);
949
1250
  try {
950
- const checked = checkSatUsing(tactic, getGoal(builder.isTrackingDependencies));
1251
+ const checked = checkSatUsing(tactic, goal);
1252
+ const reasonUnknown = checked.reasonUnknown ?? getCancelMessage(deadline);
951
1253
  setCheck(checked.status, {
1254
+ isFromTactic: true,
952
1255
  model: checked.model,
953
1256
  core:
954
1257
  builder.isTrackingDependencies || !hasNames()
955
1258
  ? getDependencyValues(checked.core)
956
1259
  : undefined,
957
- reasonUnknown: checked.reasonUnknown,
1260
+ reasonUnknown,
958
1261
  });
959
- print(getVerdict(checked.status));
1262
+ print(
1263
+ checked.isConversionCanceled
1264
+ ? `(error "tactic failed: ${reasonUnknown}")`
1265
+ : getVerdict(checked.status),
1266
+ );
960
1267
  } finally {
961
1268
  state.manager.limit.pop();
962
1269
  }
1270
+ validateCheck(list.end);
963
1271
  },
964
1272
  ],
965
1273
  [
966
1274
  "check-sat-assuming",
967
1275
  (list) => {
968
- const literals = list.items[1];
969
- if (literals?.kind !== "list")
1276
+ const literals = list.items[1] ?? list.end;
1277
+ if (literals.kind !== "list")
970
1278
  throw new SmtParseError(
971
- "invalid check-sat-assuming command, '(' expected",
972
- literals ?? list.end,
1279
+ `invalid check-sat-assuming command, '(', expected got ${literals.lastId}`,
1280
+ literals,
973
1281
  );
974
- checkSatAssuming(literals.items);
1282
+ checkSatAssuming(literals.items, literals.end, list.end);
1283
+ validateCheck(list.end);
975
1284
  },
976
1285
  ],
977
1286
  [
@@ -982,13 +1291,17 @@ export const runSmtlibScript = (
982
1291
  if (terms === undefined)
983
1292
  throw new SmtParseError("invalid command, argument(s) missing", list.end);
984
1293
  if (terms.kind !== "list")
985
- throw new SmtParseError("invalid list of terms, '(' expected", terms);
1294
+ throw new SmtParseError(
1295
+ `invalid list of terms, '(' expected got ${terms.lastId}`,
1296
+ terms,
1297
+ );
986
1298
  return terms.items.map((item) => state.reader.parseTerm(item));
987
1299
  });
988
1300
  if (list.items.length > 3)
989
1301
  throw new SmtParseError("invalid command, too many arguments", list.items[3]);
990
1302
  clearCheck();
991
- manager.limit.restart(Date.now() + options.timeLimitMs);
1303
+ const deadline = Date.now() + options.timeLimitMs;
1304
+ manager.limit.restart(deadline);
992
1305
  manager.limit.push(settings.rlimit);
993
1306
  const names = state.names.filter((name) => name !== -1);
994
1307
  try {
@@ -1002,7 +1315,11 @@ export const runSmtlibScript = (
1002
1315
  assumptions,
1003
1316
  vars,
1004
1317
  );
1005
- setCheck(found.result, { model: found.model });
1318
+ setCheck(found.result, {
1319
+ model: found.model,
1320
+ core: found.core,
1321
+ reasonUnknown: found.reasonUnknown,
1322
+ });
1006
1323
  print(getVerdict(found.result));
1007
1324
  print("");
1008
1325
  for (const consequence of found.consequences.items) display(consequence);
@@ -1013,11 +1330,22 @@ export const runSmtlibScript = (
1013
1330
  if (state.kernel === undefined)
1014
1331
  for (const assertion of getNamedAssertions()) kernel.assertExpr(assertion);
1015
1332
  const found = getConsequences(kernel, [...names, ...assumptions], vars);
1016
- setCheck(found.result, { context: kernel.context, core: kernel.context.unsatCore });
1333
+ setCheck(found.result, {
1334
+ context: kernel.context,
1335
+ core: kernel.context.unsatCore,
1336
+ reasonUnknown: kernel.context.getLastFailureMessage(),
1337
+ });
1017
1338
  print(getVerdict(found.result));
1018
1339
  print("");
1019
1340
  for (const consequence of found.consequences.items) display(consequence);
1020
1341
  found.consequences.reset();
1342
+ } catch (error) {
1343
+ if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
1344
+ const reasonUnknown = getCancelMessage(deadline);
1345
+ if (state.kernel !== undefined) state.kernel.context.reasonUnknown = reasonUnknown;
1346
+ setCheck(L_UNDEF, { reasonUnknown });
1347
+ print("unknown");
1348
+ print("");
1021
1349
  } finally {
1022
1350
  manager.limit.pop();
1023
1351
  }
@@ -1061,39 +1389,58 @@ export const runSmtlibScript = (
1061
1389
  assertions: state.assertions.length,
1062
1390
  objectives: state.objectives.length,
1063
1391
  softTrail: state.softTrail.length,
1392
+ rlimit: settings.rlimit,
1064
1393
  });
1065
1394
  state.reader.push();
1066
1395
  state.isIncremental = true;
1067
- state.kernel?.push();
1068
- useEufSolver((solver) => solver.push());
1396
+ const limit = state.manager.limit;
1397
+ limit.push(settings.rlimit);
1398
+ try {
1399
+ state.kernel?.push();
1400
+ useSatSolver((solver) => solver.push());
1401
+ } catch (error) {
1402
+ if (!(error instanceof SmtCanceledError)) throw error;
1403
+ throw new SmtParseError(limit.getCancelMessage(), list.end);
1404
+ } finally {
1405
+ limit.pop();
1406
+ }
1069
1407
  }
1408
+ if (list.items[2] !== undefined)
1409
+ throw new SmtParseError("invalid push command, ')' expected", list.items[2]);
1070
1410
  },
1071
1411
  ],
1072
1412
  [
1073
1413
  "pop",
1074
1414
  (list) => {
1075
1415
  const count = getScopeCount(list);
1416
+ const follower = list.items[2] ?? list.end;
1417
+ clearCheck();
1076
1418
  if (count > state.scopes.length)
1077
1419
  throw new SmtParseError(
1078
1420
  "invalid pop command, argument is greater than the current stack depth",
1079
- list.end,
1421
+ follower,
1080
1422
  );
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;
1423
+ if (count > 0) {
1424
+ state.isIncremental = true;
1425
+ const scope = state.scopes[state.scopes.length - count];
1426
+ state.kernel?.pop(count);
1427
+ useSatSolver((solver) => solver.pop(count));
1428
+ state.reader.pop(count);
1429
+ restoreAssertions(scope.assertions);
1430
+ settings.rlimit = scope.rlimit;
1431
+ resetOptimizer();
1432
+ releaseObjectives(scope.objectives, scope.softTrail);
1433
+ state.scopes.length -= count;
1434
+ }
1435
+ if (follower !== list.end)
1436
+ throw new SmtParseError("invalid pop command, ')' expected", follower);
1092
1437
  },
1093
1438
  ],
1094
1439
  [
1095
1440
  "reset",
1096
- () => {
1441
+ (list) => {
1442
+ if (list.items[1] !== undefined)
1443
+ throw new SmtParseError("invalid reset command, ')' expected", list.items[1]);
1097
1444
  clearCheck();
1098
1445
  resetOptimizer();
1099
1446
  state = createState();
@@ -1101,12 +1448,17 @@ export const runSmtlibScript = (
1101
1448
  ],
1102
1449
  [
1103
1450
  "reset-assertions",
1104
- () => {
1105
- clearCheck();
1451
+ (list) => {
1452
+ checkArgumentCount(list, 0);
1106
1453
  restoreAssertions(0);
1107
1454
  resetOptimizer();
1108
1455
  releaseObjectives(0, 0);
1109
- state.scopes = state.scopes.map(() => ({ assertions: 0, objectives: 0, softTrail: 0 }));
1456
+ state.scopes = state.scopes.map((scope) => ({
1457
+ ...scope,
1458
+ assertions: 0,
1459
+ objectives: 0,
1460
+ softTrail: 0,
1461
+ }));
1110
1462
  if (state.isProofsEnabled !== undefined) resetKernel();
1111
1463
  state.isIncremental = state.scopes.length > 0;
1112
1464
  state.hasChecked = false;
@@ -1124,7 +1476,17 @@ export const runSmtlibScript = (
1124
1476
  manager,
1125
1477
  getRewriterOptions(manager, getSimplifyParams(list.items.slice(2))),
1126
1478
  );
1127
- const simplified = rewriter.rewrite(term);
1479
+ // simplify_cmd prints a failure of the rewriter and then the term as it was.
1480
+ const simplified = (() => {
1481
+ try {
1482
+ return rewriter.rewrite(term);
1483
+ } catch (error) {
1484
+ if (!(error instanceof SmtDefaultError)) throw error;
1485
+ print(`(error "simplifier failed: ${error.message}")`);
1486
+ manager.incRef(term);
1487
+ return term;
1488
+ }
1489
+ })();
1128
1490
  rewriter.cleanup();
1129
1491
  display(simplified);
1130
1492
  rewriter.release();
@@ -1143,8 +1505,7 @@ export const runSmtlibScript = (
1143
1505
  manager.incRef(term);
1144
1506
  const visited = new Set<number>();
1145
1507
  const todo = [term];
1146
- while (todo.length > 0) {
1147
- const expr = todo.pop() as number;
1508
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
1148
1509
  if (visited.has(expr)) continue;
1149
1510
  visited.add(expr);
1150
1511
  const family = manager.kinds[expr] === KIND_APP ? manager.getFamily(expr) : -1;
@@ -1168,13 +1529,19 @@ export const runSmtlibScript = (
1168
1529
  const params = getCommandParams(list.items, APPLY_PARAMETERS);
1169
1530
  if (list.items[1] === undefined)
1170
1531
  throw new SmtParseError("apply needs a tactic argument", list.end);
1171
- const builder = getTactic(list.items[1], list.end);
1532
+ expectClosed(list.items[1]);
1533
+ // apply_tactic_cmd, unlike check-sat-using, gives the tactic no logic.
1534
+ const builder = compileTactic(
1535
+ { ...getTacticEnvironment(), setup: { ...getSetup(), logic: undefined } },
1536
+ list.items[1],
1537
+ );
1172
1538
  const tactic = builder.build(params);
1539
+ const input = getCommandGoal(builder.isTrackingDependencies, list.end);
1173
1540
  const isPrintingDependencies = params.get("print_dependencies") === true;
1174
1541
  if (isPrintingDependencies && !builder.isTrackingDependencies && hasNames())
1175
1542
  throw new SmtUnsupportedError("the dependencies of a tactic that drops dependencies");
1176
1543
  state.manager.limit.restart(Date.now() + options.timeLimitMs);
1177
- const input = getGoal(builder.isTrackingDependencies);
1544
+ state.manager.limit.push(settings.rlimit);
1178
1545
  const goals = (() => {
1179
1546
  try {
1180
1547
  return applyTactic(tactic, input);
@@ -1182,6 +1549,8 @@ export const runSmtlibScript = (
1182
1549
  if (!(error instanceof SmtTacticError)) throw error;
1183
1550
  print(`(error "tactic failed: ${error.message}")`);
1184
1551
  return undefined;
1552
+ } finally {
1553
+ state.manager.limit.pop();
1185
1554
  }
1186
1555
  })();
1187
1556
  // apply_tactic_cmd releases the result goals and then the input goal.
@@ -1239,8 +1608,7 @@ export const runSmtlibScript = (
1239
1608
  const decls = new Set<number>();
1240
1609
  for (const assertion of assertions) {
1241
1610
  const todo = [assertion];
1242
- while (todo.length > 0) {
1243
- const expr = todo.pop() as number;
1611
+ for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
1244
1612
  if (visited.has(expr)) continue;
1245
1613
  visited.add(expr);
1246
1614
  if (manager.kinds[expr] === KIND_QUANTIFIER) {
@@ -1281,6 +1649,7 @@ export const runSmtlibScript = (
1281
1649
  [
1282
1650
  "get-assertions",
1283
1651
  (list) => {
1652
+ checkArgumentCount(list, 0);
1284
1653
  if (!settings.isInteractive)
1285
1654
  throw new SmtParseError(
1286
1655
  "command is only available in interactive mode, use command (set-option :interactive-mode true)",
@@ -1292,17 +1661,29 @@ export const runSmtlibScript = (
1292
1661
  [
1293
1662
  "get-unsat-core",
1294
1663
  (list) => {
1664
+ checkArgumentCount(list, 0);
1295
1665
  if (!settings.isProducingUnsatCores)
1296
1666
  throw new SmtParseError(
1297
1667
  "unsat core construction is not enabled, use command (set-option :produce-unsat-cores true)",
1298
1668
  list.end,
1299
1669
  );
1300
- const check = state.check;
1301
- if (check === undefined || check.status !== L_FALSE)
1670
+ if (state.check?.status !== L_FALSE)
1302
1671
  throw new SmtParseError("unsat core is not available", list.end);
1303
- if (check.core === undefined)
1304
- throw new SmtUnsupportedError("the unsat core of a tactic that drops dependencies");
1305
- print(`(${check.core.map(format).join(" ")})`);
1672
+ printCore();
1673
+ },
1674
+ ],
1675
+ [
1676
+ "get-unsat-assumptions",
1677
+ (list) => {
1678
+ checkArgumentCount(list, 0);
1679
+ if (!settings.isProducingUnsatAssumptions)
1680
+ throw new SmtParseError(
1681
+ "unsat assumptions construction is not enabled, use command (set-option :produce-unsat-assumptions true)",
1682
+ list.end,
1683
+ );
1684
+ if (state.check?.status !== L_FALSE)
1685
+ throw new SmtParseError("unsat assumptions is not available", list.end);
1686
+ printCore();
1306
1687
  },
1307
1688
  ],
1308
1689
  [
@@ -1310,13 +1691,19 @@ export const runSmtlibScript = (
1310
1691
  (list) => {
1311
1692
  const target = list.items[1];
1312
1693
  const term = target === undefined ? -1 : state.reader.parseTerm(target);
1313
- if (list.items.length > 2) throw new SmtUnsupportedError("the parameters of eval");
1694
+ const parameter = list.items[2];
1695
+ if (parameter !== undefined && parameter.kind !== "keyword")
1696
+ throw new SmtParseError("invalid command argument, keyword expected", parameter);
1697
+ if (parameter !== undefined) throw new SmtUnsupportedError("the parameters of eval");
1314
1698
  const model = getModel(list);
1315
1699
  if (term === -1) throw new SmtParseError("no arguments passed to eval", list.end);
1316
1700
  const manager = state.manager;
1317
1701
  manager.incRef(term);
1318
- const value = model.eval(term, false);
1702
+ const evaluator = new ModelEvaluator(manager, model);
1703
+ const value = evaluator.rewrite(term);
1319
1704
  display(value);
1705
+ // eval_cmd frees its model_evaluator before the value, and the parser frees the term last.
1706
+ evaluator.release();
1320
1707
  manager.decRef(value);
1321
1708
  manager.decRef(term);
1322
1709
  },
@@ -1324,30 +1711,57 @@ export const runSmtlibScript = (
1324
1711
  [
1325
1712
  "get-value",
1326
1713
  (list) => {
1327
- const terms = list.items[1];
1328
- if (terms?.kind !== "list")
1329
- throw new SmtParseError("invalid get-value command, '(' expected", terms ?? list.end);
1714
+ const terms = list.items[1] ?? list.end;
1715
+ if (terms.kind !== "list")
1716
+ throw new SmtParseError(
1717
+ `invalid get-value command, '(' expected got ${terms.lastId}`,
1718
+ terms,
1719
+ );
1330
1720
  const manager = state.manager;
1331
1721
  const exprs = terms.items.map((item) => state.reader.parseTerm(item));
1332
1722
  if (exprs.length === 0)
1333
1723
  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");
1724
+ const extra = list.items[2];
1725
+ if (
1726
+ extra?.kind === "keyword" &&
1727
+ (extra.text === ":model-index" || extra.text === ":model_index")
1728
+ )
1729
+ throw new SmtUnsupportedError("the model index of get-value");
1730
+ if (extra !== undefined)
1731
+ throw new SmtParseError("invalid get-value command, ')' expected", extra);
1335
1732
  const model = getModel(list);
1733
+ pendingText += "(";
1336
1734
  model.compact();
1337
1735
  // Z3 prints each term as the script spells it, from the end of the term before.
1338
1736
  const offsets = [
1339
1737
  terms.offset + 1,
1340
1738
  ...terms.items.map((item) => (item.kind === "list" ? item.end : item).endOffset),
1341
1739
  ];
1342
- const lines = exprs.map((expr, index) => {
1740
+ exprs.forEach((expr, index) => {
1343
1741
  manager.incRef(expr);
1344
1742
  const value = model.eval(expr, true);
1345
- const line = `(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
1743
+ pendingText += `${index > 0 ? "\n " : ""}(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
1346
1744
  manager.decRef(value);
1347
1745
  manager.decRef(expr);
1348
- return line;
1349
1746
  });
1350
- print(`(${lines.join("\n ")})`);
1747
+ print(")");
1748
+ },
1749
+ ],
1750
+ [
1751
+ "get-assignment",
1752
+ (list) => {
1753
+ checkArgumentCount(list, 0);
1754
+ const manager = state.manager;
1755
+ const model = getModel(list);
1756
+ const assignments = state.reader.getConstantMacros().flatMap((macro) => {
1757
+ if (manager.sorts[macro.body] !== SORT_BOOL) return [];
1758
+ const value = model.eval(macro.body, true);
1759
+ const assignment = `(${getQuotedName(macro.name)} ${manager.isTrue(value)})`;
1760
+ const isDecided = manager.isTrue(value) || manager.isFalse(value);
1761
+ manager.decRef(value);
1762
+ return isDecided ? [assignment] : [];
1763
+ });
1764
+ print(`(${assignments.join(" ")})`);
1351
1765
  },
1352
1766
  ],
1353
1767
  [
@@ -1362,14 +1776,27 @@ export const runSmtlibScript = (
1362
1776
  [
1363
1777
  "get-model",
1364
1778
  (list) => {
1365
- if (list.items.length > 1) throw new SmtUnsupportedError("the index of get-model");
1779
+ for (const index of list.items.slice(1)) {
1780
+ if (index.kind !== "numeral")
1781
+ throw new SmtParseError("invalid command argument, unsigned integer expected", index);
1782
+ if (!isUnsigned(index.text))
1783
+ throw new SmtParseError(
1784
+ "invalid indexed identifier, index is too big to fit in an unsigned machine integer",
1785
+ index,
1786
+ );
1787
+ }
1366
1788
  const manager = state.manager;
1367
1789
  const model = getModel(list);
1790
+ const last = list.items[list.items.length - 1];
1791
+ // get_model_cmd takes any number of indices and keeps the last.
1792
+ if (last.kind === "numeral" && BigInt(last.text) > 0n)
1793
+ throw new SmtUnsupportedError("the index of get-model");
1368
1794
  model.compact();
1369
1795
  for (const decl of state.reader.getDeclaredFuncs()) {
1370
1796
  const funcDecl = manager.funcDecls[decl];
1371
1797
  if (
1372
1798
  funcDecl.family !== FAMILY_USER ||
1799
+ manager.macros.has(decl) ||
1373
1800
  model.constInterps.has(decl) ||
1374
1801
  model.funcInterps.has(decl)
1375
1802
  )
@@ -1387,7 +1814,13 @@ export const runSmtlibScript = (
1387
1814
  print(`(\n${printModel(manager, getPrintEnvironment(), model, 2)})`);
1388
1815
  },
1389
1816
  ],
1390
- ["display", (list) => display(state.reader.parseTerm(list.items[1] ?? list.end))],
1817
+ [
1818
+ "display",
1819
+ (list) => {
1820
+ display(state.reader.parseTerm(getFirstArgument(list)));
1821
+ checkArgumentCount(list, 1);
1822
+ },
1823
+ ],
1391
1824
  [
1392
1825
  "dbg-lt",
1393
1826
  (list) => {
@@ -1400,7 +1833,13 @@ export const runSmtlibScript = (
1400
1833
  "dbg-some-value",
1401
1834
  (list) => {
1402
1835
  display(
1403
- getManagerSomeValue(state.manager, state.reader.parseSort(list.items[1] ?? list.end)),
1836
+ getManagerSomeValue(
1837
+ state.manager,
1838
+ state.reader.parseSort(
1839
+ list.items[1] ?? list.end,
1840
+ "invalid command argument, sort expected",
1841
+ ),
1842
+ ),
1404
1843
  );
1405
1844
  },
1406
1845
  ],
@@ -1436,10 +1875,11 @@ export const runSmtlibScript = (
1436
1875
  [
1437
1876
  "echo",
1438
1877
  (list) => {
1439
- const message = list.items[1];
1440
- if (message?.kind !== "string")
1441
- throw new SmtParseError("invalid echo command, string expected", message ?? list.end);
1878
+ const message = getFirstArgument(list);
1879
+ if (message.kind !== "string")
1880
+ throw new SmtParseError("invalid command argument, string expected", message);
1442
1881
  print(message.text);
1882
+ checkArgumentCount(list, 1);
1443
1883
  },
1444
1884
  ],
1445
1885
  [
@@ -1450,10 +1890,28 @@ export const runSmtlibScript = (
1450
1890
  const optionName = `:${getParameterName(keyword)}`;
1451
1891
  const value = list.items[2];
1452
1892
  const isTrue = isSymbol(value, "true");
1893
+ if (
1894
+ (keyword === ":produce-proofs" ||
1895
+ keyword === ":produce-unsat-cores" ||
1896
+ keyword === ":produce-unsat-assumptions") &&
1897
+ state.assertions.length > 0
1898
+ )
1899
+ throw new SmtParseError(
1900
+ `error setting '${keyword}', option value cannot be modified after assertions have been added`,
1901
+ value ?? list.end,
1902
+ );
1453
1903
  if (keyword === ":produce-models") settings.isProducingModels = isTrue;
1454
1904
  if (keyword === ":produce-unsat-cores") settings.isProducingUnsatCores = isTrue;
1905
+ if (keyword === ":produce-unsat-assumptions") settings.isProducingUnsatAssumptions = isTrue;
1455
1906
  if (keyword === ":produce-proofs") settings.isProducingProofs = isTrue;
1456
- if (keyword === ":interactive-mode") settings.isInteractive = isTrue;
1907
+ if (keyword === ":interactive-mode" || keyword === ":produce-assertions") {
1908
+ if (state.isProofsEnabled !== undefined)
1909
+ throw new SmtParseError(
1910
+ "error setting ':produce-assertions', option value cannot be modified after initialization",
1911
+ value ?? list.end,
1912
+ );
1913
+ settings.isInteractive = isTrue;
1914
+ }
1457
1915
  if (keyword === ":diagnostic-output-channel")
1458
1916
  settings.isDiagnosticOnStdout = value?.kind === "string" && value.text === "stdout";
1459
1917
  if (keyword === ":int-real-coercions" && !isTrue)
@@ -1466,13 +1924,12 @@ export const runSmtlibScript = (
1466
1924
  );
1467
1925
  settings.isExitingOnError = isSymbol(value, "immediate-exit");
1468
1926
  }
1469
- if (
1927
+ const isParameter =
1470
1928
  keyword !== "" &&
1471
1929
  !BUILTIN_OPTIONS.has(keyword) &&
1472
1930
  value !== undefined &&
1473
- value.kind !== "list"
1474
- )
1475
- settings.parameters.set(getParameterName(keyword), value.text);
1931
+ value.kind !== "list";
1932
+ if (isParameter) settings.parameters.set(getParameterName(keyword), value.text);
1476
1933
  if (optionName === ":print_success") settings.isPrintingSuccess = isTrue;
1477
1934
  if (
1478
1935
  !BUILTIN_OPTIONS.has(keyword) &&
@@ -1485,6 +1942,9 @@ export const runSmtlibScript = (
1485
1942
  settings.mbqiMaxIterations = Number(value.text);
1486
1943
  if (optionName === ":rlimit" && value?.kind === "numeral")
1487
1944
  settings.rlimit = Number(value.text);
1945
+ const kernel = state.kernel;
1946
+ if (isParameter && kernel !== undefined)
1947
+ kernel.updateParams(getKernelParams(kernel.isSetUp));
1488
1948
  if (optionName === ":rewriter.hi_div0") {
1489
1949
  settings.isHiDiv0 = isTrue;
1490
1950
  state.manager.isHiDiv0 = isTrue;
@@ -1519,6 +1979,9 @@ export const runSmtlibScript = (
1519
1979
  [":print-success", settings.isPrintingSuccess],
1520
1980
  [":produce-models", settings.isProducingModels],
1521
1981
  [":produce-unsat-cores", settings.isProducingUnsatCores],
1982
+ [":produce-unsat-assumptions", settings.isProducingUnsatAssumptions],
1983
+ [":interactive-mode", settings.isInteractive],
1984
+ [":produce-assertions", settings.isInteractive],
1522
1985
  [":int-real-coercions", true],
1523
1986
  [":error-behavior", settings.isExitingOnError ? "immediate-exit" : "continued-execution"],
1524
1987
  ]);
@@ -1536,44 +1999,20 @@ export const runSmtlibScript = (
1536
1999
  "get-info",
1537
2000
  (list) => {
1538
2001
  const info = list.items[1];
1539
- if (info?.kind !== "keyword")
1540
- throw new SmtParseError("invalid command argument, keyword expected", info ?? list.end);
1541
- const optimizer = state.optimizer;
1542
- 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
- const reasonUnknown =
1553
- check === undefined
1554
- ? "state of the most recent check-sat command is not known"
1555
- : check.reasonUnknown;
1556
- if (info.text === ":reason-unknown" && reasonUnknown !== undefined) {
1557
- print(`(:reason-unknown "${reasonUnknown.replaceAll('"', '\\"')}")`);
1558
- return;
1559
- }
1560
- if (info.text === ":rlimit") {
1561
- print(`(:rlimit ${state.manager.limit.count})`);
1562
- return;
1563
- }
1564
- if (info.text !== ":error-behavior")
1565
- throw new SmtUnsupportedError(`the information ${info.text}`);
1566
- print(
1567
- `(:error-behavior ${settings.isExitingOnError ? "immediate-exit" : "continued-execution"})`,
1568
- );
2002
+ if (info === undefined)
2003
+ throw new SmtParseError("invalid command, argument(s) missing", list.end);
2004
+ if (info.kind !== "keyword")
2005
+ throw new SmtParseError("invalid command argument, keyword expected", info);
2006
+ printInfo(list, info.text);
2007
+ checkArgumentCount(list, 1);
1569
2008
  },
1570
2009
  ],
1571
2010
  [
1572
2011
  "set-logic",
1573
2012
  (list) => {
1574
- const logic = list.items[1];
2013
+ const logic = getFirstArgument(list);
1575
2014
  if (!isSymbol(logic))
1576
- throw new SmtParseError("invalid logic name, symbol expected", logic ?? list.end);
2015
+ throw new SmtParseError("invalid command argument, symbol expected", logic);
1577
2016
  if (state.logic !== undefined)
1578
2017
  throw new SmtParseError("the logic has already been set", logic);
1579
2018
  if (state.assertions.length > 0)
@@ -1583,6 +2022,7 @@ export const runSmtlibScript = (
1583
2022
  printDiagnostic(
1584
2023
  `; ignoring unsupported logic ${logic.text} line: ${list.line} position: ${list.column}`,
1585
2024
  );
2025
+ checkArgumentCount(list, 1);
1586
2026
  return;
1587
2027
  }
1588
2028
  state.logic = logic.text;
@@ -1590,14 +2030,37 @@ export const runSmtlibScript = (
1590
2030
  state.reader = createSmtlibReader(state.manager, logic.text, settings.parserOptions);
1591
2031
  else {
1592
2032
  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.
2033
+ // Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop and keeps what they asserted.
1595
2034
  resetKernel();
1596
2035
  }
1597
2036
  if (settings.isPrintingSuccess) print("success");
2037
+ checkArgumentCount(list, 1);
2038
+ },
2039
+ ],
2040
+ [
2041
+ "set-info",
2042
+ (list) => {
2043
+ const info = list.items[1];
2044
+ if (info === undefined)
2045
+ throw new SmtParseError("invalid command, argument(s) missing", list.end);
2046
+ if (info.kind !== "keyword")
2047
+ throw new SmtParseError("invalid command argument, keyword expected", info);
2048
+ const value = list.items[2];
2049
+ if (value === undefined)
2050
+ throw new SmtParseError("invalid command, argument(s) missing", list.end);
2051
+ if (value.kind === "list" || value.kind === "keyword" || value.kind === "eof")
2052
+ throw new SmtParseError("invalid option value", value);
2053
+ if (info.text === ":status" && value.kind === "symbol") {
2054
+ const status = [L_TRUE, L_FALSE, L_UNDEF].find(
2055
+ (innerStatus) => getVerdict(innerStatus) === value.text,
2056
+ );
2057
+ if (status === undefined) throw new SmtParseError("invalid ':status' attribute", value);
2058
+ settings.status = status;
2059
+ }
2060
+ if (list.items[3] !== undefined)
2061
+ throw new SmtParseError("invalid command, too many arguments", list.items[3]);
1598
2062
  },
1599
2063
  ],
1600
- ["set-info", () => {}],
1601
2064
  ]);
1602
2065
  const run = (list: SmtList) => {
1603
2066
  const head = list.items[0];
@@ -1606,18 +2069,34 @@ export const runSmtlibScript = (
1606
2069
  const command = DECLARATIONS.has(head.text)
1607
2070
  ? (declaration: SmtList) => state.reader.declareCommand(declaration)
1608
2071
  : runCommand.get(head.text);
1609
- if (command === undefined) throw new SmtUnsupportedError(`the command ${head.text}`);
1610
- if (!MANAGERLESS_COMMANDS.has(head.text) && state.isProofsEnabled === undefined) {
1611
- state.isProofsEnabled = settings.parameters.get("proof") === "true";
1612
- resetKernel();
2072
+ if (command === undefined && UNPORTED_COMMANDS.has(head.text))
2073
+ throw new SmtUnsupportedError(`the command ${head.text}`);
2074
+ if (command === undefined) {
2075
+ expectClosed(list);
2076
+ print("unsupported");
2077
+ printDiagnostic(`; ${head.text} line: ${list.end.line} position: ${list.end.column}`);
2078
+ return;
2079
+ }
2080
+ // Z3's scoped_timer ends with the command that set it, so a command starts without one.
2081
+ state.manager.limit.restart(Infinity);
2082
+ if (!MANAGERLESS_COMMANDS.has(head.text)) initManager();
2083
+ try {
2084
+ command(list);
2085
+ } catch (error) {
2086
+ if (!(error instanceof SmtDefaultError)) throw error;
2087
+ throw new SmtParseError(error.message, list.end);
1613
2088
  }
1614
- command(list);
1615
2089
  if (settings.isPrintingSuccess && SILENT_COMMANDS.has(head.text)) print("success");
1616
2090
  };
1617
2091
  for (;;) {
1618
2092
  try {
1619
- const list = commands.read();
1620
- if (list === undefined || isSymbol(list.items[0], "exit")) break;
2093
+ const list = commands.readCommand();
2094
+ if (list === undefined) break;
2095
+ if (isSymbol(list.items[0], "exit")) {
2096
+ checkArgumentCount(list, 0);
2097
+ if (settings.isPrintingSuccess) print("success");
2098
+ break;
2099
+ }
1621
2100
  run(list);
1622
2101
  } catch (error) {
1623
2102
  if (!(error instanceof SmtParseError)) throw error;