tla-ts 0.0.9 → 0.0.10-dev.094b9b512

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 (622) hide show
  1. package/README.md +30 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +40 -37
  5. package/dist/deciders.js +47 -44
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2658 -410
  15. package/dist/prove.js +2657 -409
  16. package/dist/run.cjs +144 -31
  17. package/dist/run.js +144 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +6 -6
  23. package/dist/worker.js +6 -6
  24. package/package.json +3 -1
  25. package/src/ast.ts +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +208 -54
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +100 -57
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +83 -101
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +18 -43
  66. package/src/obligations/anonymize.ts +119 -90
  67. package/src/obligations/enabled-axioms.ts +218 -0
  68. package/src/obligations/equality.ts +2 -2
  69. package/src/obligations/expression.ts +38 -25
  70. package/src/obligations/format.ts +1 -9
  71. package/src/obligations/generate.ts +67 -63
  72. package/src/obligations/index.ts +38 -20
  73. package/src/obligations/levels.ts +28 -17
  74. package/src/obligations/module.ts +29 -54
  75. package/src/obligations/normalize.ts +31 -36
  76. package/src/obligations/operators.ts +1 -2
  77. package/src/obligations/pragma.ts +53 -25
  78. package/src/obligations/printer.ts +90 -57
  79. package/src/obligations/proof.ts +4 -5
  80. package/src/obligations/regroup.ts +1 -4
  81. package/src/obligations/simplify.ts +58 -62
  82. package/src/obligations/source.ts +119 -95
  83. package/src/obligations/subexpression.ts +51 -27
  84. package/src/obligations/substitution.ts +2 -4
  85. package/src/obligations/temporal.ts +13 -19
  86. package/src/obligations/tuples.ts +3 -9
  87. package/src/parallel-worker.ts +30 -60
  88. package/src/parallel.ts +57 -71
  89. package/src/parser.ts +961 -387
  90. package/src/pcal/ast.ts +53 -86
  91. package/src/pcal/parse.ts +144 -219
  92. package/src/pcal/tokenize.ts +91 -131
  93. package/src/pcal/translate.ts +83 -130
  94. package/src/pcal/validate.ts +48 -68
  95. package/src/pretty-print.ts +7 -8
  96. package/src/prover/decide-pool.ts +8 -13
  97. package/src/prover/deciders.ts +19 -13
  98. package/src/prover/first-order.ts +0 -11
  99. package/src/prover/isabelle/decide.ts +3 -31
  100. package/src/prover/isabelle/encode.ts +82 -62
  101. package/src/prover/isabelle/isar/attrib.ts +219 -0
  102. package/src/prover/isabelle/isar/context.ts +336 -0
  103. package/src/prover/isabelle/isar/induct.ts +392 -0
  104. package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
  105. package/src/prover/isabelle/isar/method.ts +513 -225
  106. package/src/prover/isabelle/isar/proof.ts +569 -23
  107. package/src/prover/isabelle/isar/rule-cases.ts +234 -0
  108. package/src/prover/isabelle/isar/theory.ts +490 -89
  109. package/src/prover/isabelle/isar/toplevel.ts +341 -0
  110. package/src/prover/isabelle/isar/type-check.ts +100 -37
  111. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  112. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  113. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  114. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  115. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  116. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  117. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  118. package/src/prover/isabelle/provers/classical.ts +59 -60
  119. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  120. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  121. package/src/prover/isabelle/pure/consts.ts +1 -7
  122. package/src/prover/isabelle/pure/conv.ts +3 -17
  123. package/src/prover/isabelle/pure/drule.ts +96 -44
  124. package/src/prover/isabelle/pure/envir.ts +3 -52
  125. package/src/prover/isabelle/pure/goal.ts +2 -8
  126. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  127. package/src/prover/isabelle/pure/list.ts +0 -3
  128. package/src/prover/isabelle/pure/logic.ts +2 -15
  129. package/src/prover/isabelle/pure/name.ts +2 -9
  130. package/src/prover/isabelle/pure/net.ts +3 -59
  131. package/src/prover/isabelle/pure/object-logic.ts +16 -15
  132. package/src/prover/isabelle/pure/pattern.ts +2 -19
  133. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  134. package/src/prover/isabelle/pure/rewriter.ts +32 -73
  135. package/src/prover/isabelle/pure/search.ts +3 -10
  136. package/src/prover/isabelle/pure/seq.ts +1 -10
  137. package/src/prover/isabelle/pure/simplifier.ts +28 -15
  138. package/src/prover/isabelle/pure/table.ts +3 -32
  139. package/src/prover/isabelle/pure/tactic.ts +12 -22
  140. package/src/prover/isabelle/pure/tactical.ts +48 -47
  141. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  142. package/src/prover/isabelle/pure/term.ts +2 -43
  143. package/src/prover/isabelle/pure/thm.ts +27 -47
  144. package/src/prover/isabelle/pure/type.ts +2 -15
  145. package/src/prover/isabelle/pure/unify.ts +20 -30
  146. package/src/prover/isabelle/pure/variable.ts +3 -7
  147. package/src/prover/isabelle/tla/classical-setup.ts +18 -24
  148. package/src/prover/isabelle/tla/context.ts +65 -26
  149. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  150. package/src/prover/isabelle/tla/logic.ts +53 -32
  151. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  152. package/src/prover/isabelle/tools/intuitionistic.ts +29 -20
  153. package/src/prover/ocaml.ts +0 -6
  154. package/src/prover/prep/action.ts +32 -66
  155. package/src/prover/prep/enabled-axioms.ts +22 -20
  156. package/src/prover/prep/fingerprint.ts +2 -21
  157. package/src/prover/prep/level-comparison.ts +8 -12
  158. package/src/prover/prep/md5.ts +0 -2
  159. package/src/prover/prep/methods.ts +137 -83
  160. package/src/prover/prep/normalize.ts +38 -36
  161. package/src/prover/prove-worker.ts +0 -2
  162. package/src/prover/prove.ts +371 -132
  163. package/src/prover/ptl/decide.ts +104 -44
  164. package/src/prover/ptl/encode.ts +15 -38
  165. package/src/prover/ptl/sat.ts +24 -32
  166. package/src/prover/ptl/tableau.ts +40 -28
  167. package/src/prover/smt/arithmetic.ts +310 -0
  168. package/src/prover/smt/axioms.ts +12 -15
  169. package/src/prover/smt/context.ts +61 -29
  170. package/src/prover/smt/data.ts +497 -387
  171. package/src/prover/smt/encode.ts +156 -85
  172. package/src/prover/smt/extensionality.ts +5 -13
  173. package/src/prover/smt/flatten.ts +7 -28
  174. package/src/prover/smt/format.ts +33 -14
  175. package/src/prover/smt/instances.ts +7 -11
  176. package/src/prover/smt/layout.ts +91 -0
  177. package/src/prover/smt/rewrite.ts +1025 -658
  178. package/src/prover/smt/simplify.ts +441 -0
  179. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +63 -0
  180. package/src/prover/smt/solver/ackr-helper.ts +182 -0
  181. package/src/prover/smt/solver/ackr-model-converter.ts +112 -0
  182. package/src/prover/smt/solver/act-cache.ts +0 -15
  183. package/src/prover/smt/solver/add-bounds-tactic.ts +60 -0
  184. package/src/prover/smt/solver/aig-tactic.ts +43 -0
  185. package/src/prover/smt/solver/aig.ts +890 -0
  186. package/src/prover/smt/solver/arith-rewriter.ts +613 -48
  187. package/src/prover/smt/solver/arith-terms.ts +123 -0
  188. package/src/prover/smt/solver/array-decl-plugin.ts +176 -0
  189. package/src/prover/smt/solver/array-rewriter.ts +312 -0
  190. package/src/prover/smt/solver/array.ts +1 -3
  191. package/src/prover/smt/solver/asserted-formulas.ts +87 -57
  192. package/src/prover/smt/solver/ast-lt.ts +166 -21
  193. package/src/prover/smt/solver/ast-util.ts +161 -7
  194. package/src/prover/smt/solver/ast.ts +1466 -178
  195. package/src/prover/smt/solver/auf-solver.ts +8 -44
  196. package/src/prover/smt/solver/bit-blast-tactic.ts +591 -0
  197. package/src/prover/smt/solver/bit-blaster.ts +874 -0
  198. package/src/prover/smt/solver/bound-manager.ts +186 -0
  199. package/src/prover/smt/solver/bound-simplifier.ts +602 -0
  200. package/src/prover/smt/solver/bv-bound-chk.ts +500 -0
  201. package/src/prover/smt/solver/bv-decl-plugin.ts +339 -0
  202. package/src/prover/smt/solver/bv-divrem-bounds.ts +97 -0
  203. package/src/prover/smt/solver/bv-rewriter.ts +1905 -0
  204. package/src/prover/smt/solver/bv1-blast.ts +224 -0
  205. package/src/prover/smt/solver/bv2fpa-converter.ts +175 -0
  206. package/src/prover/smt/solver/bv2int-rewriter.ts +545 -0
  207. package/src/prover/smt/solver/bv2real-rewriter.ts +534 -0
  208. package/src/prover/smt/solver/card2bv.ts +112 -0
  209. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  210. package/src/prover/smt/solver/cg-table.ts +28 -34
  211. package/src/prover/smt/solver/check-logic.ts +326 -0
  212. package/src/prover/smt/solver/clause.ts +1 -27
  213. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +280 -0
  214. package/src/prover/smt/solver/conflict-resolution.ts +79 -12
  215. package/src/prover/smt/solver/context.ts +510 -175
  216. package/src/prover/smt/solver/ctx-simplify.ts +34 -50
  217. package/src/prover/smt/solver/ctx-solver-simplify.ts +124 -0
  218. package/src/prover/smt/solver/datatype-decl-plugin.ts +575 -0
  219. package/src/prover/smt/solver/datatype-rewriter.ts +83 -0
  220. package/src/prover/smt/solver/demodulator.ts +789 -0
  221. package/src/prover/smt/solver/dependent-expr-state.ts +68 -0
  222. package/src/prover/smt/solver/der.ts +40 -30
  223. package/src/prover/smt/solver/diff-neq.ts +207 -0
  224. package/src/prover/smt/solver/distribute-forall.ts +67 -0
  225. package/src/prover/smt/solver/dom-simplify.ts +513 -0
  226. package/src/prover/smt/solver/dt2bv-tactic.ts +267 -0
  227. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  228. package/src/prover/smt/solver/e-matching.ts +4 -35
  229. package/src/prover/smt/solver/elim-small-bv-tactic.ts +130 -0
  230. package/src/prover/smt/solver/elim-uncnstr.ts +558 -0
  231. package/src/prover/smt/solver/enode.ts +93 -22
  232. package/src/prover/smt/solver/eq2bv-tactic.ts +219 -0
  233. package/src/prover/smt/solver/euf/arith-axioms.ts +404 -0
  234. package/src/prover/smt/solver/euf/arith-internalize.ts +659 -0
  235. package/src/prover/smt/solver/euf/arith-solver.ts +895 -0
  236. package/src/prover/smt/solver/euf/array-axioms.ts +528 -0
  237. package/src/prover/smt/solver/euf/array-internalize.ts +419 -0
  238. package/src/prover/smt/solver/euf/array-solver.ts +308 -0
  239. package/src/prover/smt/solver/euf/bv-ackerman.ts +164 -0
  240. package/src/prover/smt/solver/euf/bv-internalize.ts +750 -0
  241. package/src/prover/smt/solver/euf/bv-solver.ts +451 -0
  242. package/src/prover/smt/solver/euf/dt-solver.ts +620 -0
  243. package/src/prover/smt/solver/euf/egraph.ts +885 -0
  244. package/src/prover/smt/solver/euf/euf-solver.ts +1203 -0
  245. package/src/prover/smt/solver/euf/fpa-solver.ts +333 -0
  246. package/src/prover/smt/solver/euf/mam.ts +1094 -0
  247. package/src/prover/smt/solver/euf/q-ematch.ts +900 -0
  248. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  249. package/src/prover/smt/solver/euf/q-model-fixer.ts +299 -0
  250. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  251. package/src/prover/smt/solver/euf/th-solver.ts +343 -0
  252. package/src/prover/smt/solver/euf/th-solvers.ts +31 -0
  253. package/src/prover/smt/solver/expr-ref.ts +1 -5
  254. package/src/prover/smt/solver/expr-safe-replace.ts +26 -6
  255. package/src/prover/smt/solver/expr2polynomial.ts +147 -0
  256. package/src/prover/smt/solver/factor.ts +152 -0
  257. package/src/prover/smt/solver/fd-solver.ts +269 -0
  258. package/src/prover/smt/solver/fingerprints.ts +16 -26
  259. package/src/prover/smt/solver/fix-dl-var.ts +149 -0
  260. package/src/prover/smt/solver/flat-literals.ts +1 -9
  261. package/src/prover/smt/solver/fm-tactic.ts +873 -0
  262. package/src/prover/smt/solver/fpa-decl-plugin.ts +619 -0
  263. package/src/prover/smt/solver/fpa-rewriter.ts +641 -0
  264. package/src/prover/smt/solver/fpa2bv-converter.ts +2246 -0
  265. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  266. package/src/prover/smt/solver/fpa2bv-tactic.ts +75 -0
  267. package/src/prover/smt/solver/goal.ts +177 -28
  268. package/src/prover/smt/solver/goal2nlsat.ts +191 -0
  269. package/src/prover/smt/solver/guard-set.ts +220 -0
  270. package/src/prover/smt/solver/hash.ts +0 -8
  271. package/src/prover/smt/solver/hashtable.ts +27 -23
  272. package/src/prover/smt/solver/inf-eps.ts +64 -0
  273. package/src/prover/smt/solver/inj-axiom.ts +102 -0
  274. package/src/prover/smt/solver/internalizer.ts +72 -130
  275. package/src/prover/smt/solver/lackr.ts +383 -0
  276. package/src/prover/smt/solver/lbool.ts +1 -2
  277. package/src/prover/smt/solver/lia2card.ts +269 -0
  278. package/src/prover/smt/solver/lia2pb.ts +141 -0
  279. package/src/prover/smt/solver/literal.ts +0 -3
  280. package/src/prover/smt/solver/logic-tactics.ts +349 -0
  281. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  282. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  283. package/src/prover/smt/solver/lp/containers.ts +12 -30
  284. package/src/prover/smt/solver/lp/core-solver.ts +24 -27
  285. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  286. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  287. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  288. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  289. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  290. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  291. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  292. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  293. package/src/prover/smt/solver/lp/int-cube.ts +18 -39
  294. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  295. package/src/prover/smt/solver/lp/lar-solver.ts +70 -82
  296. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  297. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  298. package/src/prover/smt/solver/lp/maximize-term.ts +79 -52
  299. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  300. package/src/prover/smt/solver/lp/nex.ts +1 -6
  301. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  302. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  303. package/src/prover/smt/solver/lp/nla-core.ts +69 -132
  304. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  305. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  306. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  307. package/src/prover/smt/solver/lp/nla-grobner.ts +24 -72
  308. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  309. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  310. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  311. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  312. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  313. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  314. package/src/prover/smt/solver/lp/nla-powers.ts +184 -0
  315. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  316. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  317. package/src/prover/smt/solver/lp/nla-transcendentals.ts +293 -0
  318. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  319. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  320. package/src/prover/smt/solver/lp/nra-solver.ts +30 -54
  321. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  322. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  323. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  324. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  325. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  326. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  327. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  328. package/src/prover/smt/solver/lp/union-find.ts +6 -5
  329. package/src/prover/smt/solver/macro-finder.ts +533 -0
  330. package/src/prover/smt/solver/mam-compiler.ts +117 -126
  331. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  332. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +29 -0
  333. package/src/prover/smt/solver/max-cliques.ts +107 -0
  334. package/src/prover/smt/solver/maxcore.ts +318 -0
  335. package/src/prover/smt/solver/maximize-ac-sharing.ts +9 -20
  336. package/src/prover/smt/solver/maxlex.ts +123 -0
  337. package/src/prover/smt/solver/maxsmt-base.ts +99 -0
  338. package/src/prover/smt/solver/maxsmt.ts +93 -0
  339. package/src/prover/smt/solver/mbp/mbp-arith.ts +477 -0
  340. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +102 -0
  341. package/src/prover/smt/solver/mbp/mbp-plugin.ts +280 -0
  342. package/src/prover/smt/solver/mbp/mbp-qel.ts +49 -0
  343. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +280 -0
  344. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +624 -0
  345. package/src/prover/smt/solver/model-based-opt.ts +845 -0
  346. package/src/prover/smt/solver/model-checker.ts +20 -62
  347. package/src/prover/smt/solver/model-evaluator.ts +186 -39
  348. package/src/prover/smt/solver/model-finder.ts +15 -32
  349. package/src/prover/smt/solver/model-generator.ts +57 -40
  350. package/src/prover/smt/solver/model-macro-solver.ts +58 -111
  351. package/src/prover/smt/solver/model-printer.ts +215 -0
  352. package/src/prover/smt/solver/mpf.ts +712 -0
  353. package/src/prover/smt/solver/mus.ts +52 -0
  354. package/src/prover/smt/solver/muz/dl-context.ts +362 -0
  355. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +98 -0
  356. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +121 -0
  357. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +121 -0
  358. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +305 -0
  359. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +427 -0
  360. package/src/prover/smt/solver/muz/dl-mk-slice.ts +278 -0
  361. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +158 -0
  362. package/src/prover/smt/solver/muz/dl-rule-set.ts +303 -0
  363. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +127 -0
  364. package/src/prover/smt/solver/muz/dl-rule.ts +460 -0
  365. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  366. package/src/prover/smt/solver/muz/horn-tactic.ts +192 -0
  367. package/src/prover/smt/solver/muz/rule-properties.ts +179 -0
  368. package/src/prover/smt/solver/muz/spacer-context.ts +1395 -0
  369. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +41 -0
  370. package/src/prover/smt/solver/muz/spacer-generalizers.ts +244 -0
  371. package/src/prover/smt/solver/muz/spacer-manager.ts +133 -0
  372. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  373. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +344 -0
  374. package/src/prover/smt/solver/muz/spacer-util.ts +309 -0
  375. package/src/prover/smt/solver/muz/substitution.ts +154 -0
  376. package/src/prover/smt/solver/nla2bv-tactic.ts +286 -0
  377. package/src/prover/smt/solver/nlqsat.ts +484 -0
  378. package/src/prover/smt/solver/nlsat/algebraic.ts +179 -159
  379. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  380. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  381. package/src/prover/smt/solver/nlsat/explain.ts +61 -69
  382. package/src/prover/smt/solver/nlsat/interval-set.ts +10 -51
  383. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  384. package/src/prover/smt/solver/nlsat/mpbq.ts +48 -14
  385. package/src/prover/smt/solver/nlsat/polynomial.ts +30 -160
  386. package/src/prover/smt/solver/nlsat/solver.ts +227 -99
  387. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +311 -0
  388. package/src/prover/smt/solver/nlsat/transcendentals.ts +369 -0
  389. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  390. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  391. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  392. package/src/prover/smt/solver/nlsat-tactic.ts +83 -0
  393. package/src/prover/smt/solver/nnf.ts +108 -60
  394. package/src/prover/smt/solver/normalize-bounds.ts +54 -0
  395. package/src/prover/smt/solver/occf.ts +98 -0
  396. package/src/prover/smt/solver/opt-context.ts +787 -0
  397. package/src/prover/smt/solver/opt-nlsat.ts +366 -0
  398. package/src/prover/smt/solver/opt-pareto.ts +284 -0
  399. package/src/prover/smt/solver/opt-preprocess.ts +102 -0
  400. package/src/prover/smt/solver/opt-solver.ts +300 -0
  401. package/src/prover/smt/solver/opt-value.ts +56 -0
  402. package/src/prover/smt/solver/optsmt.ts +691 -0
  403. package/src/prover/smt/solver/parallel-tactic.ts +301 -0
  404. package/src/prover/smt/solver/pattern-inference.ts +19 -23
  405. package/src/prover/smt/solver/pb-rewriter.ts +296 -0
  406. package/src/prover/smt/solver/pb2bv-tactic.ts +542 -0
  407. package/src/prover/smt/solver/poly-rewriter.ts +203 -77
  408. package/src/prover/smt/solver/probes.ts +514 -0
  409. package/src/prover/smt/solver/propagate-values.ts +34 -30
  410. package/src/prover/smt/solver/proto-model.ts +648 -63
  411. package/src/prover/smt/solver/pull-quant.ts +29 -23
  412. package/src/prover/smt/solver/purify-arith.ts +598 -0
  413. package/src/prover/smt/solver/qe-arith-plugin.ts +1099 -0
  414. package/src/prover/smt/solver/qe-lite-der.ts +3 -31
  415. package/src/prover/smt/solver/qe-lite-fm.ts +5 -28
  416. package/src/prover/smt/solver/qe-lite.ts +40 -49
  417. package/src/prover/smt/solver/qe-mbp.ts +281 -0
  418. package/src/prover/smt/solver/qe.ts +1508 -0
  419. package/src/prover/smt/solver/qel.ts +26 -0
  420. package/src/prover/smt/solver/qi-queue.ts +1 -16
  421. package/src/prover/smt/solver/qsat.ts +840 -0
  422. package/src/prover/smt/solver/quant-hoist.ts +195 -0
  423. package/src/prover/smt/solver/quant-tactics.ts +18 -74
  424. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  425. package/src/prover/smt/solver/quantifier-manager.ts +9 -23
  426. package/src/prover/smt/solver/quasi-macros.ts +254 -0
  427. package/src/prover/smt/solver/random-gen.ts +1 -2
  428. package/src/prover/smt/solver/rational.ts +29 -8
  429. package/src/prover/smt/solver/recfun-decl-plugin.ts +248 -0
  430. package/src/prover/smt/solver/recfun-rewriter.ts +108 -0
  431. package/src/prover/smt/solver/reduce-args.ts +226 -0
  432. package/src/prover/smt/solver/reduce-bv-size.ts +120 -0
  433. package/src/prover/smt/solver/ref-vector.ts +1 -6
  434. package/src/prover/smt/solver/relevancy.ts +3 -16
  435. package/src/prover/smt/solver/rewriter-tpl.ts +49 -129
  436. package/src/prover/smt/solver/rewriter.ts +478 -120
  437. package/src/prover/smt/solver/rlimit.ts +27 -21
  438. package/src/prover/smt/solver/sat/asymm-branch.ts +314 -0
  439. package/src/prover/smt/solver/sat/big.ts +178 -0
  440. package/src/prover/smt/solver/sat/clause-use-list.ts +79 -0
  441. package/src/prover/smt/solver/sat/clause.ts +221 -0
  442. package/src/prover/smt/solver/sat/cleaner.ts +96 -0
  443. package/src/prover/smt/solver/sat/config.ts +125 -0
  444. package/src/prover/smt/solver/sat/consequences.ts +204 -0
  445. package/src/prover/smt/solver/sat/elim-eqs.ts +144 -0
  446. package/src/prover/smt/solver/sat/goal2sat.ts +528 -0
  447. package/src/prover/smt/solver/sat/inc-sat-solver.ts +388 -0
  448. package/src/prover/smt/solver/sat/model-converter.ts +156 -0
  449. package/src/prover/smt/solver/sat/pb-constraint.ts +264 -0
  450. package/src/prover/smt/solver/sat/pb-solver.ts +1553 -0
  451. package/src/prover/smt/solver/sat/probing.ts +169 -0
  452. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  453. package/src/prover/smt/solver/sat/sat2goal.ts +171 -0
  454. package/src/prover/smt/solver/sat/scc.ts +143 -0
  455. package/src/prover/smt/solver/sat/simplifier.ts +1662 -0
  456. package/src/prover/smt/solver/sat/solver.ts +2128 -0
  457. package/src/prover/smt/solver/sat/var-queue.ts +119 -0
  458. package/src/prover/smt/solver/sat/watch-list.ts +136 -0
  459. package/src/prover/smt/solver/search-tree.ts +285 -0
  460. package/src/prover/smt/solver/seq-axioms.ts +1013 -0
  461. package/src/prover/smt/solver/seq-decl-plugin.ts +823 -0
  462. package/src/prover/smt/solver/seq-derive.ts +1303 -0
  463. package/src/prover/smt/solver/seq-eq-approx.ts +238 -0
  464. package/src/prover/smt/solver/seq-eq-solver.ts +440 -0
  465. package/src/prover/smt/solver/seq-factory.ts +91 -0
  466. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  467. package/src/prover/smt/solver/seq-range-predicate.ts +225 -0
  468. package/src/prover/smt/solver/seq-re-rewriter.ts +1296 -0
  469. package/src/prover/smt/solver/seq-re-util.ts +777 -0
  470. package/src/prover/smt/solver/seq-regex-bisim.ts +145 -0
  471. package/src/prover/smt/solver/seq-regex-live.ts +202 -0
  472. package/src/prover/smt/solver/seq-regex-witness.ts +100 -0
  473. package/src/prover/smt/solver/seq-rewriter.ts +2407 -0
  474. package/src/prover/smt/solver/seq-skolem.ts +318 -0
  475. package/src/prover/smt/solver/seq-subset.ts +166 -0
  476. package/src/prover/smt/solver/seq-view-witness.ts +355 -0
  477. package/src/prover/smt/solver/smt-consequences.ts +299 -0
  478. package/src/prover/smt/solver/smt-kernel.ts +85 -0
  479. package/src/prover/smt/solver/smt-logics.ts +67 -0
  480. package/src/prover/smt/solver/smt-setup.ts +492 -0
  481. package/src/prover/smt/solver/smt2-printer.ts +767 -0
  482. package/src/prover/smt/solver/smtlib-parser.ts +2423 -270
  483. package/src/prover/smt/solver/smtlib-script.ts +1493 -0
  484. package/src/prover/smt/solver/solve-eqs.ts +931 -0
  485. package/src/prover/smt/solver/solver.ts +120 -39
  486. package/src/prover/smt/solver/sort.ts +1 -5
  487. package/src/prover/smt/solver/static-features.ts +319 -0
  488. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  489. package/src/prover/smt/solver/tactic.ts +1936 -0
  490. package/src/prover/smt/solver/term-enumeration.ts +206 -0
  491. package/src/prover/smt/solver/theory-array.ts +1275 -0
  492. package/src/prover/smt/solver/theory-bv.ts +1239 -0
  493. package/src/prover/smt/solver/theory-char.ts +356 -0
  494. package/src/prover/smt/solver/theory-datatype.ts +599 -0
  495. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  496. package/src/prover/smt/solver/theory-fpa.ts +422 -0
  497. package/src/prover/smt/solver/theory-lra-axioms.ts +56 -25
  498. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -10
  499. package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
  500. package/src/prover/smt/solver/theory-lra-internalize.ts +87 -53
  501. package/src/prover/smt/solver/theory-lra-model.ts +24 -53
  502. package/src/prover/smt/solver/theory-lra-propagate.ts +25 -40
  503. package/src/prover/smt/solver/theory-lra-state.ts +7 -27
  504. package/src/prover/smt/solver/theory-lra.ts +194 -8
  505. package/src/prover/smt/solver/theory-pb.ts +932 -0
  506. package/src/prover/smt/solver/theory-polymorphism.ts +59 -0
  507. package/src/prover/smt/solver/theory-recfun.ts +308 -0
  508. package/src/prover/smt/solver/theory-seq-regex.ts +871 -0
  509. package/src/prover/smt/solver/theory-seq-solve.ts +1375 -0
  510. package/src/prover/smt/solver/theory-seq-state.ts +880 -0
  511. package/src/prover/smt/solver/theory-seq.ts +984 -0
  512. package/src/prover/smt/solver/theory.ts +175 -0
  513. package/src/prover/smt/solver/tseitin-cnf.ts +487 -0
  514. package/src/prover/smt/solver/var-subst.ts +33 -35
  515. package/src/prover/smt/table.ts +1 -9
  516. package/src/prover/smt/types.ts +146 -0
  517. package/src/prover/tlapm/cache.ts +67 -41
  518. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  519. package/src/prover/tlapm/tlapm.ts +21 -20
  520. package/src/prover/tlapm-library.ts +3208 -0
  521. package/src/prover/verdict.ts +9 -2
  522. package/src/prover/zenon/check/check.ts +1 -11
  523. package/src/prover/zenon/check/definitions.ts +5 -15
  524. package/src/prover/zenon/check/equality.ts +0 -8
  525. package/src/prover/zenon/check/functions.ts +0 -4
  526. package/src/prover/zenon/check/keys.ts +0 -7
  527. package/src/prover/zenon/check/propositional.ts +0 -3
  528. package/src/prover/zenon/check/records.ts +1 -6
  529. package/src/prover/zenon/check/relations.ts +2 -14
  530. package/src/prover/zenon/check/rewrites.ts +2 -21
  531. package/src/prover/zenon/check/sets.ts +40 -61
  532. package/src/prover/zenon/check/terms.ts +1 -19
  533. package/src/prover/zenon/check/tla.ts +0 -6
  534. package/src/prover/zenon/decide.ts +10 -15
  535. package/src/prover/zenon/encode.ts +1 -8
  536. package/src/prover/zenon/eqrel.ts +2 -13
  537. package/src/prover/zenon/equality-rules.ts +0 -4
  538. package/src/prover/zenon/expr.ts +8 -26
  539. package/src/prover/zenon/index-table.ts +26 -57
  540. package/src/prover/zenon/isar-case.ts +9 -19
  541. package/src/prover/zenon/isar.ts +36 -64
  542. package/src/prover/zenon/limits.ts +0 -4
  543. package/src/prover/zenon/llproof.ts +2 -20
  544. package/src/prover/zenon/mltoll.ts +66 -104
  545. package/src/prover/zenon/node.ts +20 -14
  546. package/src/prover/zenon/ocaml.ts +1 -17
  547. package/src/prover/zenon/parse.ts +10 -12
  548. package/src/prover/zenon/phrase.ts +1 -11
  549. package/src/prover/zenon/proof.ts +0 -9
  550. package/src/prover/zenon/propositional-rules.ts +0 -5
  551. package/src/prover/zenon/rules.ts +2 -6
  552. package/src/prover/zenon/search.ts +11 -33
  553. package/src/prover/zenon/tla/functions.ts +59 -31
  554. package/src/prover/zenon/tla/llproof.ts +67 -76
  555. package/src/prover/zenon/tla/records.ts +57 -33
  556. package/src/prover/zenon/tla/rewrites.ts +12 -19
  557. package/src/prover/zenon/tla/sets.ts +88 -57
  558. package/src/prover/zenon/tla/terms.ts +0 -6
  559. package/src/prover/zenon/tla/tla.ts +66 -64
  560. package/src/randomization.ts +81 -35
  561. package/src/resolve.ts +67 -184
  562. package/src/runtime.ts +22 -22
  563. package/src/sany/builtins.ts +2 -5
  564. package/src/sany/generation.ts +394 -0
  565. package/src/sany/generator-def-entries.ts +210 -0
  566. package/src/sany/generator-definitions.ts +686 -0
  567. package/src/sany/generator-expressions.ts +1100 -0
  568. package/src/sany/generator-proofs.ts +662 -0
  569. package/src/sany/generator.ts +191 -2764
  570. package/src/sany/levels.ts +6 -34
  571. package/src/sany/lexer.ts +58 -77
  572. package/src/sany/linter.ts +1 -9
  573. package/src/sany/modules.ts +1 -5
  574. package/src/sany/nodes.ts +5 -43
  575. package/src/sany/parse-error.ts +39 -117
  576. package/src/sany/report.ts +32 -69
  577. package/src/sany/selectors.ts +49 -76
  578. package/src/sany/source.ts +1 -17
  579. package/src/sany/xml.ts +35 -117
  580. package/src/search.ts +541 -163
  581. package/src/simulate.ts +709 -0
  582. package/src/spec-description.ts +192 -100
  583. package/src/standard-definitions.ts +0 -4
  584. package/src/standard-modules.ts +264 -95
  585. package/src/state-graph.ts +52 -31
  586. package/src/subexpressions.ts +69 -52
  587. package/src/substitution-levels.ts +7 -7
  588. package/src/successors.ts +266 -99
  589. package/src/symmetry.ts +33 -25
  590. package/src/tableau.ts +27 -24
  591. package/src/tlc/fingerprint.ts +183 -67
  592. package/src/tlc/jar-data.ts +112 -6
  593. package/src/tlc/messages.ts +125 -54
  594. package/src/tlc/order.ts +39 -69
  595. package/src/tlc/random.ts +37 -49
  596. package/src/tlc/replay.ts +553 -228
  597. package/src/tlc/summary.ts +36 -47
  598. package/src/tlc/tlc-operators.ts +78 -44
  599. package/src/tlc/tlcext-operators.ts +139 -122
  600. package/src/tlc/trace-spec.ts +249 -0
  601. package/src/tlc/value-stream.ts +139 -0
  602. package/src/tlc/version.ts +1 -4
  603. package/src/transfer.ts +22 -25
  604. package/src/typescript/actions.ts +479 -0
  605. package/src/typescript/collections.ts +614 -0
  606. package/src/typescript/compile.ts +63 -0
  607. package/src/typescript/context.ts +94 -0
  608. package/src/typescript/emit.ts +121 -0
  609. package/src/typescript/expressions.ts +496 -0
  610. package/src/typescript/formula.ts +154 -0
  611. package/src/typescript/functions.ts +284 -0
  612. package/src/typescript/model.ts +162 -0
  613. package/src/typescript/names.ts +114 -0
  614. package/src/typescript/program.ts +48 -0
  615. package/src/typescript/properties.ts +139 -0
  616. package/src/typescript/scope.ts +112 -0
  617. package/src/typescript/steps.ts +167 -0
  618. package/src/typescript/types.ts +171 -0
  619. package/src/values.ts +832 -484
  620. package/src/worker.ts +7 -8
  621. package/src/prover/isabelle/isar/statement.ts +0 -57
  622. package/src/prover/tlaps-module.ts +0 -510
@@ -1,17 +1,28 @@
1
- // Ported from Z3 (src/parsers/smt2/smt2parser.cpp), MIT license, see z3-license.txt.
2
- // Parses the SMT-LIB subset that tlapm emits into Z3-style expressions.
1
+ // Ported from Z3 (src/parsers/smt2/smt2scanner.cpp, src/parsers/smt2/smt2parser.cpp,
2
+ // src/cmd_context/cmd_context.cpp), MIT license, see z3-license.txt.
3
3
  import { SmtParseError, SmtUnsupportedError } from "../../../errors";
4
4
  import {
5
- AstManager,
5
+ type AstManager,
6
+ getSymbolHash,
6
7
  FAMILY_ARITH,
7
8
  FAMILY_BASIC,
9
+ FAMILY_DATATYPE,
8
10
  KIND_QUANTIFIER,
9
11
  KIND_VAR,
10
12
  OP_ABS,
11
13
  OP_ADD,
12
14
  OP_AND,
15
+ OP_AT_LEAST_K,
16
+ OP_AT_MOST_K,
17
+ OP_PB_EQ,
18
+ OP_PB_GE,
19
+ OP_PB_LE,
20
+ OP_ARRAY_DEFAULT,
21
+ OP_ARRAY_MAP,
22
+ OP_CONST_ARRAY,
13
23
  OP_DISTINCT,
14
24
  OP_DIV,
25
+ OP_DT_ACCESSOR,
15
26
  OP_EQ,
16
27
  OP_GE,
17
28
  OP_GT,
@@ -22,9 +33,29 @@ import {
22
33
  OP_LE,
23
34
  OP_LT,
24
35
  OP_MOD,
36
+ OP_REM,
25
37
  OP_MUL,
26
38
  OP_NOT,
27
39
  OP_OR,
40
+ OP_POWER,
41
+ OP_POWER0,
42
+ OP_SIN,
43
+ OP_COS,
44
+ OP_TAN,
45
+ OP_ASIN,
46
+ OP_ACOS,
47
+ OP_ATAN,
48
+ OP_SINH,
49
+ OP_COSH,
50
+ OP_TANH,
51
+ OP_ASINH,
52
+ OP_ACOSH,
53
+ OP_ATANH,
54
+ OP_EXP,
55
+ OP_ATAN2,
56
+ OP_LOG,
57
+ OP_SELECT,
58
+ OP_STORE,
28
59
  OP_SUB,
29
60
  OP_TO_INT,
30
61
  OP_TO_REAL,
@@ -32,61 +63,418 @@ import {
32
63
  OP_FALSE,
33
64
  OP_UMINUS,
34
65
  OP_UNINTERPRETED,
66
+ OP_FUN_DEFINED,
35
67
  OP_XOR,
36
68
  SORT_BOOL,
37
69
  SORT_INT,
38
70
  SORT_REAL,
39
71
  isArithSort,
72
+ QUANTIFIER_EXISTS,
73
+ QUANTIFIER_FORALL,
74
+ QUANTIFIER_LAMBDA,
40
75
  } from "./ast";
76
+ import { getArraySignature, getMapSignature, mkAsArray } from "./array-decl-plugin";
77
+ import { BV_OP_NAMES, getBvSignature } from "./bv-decl-plugin";
78
+ import {
79
+ type ConstructorDef,
80
+ type DatatypeDef,
81
+ getConstructorAccessors,
82
+ getConstructorIs,
83
+ getConstructorRecognizer,
84
+ getDatatypeConstructors,
85
+ getDatatypeDef,
86
+ instantiateAccessor,
87
+ instantiateConstructor,
88
+ mkDatatypeDef,
89
+ mkDatatypeSort,
90
+ mkDatatypes,
91
+ mkUpdateField,
92
+ removeDatatype,
93
+ substituteSort,
94
+ } from "./datatype-decl-plugin";
95
+ import {
96
+ FPA_OP_NAMES,
97
+ FPA_SORT_NAMES,
98
+ getFloatSortError,
99
+ getFpaSignature,
100
+ mkFpaAppOf,
101
+ } from "./fpa-decl-plugin";
102
+ import { createLogicChecker } from "./check-logic";
103
+ import { ObjMap } from "./hashtable";
104
+ import {
105
+ CHAR_OP_NAMES,
106
+ getSeqSignature,
107
+ mkSeqAppOf,
108
+ parseZstring,
109
+ SEQ_OP_NAMES,
110
+ SEQ_SORT_NAMES,
111
+ } from "./seq-decl-plugin";
41
112
  import { Rational } from "./rational";
42
- import { replaceFreeVars } from "./var-subst";
113
+ import {
114
+ logicHasArith,
115
+ logicHasArray,
116
+ logicHasBv,
117
+ logicHasFpa,
118
+ logicHasRealsOnly,
119
+ logicHasSeq,
120
+ isSupportedLogic,
121
+ } from "./smt-logics";
122
+ import { setRecFunDefinition } from "./recfun-decl-plugin";
123
+ import { replaceFreeVars, VarSubst } from "./var-subst";
124
+ import { UpolynomialManager } from "./nlsat/upolynomial";
125
+
126
+ export interface ParserOptions {
127
+ isIgnoringBadPatterns: boolean;
128
+ }
129
+
130
+ const DEFAULT_PARSER_OPTIONS: ParserOptions = { isIgnoringBadPatterns: true };
131
+
132
+ // Z3 counts the columns of the first line from 1 and of the others from 0.
133
+ export interface SmtToken {
134
+ kind: "(" | ")" | "symbol" | "keyword" | "string" | "numeral" | "decimal" | "bitvector";
135
+ text: string;
136
+ line: number;
137
+ column: number;
138
+ offset: number;
139
+ endOffset: number;
140
+ }
141
+
142
+ export interface SmtList {
143
+ kind: "list";
144
+ items: SExpr[];
145
+ line: number;
146
+ column: number;
147
+ offset: number;
148
+ // Z3 reports an error in making an application at its closing parenthesis.
149
+ end: SmtToken;
150
+ follower?: SmtToken;
151
+ }
152
+
153
+ export type SExpr = SmtToken | SmtList;
154
+
155
+ interface VarBinding {
156
+ kind: "var";
157
+ depth: number;
158
+ sort: number;
159
+ }
160
+
161
+ interface LetBinding {
162
+ kind: "let";
163
+ depth: number;
164
+ expr: number;
165
+ }
166
+
167
+ type Binding = VarBinding | LetBinding;
168
+
169
+ interface Macro {
170
+ domain: number[];
171
+ range: number;
172
+ body: number;
173
+ }
174
+
175
+ interface ConstantSortDecl {
176
+ kind: "sort";
177
+ sort: number;
178
+ }
179
+
180
+ interface UserSortDecl {
181
+ kind: "user";
182
+ name: string;
183
+ arity: number;
184
+ }
43
185
 
44
- type SExpr = string | SExpr[];
186
+ interface DatatypeSortDecl {
187
+ kind: "datatype";
188
+ name: string;
189
+ arity: number;
190
+ siblings: string[];
191
+ instances: Map<string, number>;
192
+ }
193
+
194
+ interface DefinedSortDecl {
195
+ kind: "definition";
196
+ parameters: string[];
197
+ body: SExpr;
198
+ }
199
+
200
+ // Z3's List datatype, which exists when no logic is set, declared here at its first use.
201
+ interface ListSortDecl {
202
+ kind: "list";
203
+ }
45
204
 
46
- // A name in scope: a variable bound by a quantifier, or a let binding's term. depth is the number of
47
- // binders above it.
48
- type Binding =
49
- | { kind: "var"; depth: number; sort: number }
50
- | { kind: "let"; depth: number; expr: number };
205
+ type SortDecl = ConstantSortDecl | UserSortDecl | DatatypeSortDecl | DefinedSortDecl | ListSortDecl;
206
+
207
+ const NO_BINDINGS: ReadonlyMap<string, number> = new Map();
208
+
209
+ const UPOLYNOMIALS = new UpolynomialManager();
51
210
 
52
211
  interface SmtProblem {
53
212
  assertions: number[];
54
- // Z3 prints no answer for a script without check-sat.
55
213
  hasCheckSat: boolean;
214
+ rlimit: number;
56
215
  }
57
216
 
58
- // An application that parseTerm is parsing: its name, its list, where its arguments start on the
59
- // result stack, and its next argument.
60
217
  interface ApplicationFrame {
61
- name: string;
62
- list: SExpr[];
218
+ head: SmtToken;
219
+ indices: number[];
220
+ build?: (args: number[]) => number;
221
+ list: SmtList;
63
222
  start: number;
64
223
  next: number;
65
224
  }
66
225
 
67
226
  const BUILTIN_OPS = new Map<string, number>([
68
227
  ["and", OP_AND],
228
+ ["-", OP_SUB],
69
229
  ["or", OP_OR],
70
230
  ["not", OP_NOT],
71
231
  ["=>", OP_IMPLIES],
72
232
  ["xor", OP_XOR],
73
233
  ["ite", OP_ITE],
234
+ ["if", OP_ITE],
74
235
  ["distinct", OP_DISTINCT],
75
236
  ["+", OP_ADD],
76
237
  ["*", OP_MUL],
77
238
  ["/", OP_DIV],
78
239
  ["div", OP_IDIV],
79
240
  ["mod", OP_MOD],
241
+ ["rem", OP_REM],
80
242
  ["abs", OP_ABS],
81
243
  ["to_real", OP_TO_REAL],
82
244
  ["to_int", OP_TO_INT],
83
245
  ["is_int", OP_IS_INT],
84
246
  ]);
85
247
 
86
- // arith_decl_plugin's use_coercion: the operators that are Real when any argument is Real.
87
- const COERCING_OPS = new Set([OP_ADD, OP_SUB, OP_UMINUS, OP_MUL, OP_LE, OP_GE, OP_LT, OP_GT]);
248
+ // basic_decl_plugin's aliases, which Z3 knows only when the script sets no logic.
249
+ const LOGIC_FREE_ALIASES = new Map([
250
+ ["implies", "=>"],
251
+ ["iff", "="],
252
+ ["if_then_else", "ite"],
253
+ ["&&", "and"],
254
+ ["||", "or"],
255
+ ["equals", "="],
256
+ ["equiv", "="],
257
+ ]);
258
+
259
+ // Z3 declares these only without a logic, in ALL or in QF_NTA.
260
+ const TRANSCENDENTAL_OPS = new Map([
261
+ ["^", OP_POWER],
262
+ ["^0", OP_POWER0],
263
+ ["sin", OP_SIN],
264
+ ["cos", OP_COS],
265
+ ["tan", OP_TAN],
266
+ ["asin", OP_ASIN],
267
+ ["acos", OP_ACOS],
268
+ ["atan", OP_ATAN],
269
+ ["sinh", OP_SINH],
270
+ ["cosh", OP_COSH],
271
+ ["tanh", OP_TANH],
272
+ ["asinh", OP_ASINH],
273
+ ["acosh", OP_ACOSH],
274
+ ["atanh", OP_ATANH],
275
+ ["exp", OP_EXP],
276
+ ["atan2", OP_ATAN2],
277
+ ["arctan2", OP_ATAN2],
278
+ ["log", OP_LOG],
279
+ ["ln", OP_LOG],
280
+ ]);
281
+ const TRANSCENDENTALS = new Set([
282
+ ...TRANSCENDENTAL_OPS.keys(),
283
+ "pi",
284
+ "euler",
285
+ "/0",
286
+ "div0",
287
+ "mod0",
288
+ "complex.make",
289
+ "complex.real",
290
+ "complex.imag",
291
+ ]);
292
+
293
+ const hasTranscendentals = (logic: string | undefined) =>
294
+ logic === undefined || logic === "ALL" || logic === "QF_NTA";
295
+
296
+ const THEORY_SORTS = new Set([
297
+ "BitVec",
298
+ "Array",
299
+ "Set",
300
+ "Seq",
301
+ "String",
302
+ "StringSequence",
303
+ "RegEx",
304
+ "RegLan",
305
+ "Unicode",
306
+ "FloatingPoint",
307
+ "RoundingMode",
308
+ "Float16",
309
+ "Float32",
310
+ "Float64",
311
+ "Float128",
312
+ "FiniteSet",
313
+ "FiniteField",
314
+ "Complex",
315
+ ]);
316
+ const PB_OP_NAMES = new Map([
317
+ ["at-most", OP_AT_MOST_K],
318
+ ["at-least", OP_AT_LEAST_K],
319
+ ["pble", OP_PB_LE],
320
+ ["pbge", OP_PB_GE],
321
+ ["pbeq", OP_PB_EQ],
322
+ ]);
323
+ const THEORY_OPERATOR = /^(bv|fp\.|str\.|seq\.|re\.|char\.|ff\.)/;
324
+ const THEORY_OPERATORS = new Set([
325
+ "bit0",
326
+ "bit1",
327
+ "concat",
328
+ "sign_extend",
329
+ "zero_extend",
330
+ "extract",
331
+ "repeat",
332
+ "rotate_left",
333
+ "rotate_right",
334
+ "ext_rotate_left",
335
+ "ext_rotate_right",
336
+ "bit2bool",
337
+ "ubv_to_int",
338
+ "sbv_to_int",
339
+ "int_to_bv",
340
+ "int2bv",
341
+ "mkbv",
342
+ "store",
343
+ "select",
344
+ "const",
345
+ "map",
346
+ "default",
347
+ "union",
348
+ "intersection",
349
+ "setminus",
350
+ "complement",
351
+ "subset",
352
+ "as-array",
353
+ "choice",
354
+ "array-ext",
355
+ "set-has-size",
356
+ "card",
357
+ "is",
358
+ "update-field",
359
+ "int.to.str",
360
+ "char",
361
+ "fp",
362
+ "to_fp",
363
+ "to_fp_unsigned",
364
+ "to_ieee_bv",
365
+ "+oo",
366
+ "-oo",
367
+ "+zero",
368
+ "-zero",
369
+ "NaN",
370
+ "roundNearestTiesToEven",
371
+ "roundNearestTiesToAway",
372
+ "roundTowardPositive",
373
+ "roundTowardNegative",
374
+ "roundTowardZero",
375
+ "RNE",
376
+ "RNA",
377
+ "RTP",
378
+ "RTN",
379
+ "RTZ",
380
+ "at-most",
381
+ "at-least",
382
+ "pble",
383
+ "pbge",
384
+ "pbeq",
385
+ "linear-order",
386
+ "partial-order",
387
+ "piecewise-linear-order",
388
+ "tree-order",
389
+ "transitive-closure",
390
+ ]);
88
391
 
89
- const DECIMAL = /^([0-9]+)\.([0-9]+)$/;
392
+ // The operators that are associative but not flat: xor and => nest to the right, the others to the
393
+ // left.
394
+ const NESTED_OPS = new Set([OP_XOR, OP_IMPLIES, OP_SUB, OP_DIV, OP_IDIV]);
395
+
396
+ const COERCING_OPS = new Set([
397
+ OP_ADD,
398
+ OP_SUB,
399
+ OP_UMINUS,
400
+ OP_MUL,
401
+ OP_POWER,
402
+ OP_POWER0,
403
+ OP_LE,
404
+ OP_GE,
405
+ OP_LT,
406
+ OP_GT,
407
+ ]);
408
+
409
+ const REAL_FUNCTION_OPS = new Set([
410
+ OP_SIN,
411
+ OP_COS,
412
+ OP_TAN,
413
+ OP_ASIN,
414
+ OP_ACOS,
415
+ OP_ATAN,
416
+ OP_SINH,
417
+ OP_COSH,
418
+ OP_TANH,
419
+ OP_ASINH,
420
+ OP_ACOSH,
421
+ OP_ATANH,
422
+ OP_EXP,
423
+ OP_ATAN2,
424
+ OP_LOG,
425
+ ]);
426
+
427
+ const ARITIES = new Map<number, [number, number]>([
428
+ [OP_AND, [0, Infinity]],
429
+ [OP_OR, [0, Infinity]],
430
+ [OP_ITE, [3, 3]],
431
+ [OP_EQ, [2, Infinity]],
432
+ [OP_DISTINCT, [1, Infinity]],
433
+ ...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
434
+ .filter((op) => op !== OP_ATAN2)
435
+ .map((op): [number, [number, number]] => [op, [1, 1]]),
436
+ ...[
437
+ OP_IMPLIES,
438
+ OP_XOR,
439
+ OP_IDIV,
440
+ OP_MOD,
441
+ OP_REM,
442
+ OP_DIV,
443
+ OP_LE,
444
+ OP_GE,
445
+ OP_LT,
446
+ OP_GT,
447
+ OP_POWER,
448
+ OP_POWER0,
449
+ OP_ATAN2,
450
+ ].map((op): [number, [number, number]] => [op, [2, 2]]),
451
+ ]);
452
+
453
+ const RANGES = new Map<number, number>([
454
+ [OP_TO_REAL, SORT_REAL],
455
+ [OP_POWER, SORT_REAL],
456
+ [OP_POWER0, SORT_REAL],
457
+ ...[...REAL_FUNCTION_OPS].map((op): [number, number] => [op, SORT_REAL]),
458
+ [OP_DIV, SORT_REAL],
459
+ [OP_TO_INT, SORT_INT],
460
+ [OP_IDIV, SORT_INT],
461
+ [OP_MOD, SORT_INT],
462
+ [OP_REM, SORT_INT],
463
+ ...[
464
+ OP_EQ,
465
+ OP_DISTINCT,
466
+ OP_AND,
467
+ OP_OR,
468
+ OP_XOR,
469
+ OP_NOT,
470
+ OP_IMPLIES,
471
+ OP_LE,
472
+ OP_GE,
473
+ OP_LT,
474
+ OP_GT,
475
+ ].map((op): [number, number] => [op, SORT_BOOL]),
476
+ [OP_IS_INT, SORT_BOOL],
477
+ ]);
90
478
 
91
479
  const CHAINABLE_OPS = new Map<string, number>([
92
480
  ["=", OP_EQ],
@@ -96,88 +484,563 @@ const CHAINABLE_OPS = new Map<string, number>([
96
484
  [">", OP_GT],
97
485
  ]);
98
486
 
99
- const tokenize = (text: string) => {
100
- const tokens: string[] = [];
101
- let position = 0;
102
- while (position < text.length) {
103
- const char = text[position];
104
- if (char === ";") {
105
- const end = text.indexOf("\n", position);
106
- position = end === -1 ? text.length : end + 1;
107
- } else if (char === "(" || char === ")") {
108
- tokens.push(char);
109
- position++;
110
- } else if (char === " " || char === "\n" || char === "\t" || char === "\r") {
111
- position++;
112
- } else if (char === "|") {
113
- const end = text.indexOf("|", position + 1);
114
- if (end === -1) throw new SmtParseError("unterminated quoted symbol");
115
- tokens.push(text.slice(position + 1, end));
116
- position = end + 1;
117
- } else if (char === '"') {
118
- let end = position + 1;
119
- while (end < text.length && (text[end] !== '"' || text[end + 1] === '"'))
120
- end += text[end] === '"' ? 2 : 1;
121
- tokens.push(text.slice(position, end + 1));
122
- position = end + 1;
123
- } else {
124
- let end = position;
125
- while (end < text.length && !' \n\t\r();|"'.includes(text[end])) end++;
126
- tokens.push(text.slice(position, end));
127
- position = end;
487
+ const BV_EXTENSION_NAMES = new Set([
488
+ "bvumul_noovfl",
489
+ "bvsmul_noovfl",
490
+ "bvsmul_noudfl",
491
+ "bvsdiv0",
492
+ "bvudiv0",
493
+ "bvsrem0",
494
+ "bvurem0",
495
+ "bvsmod0",
496
+ "ext_rotate_left",
497
+ "ext_rotate_right",
498
+ "int2bv",
499
+ "bv2int",
500
+ "bv2nat",
501
+ "mkbv",
502
+ ]);
503
+
504
+ const BV_EXTENSION_LOGICS = new Set(["ALL", "QF_FD", "HORN"]);
505
+
506
+ const ARRAY_SORT_NAMES = new Set(["Array", "=>", "->"]);
507
+
508
+ // array_decl_plugin::get_op_names: select and store in every logic with arrays, the others only
509
+ // without a logic or in HORN and ALL.
510
+ const ARRAY_OPS = new Map([
511
+ ["select", OP_SELECT],
512
+ ["store", OP_STORE],
513
+ ]);
514
+ const ARRAY_EXTENSION_OPS = new Map([["default", OP_ARRAY_DEFAULT]]);
515
+
516
+ const UNARY_BOOL_REFS = new Map([["not", OP_NOT]]);
517
+ const BINARY_BOOL_REFS = new Map([
518
+ ["and", OP_AND],
519
+ ["or", OP_OR],
520
+ ["=>", OP_IMPLIES],
521
+ ["xor", OP_XOR],
522
+ ]);
523
+
524
+ const REAL_RANGE_OPS = new Set([OP_DIV, OP_TO_REAL]);
525
+ const INT_RANGE_OPS = new Set([OP_IDIV, OP_MOD, OP_REM, OP_TO_INT]);
526
+ const DOMAIN_RANGE_OPS = new Set([OP_ADD, OP_SUB, OP_MUL, OP_ABS]);
527
+
528
+ // mk_func_decl of a builtin ignores the range of the reference and gives its own.
529
+ const getBuiltinRange = (op: number, domain: number[]) =>
530
+ op === OP_ITE
531
+ ? domain[1]
532
+ : REAL_RANGE_OPS.has(op)
533
+ ? SORT_REAL
534
+ : INT_RANGE_OPS.has(op)
535
+ ? SORT_INT
536
+ : DOMAIN_RANGE_OPS.has(op)
537
+ ? domain[0]
538
+ : SORT_BOOL;
539
+
540
+ interface MappedDecl {
541
+ decl: number;
542
+ domain: readonly number[];
543
+ range: number;
544
+ }
545
+ const ARRAY_EXTENSION_LOGICS = new Set(["HORN", "ALL"]);
546
+
547
+ const BUILTIN_NAMES = new Set([
548
+ "true",
549
+ "false",
550
+ "~",
551
+ ...BV_OP_NAMES.keys(),
552
+ ...CHAINABLE_OPS.keys(),
553
+ ...BUILTIN_OPS.keys(),
554
+ ...LOGIC_FREE_ALIASES.keys(),
555
+ ...TRANSCENDENTALS,
556
+ ...THEORY_OPERATORS,
557
+ ...SEQ_OP_NAMES.keys(),
558
+ ...CHAR_OP_NAMES.keys(),
559
+ ]);
560
+
561
+ const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
562
+
563
+ const createScanner = (text: string) => {
564
+ const state = { index: 0, line: 1, lineStart: -1 };
565
+ const getColumn = () => state.index - state.lineStart - (state.line === 1 ? 0 : 1);
566
+ const advance = () => {
567
+ if (text[state.index] === "\n") {
568
+ state.line++;
569
+ state.lineStart = state.index;
128
570
  }
129
- }
130
- return tokens;
571
+ state.index++;
572
+ };
573
+ const readWhile = (pattern: RegExp) => {
574
+ while (state.index < text.length && pattern.test(text[state.index])) advance();
575
+ };
576
+ const next = (): SmtToken | undefined => {
577
+ for (;;) {
578
+ const character = text[state.index];
579
+ if (character === undefined) return undefined;
580
+ if (character === ";") {
581
+ while (state.index < text.length && text[state.index] !== "\n") advance();
582
+ continue;
583
+ }
584
+ if (character === " " || character === "\t" || character === "\r" || character === "\n") {
585
+ advance();
586
+ continue;
587
+ }
588
+ const start = state.index;
589
+ const position = { line: state.line, column: getColumn() };
590
+ const getToken = (kind: SmtToken["kind"], tokenText = text.slice(start, state.index)) => ({
591
+ kind,
592
+ text: tokenText,
593
+ ...position,
594
+ offset: start,
595
+ endOffset: state.index,
596
+ });
597
+ if (character === "(" || character === ")") {
598
+ advance();
599
+ return getToken(character);
600
+ }
601
+ if (character === "|" || character === '"') {
602
+ advance();
603
+ for (;;) {
604
+ if (state.index >= text.length)
605
+ throw new SmtParseError(
606
+ character === "|" ? "unexpected end of quoted symbol" : "unexpected end of string",
607
+ { line: state.line, column: getColumn() },
608
+ );
609
+ const current = text[state.index];
610
+ advance();
611
+ // Z3's scanner starts the line before it reads past a newline in a quoted symbol or a
612
+ // string, so the columns of the rest of the line count one more.
613
+ if (current === "\n") state.lineStart--;
614
+ if (current !== character) continue;
615
+ if (character !== '"' || text[state.index] !== '"') break;
616
+ advance();
617
+ }
618
+ const inner = text.slice(start + 1, state.index - 1);
619
+ return character === "|"
620
+ ? getToken("symbol", inner)
621
+ : getToken("string", inner.replaceAll('""', '"'));
622
+ }
623
+ if (/[0-9]/.test(character) || (character === "-" && /[0-9]/.test(text[start + 1] ?? ""))) {
624
+ advance();
625
+ readWhile(/[0-9]/);
626
+ if (text[state.index] !== ".") return getToken("numeral");
627
+ advance();
628
+ readWhile(/[0-9]/);
629
+ return getToken("decimal");
630
+ }
631
+ if (character === "#") {
632
+ advance();
633
+ readWhile(/[0-9A-Za-z]/);
634
+ return getToken("bitvector");
635
+ }
636
+ if (character === ":" || SYMBOL_CHARACTER.test(character)) {
637
+ advance();
638
+ readWhile(SYMBOL_CHARACTER);
639
+ return getToken(character === ":" ? "keyword" : "symbol");
640
+ }
641
+ advance();
642
+ throw new SmtParseError("unexpected character", position);
643
+ }
644
+ };
645
+ return { next, getPosition: () => ({ line: state.line, column: getColumn() }) };
131
646
  };
132
647
 
133
- const readSExprs = (tokens: string[]) => {
134
- const stack: SExpr[][] = [[]];
135
- for (const token of tokens) {
136
- if (token === "(") stack.push([]);
137
- else if (token === ")") {
138
- const list = stack.pop();
139
- if (list === undefined || stack.length === 0)
140
- throw new SmtParseError("unbalanced parentheses");
141
- stack[stack.length - 1].push(list);
142
- } else stack[stack.length - 1].push(token);
143
- }
144
- if (stack.length !== 1) throw new SmtParseError("unbalanced parentheses");
145
- return stack[0];
648
+ export const createCommandReader = (text: string) => {
649
+ const scanner = createScanner(text);
650
+ const state: { lookahead: SmtToken | undefined; depth: number } = {
651
+ lookahead: undefined,
652
+ depth: 0,
653
+ };
654
+ const take = () => {
655
+ const token = state.lookahead ?? scanner.next();
656
+ state.lookahead = undefined;
657
+ return token;
658
+ };
659
+ const readList = (open: SmtToken): SmtList => {
660
+ const stack: SmtList[] = [];
661
+ const root: SmtList = {
662
+ kind: "list",
663
+ items: [],
664
+ line: open.line,
665
+ column: open.column,
666
+ offset: open.offset,
667
+ end: open,
668
+ };
669
+ let rootObject: SmtList | undefined;
670
+ for (let current = root; ;) {
671
+ const token = take();
672
+ if (token === undefined)
673
+ throw new SmtParseError("unexpected end of file", scanner.getPosition());
674
+ if (rootObject !== undefined) rootObject.follower = token;
675
+ rootObject = undefined;
676
+ if (token.kind === "(") {
677
+ const list: SmtList = {
678
+ kind: "list",
679
+ items: [],
680
+ line: token.line,
681
+ column: token.column,
682
+ offset: token.offset,
683
+ end: token,
684
+ };
685
+ current.items.push(list);
686
+ stack.push(current);
687
+ state.depth++;
688
+ current = list;
689
+ continue;
690
+ }
691
+ if (token.kind !== ")") {
692
+ current.items.push(token);
693
+ continue;
694
+ }
695
+ current.end = token;
696
+ if (isSymbol(current.items[0], "root-obj")) rootObject = current;
697
+ state.depth--;
698
+ const parent = stack.pop();
699
+ if (parent === undefined) return root;
700
+ current = parent;
701
+ }
702
+ };
703
+ const read = (): SmtList | undefined => {
704
+ const token = take();
705
+ if (token === undefined) return undefined;
706
+ if (token.kind !== "(") throw new SmtParseError("invalid command, '(' expected", token);
707
+ state.depth = 1;
708
+ return readList(token);
709
+ };
710
+ const skip = (report: (error: SmtParseError) => void) => {
711
+ for (;;) {
712
+ try {
713
+ const token = take();
714
+ if (token === undefined) return;
715
+ if (token.kind === "(" && state.depth === 0) {
716
+ state.lookahead = token;
717
+ return;
718
+ }
719
+ if (token.kind === "(") state.depth++;
720
+ if (token.kind === ")") state.depth = Math.max(0, state.depth - 1);
721
+ } catch (error) {
722
+ if (!(error instanceof SmtParseError)) throw error;
723
+ report(error);
724
+ }
725
+ }
726
+ };
727
+ return { read, skip };
146
728
  };
147
729
 
148
- const expectList = (sexpr: SExpr | undefined): SExpr[] => {
149
- if (!Array.isArray(sexpr)) throw new SmtParseError("expected a list");
730
+ export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
731
+ sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
732
+
733
+ const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtList => {
734
+ if (sexpr?.kind !== "list") throw new SmtParseError(message, sexpr ?? at);
150
735
  return sexpr;
151
736
  };
152
737
 
153
- const expectSymbol = (sexpr: SExpr | undefined): string => {
154
- if (typeof sexpr !== "string") throw new SmtParseError("expected a symbol");
738
+ const expectSymbol = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtToken => {
739
+ if (!isSymbol(sexpr)) throw new SmtParseError(message, sexpr ?? at);
155
740
  return sexpr;
156
741
  };
157
742
 
158
- // Parses a script, and hands each assertion to assertExpr as Z3's cmd_context does, before it parses
159
- // the next command. Expressions are created in the order of Z3's parser, and live as long as there.
160
- export const parseSmtlib = (
161
- text: string,
743
+ export const createSmtlibReader = (
162
744
  manager: AstManager,
163
- assertExpr: (assertion: number) => void,
164
- ): SmtProblem => {
165
- const sorts = new Map<string, number>([
166
- ["Bool", SORT_BOOL],
167
- ["Int", SORT_INT],
168
- ["Real", SORT_REAL],
745
+ logic?: string,
746
+ options: ParserOptions = DEFAULT_PARSER_OPTIONS,
747
+ ) => {
748
+ const hasArith = logic === undefined || logicHasArith(logic);
749
+ const hasBv = logic === undefined || logicHasBv(logic);
750
+ const isNumeralAsReal = logic !== undefined && logicHasRealsOnly(logic);
751
+ const logicChecker = createLogicChecker(manager, logic);
752
+ const sortDecls = new Map<string, SortDecl>([
753
+ ["Bool", { kind: "sort", sort: SORT_BOOL }],
754
+ ...(hasArith
755
+ ? [
756
+ ["Int", { kind: "sort", sort: SORT_INT }] as const,
757
+ ["Real", { kind: "sort", sort: SORT_REAL }] as const,
758
+ ]
759
+ : []),
760
+ ...(logic === undefined ? [["List", { kind: "list" }] as const] : []),
169
761
  ]);
170
- const funcs = new Map<string, number>();
171
- const assertions: number[] = [];
762
+ const funcs = new Map<string, readonly number[]>();
763
+ const macros = new Map<string, Macro>();
764
+ const lastNamed = { name: "", expr: -1 };
765
+ const notifiedSorts = new Set<number>();
766
+ const undo: (() => void)[] = [];
767
+ const scopeStarts: number[] = [];
172
768
  const scopes: Map<string, Binding>[] = [];
173
- let depth = 0;
769
+ const binders = { depth: 0 };
770
+
771
+ const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
772
+ const previous = names.get(name);
773
+ undo.push(() => {
774
+ if (previous === undefined) names.delete(name);
775
+ else names.set(name, previous);
776
+ });
777
+ names.set(name, value);
778
+ };
779
+
780
+ const hasArrays = logic === undefined || logicHasArray(logic);
781
+ const hasFpa = logic === undefined || logicHasFpa(logic);
782
+ const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
783
+ const hasSeq = logic === undefined || logicHasSeq(logic);
174
784
 
175
- const parseSort = (sexpr: SExpr) => {
176
- const sort = sorts.get(expectSymbol(sexpr));
177
- if (sort === undefined) throw new SmtParseError(`unknown sort ${String(sexpr)}`);
785
+ const getFirstFunc = (name: string) => funcs.get(name)?.[0];
786
+
787
+ const checkDecl = (decl: number, at: SExpr) => {
788
+ const error = logicChecker.checkDecl(decl);
789
+ if (error !== undefined) throw new SmtParseError(error, at);
790
+ };
791
+
792
+ const insertFunc = (decl: number, at: SExpr) => {
793
+ checkDecl(decl, at);
794
+ const funcDecl = manager.funcDecls[decl];
795
+ const name = String(funcDecl.name);
796
+ if (macros.has(name))
797
+ throw new SmtParseError(
798
+ `invalid declaration, named expression already defined with this name ${name}`,
799
+ at,
800
+ );
801
+ const existing = funcs.get(name) ?? [];
802
+ if (existing.includes(decl))
803
+ throw new SmtParseError(
804
+ `invalid declaration, ${funcDecl.domain.length === 0 ? "constant" : "function"} '${name}' (with the given signature) already declared`,
805
+ at,
806
+ );
807
+ declare(funcs, name, [...existing, decl]);
808
+ };
809
+
810
+ const insertDatatypeDecls = (sort: number, at: SExpr) => {
811
+ for (const constructor of getDatatypeConstructors(manager, sort)) {
812
+ insertFunc(constructor, at);
813
+ insertFunc(getConstructorRecognizer(manager, constructor), at);
814
+ for (const accessor of getConstructorAccessors(manager, constructor))
815
+ insertFunc(accessor, at);
816
+ }
817
+ };
818
+
819
+ const notifyDatatype = (sort: number, at: SExpr) => {
820
+ const parameters = manager.getSortParameters(sort);
821
+ if (parameters.length === 0 || notifiedSorts.has(sort)) return;
822
+ if (getDatatypeDef(manager, sort) === undefined) return;
823
+ if (parameters.every((parameter) => manager.getTypeParameterIndex(parameter) === -1))
824
+ insertDatatypeDecls(sort, at);
825
+ notifiedSorts.add(sort);
826
+ undo.push(() => notifiedSorts.delete(sort));
827
+ };
828
+
829
+ const getDatatypeInstance = (decl: DatatypeSortDecl, parameters: number[], at: SExpr) => {
830
+ const key = parameters.join(",");
831
+ const sort = decl.instances.get(key) ?? mkDatatypeSort(manager, decl.name, parameters);
832
+ decl.instances.set(key, sort);
833
+ notifyDatatype(sort, at);
178
834
  return sort;
179
835
  };
180
836
 
837
+ const instantiateDatatype = (decl: DatatypeSortDecl, parameters: number[], at: SExpr) => {
838
+ const sort = getDatatypeInstance(decl, parameters, at);
839
+ const def = getDatatypeDef(manager, sort);
840
+ if (def === undefined || parameters.length === 0 || decl.siblings.length === 0) return sort;
841
+ const marked = new Set([sort]);
842
+ for (const constructor of def.constructors)
843
+ for (const accessor of constructor.accessors) {
844
+ const range = accessor.range;
845
+ if (!manager.isDatatypeSort(range) || marked.has(range)) continue;
846
+ marked.add(range);
847
+ const sibling = sortDecls.get(manager.sortNames[range]);
848
+ if (sibling?.kind !== "datatype" || !decl.siblings.includes(sibling.name)) continue;
849
+ const instance = substituteSort(manager, range, def.parameters, parameters);
850
+ getDatatypeInstance(sibling, [...manager.getSortParameters(instance)], at);
851
+ }
852
+ return sort;
853
+ };
854
+
855
+ const getSortDeclArity = (decl: SortDecl) =>
856
+ decl.kind === "sort"
857
+ ? 0
858
+ : decl.kind === "list"
859
+ ? 1
860
+ : decl.kind === "definition"
861
+ ? decl.parameters.length
862
+ : decl.arity;
863
+
864
+ const instantiateSort = (decl: SortDecl, parameters: number[], at: SExpr): number => {
865
+ if (decl.kind === "sort") return decl.sort;
866
+ if (decl.kind === "list") {
867
+ const element = manager.mkTypeParameter(0);
868
+ mkDatatypes(manager, [
869
+ mkDatatypeDef(
870
+ manager,
871
+ "List",
872
+ [element],
873
+ [
874
+ { name: "nil", recognizer: "is-nil", accessors: [] },
875
+ {
876
+ name: "insert",
877
+ recognizer: "is-insert",
878
+ accessors: [
879
+ { name: "head", range: element },
880
+ { name: "tail", range: -1 },
881
+ ],
882
+ },
883
+ ],
884
+ ),
885
+ ]);
886
+ const list: DatatypeSortDecl = {
887
+ kind: "datatype",
888
+ name: "List",
889
+ arity: 1,
890
+ siblings: [],
891
+ instances: new Map(),
892
+ };
893
+ sortDecls.set("List", list);
894
+ return instantiateSort(list, parameters, at);
895
+ }
896
+ if (decl.kind === "user") return manager.mkUninterpretedSort(decl.name, parameters);
897
+ if (decl.kind === "datatype") return instantiateDatatype(decl, parameters, at);
898
+ return parseSort(
899
+ decl.body,
900
+ "",
901
+ new Map(decl.parameters.map((name, index) => [name, parameters[index]])),
902
+ );
903
+ };
904
+
905
+ const parseParametricSort = (
906
+ sexpr: SmtList,
907
+ context: string,
908
+ bindings: ReadonlyMap<string, number>,
909
+ ): number => {
910
+ const head = sexpr.items[0];
911
+ if (!isSymbol(head)) throw new SmtParseError("invalid sort, symbol or '_' expected", head);
912
+ const isArray = ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && hasArrayExtensions);
913
+ if (isArray && hasArrays) {
914
+ const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
915
+ if (head.text === "Set" ? parameters.length !== 1 : parameters.length < 2)
916
+ throw new SmtParseError(
917
+ "invalid array sort definition, invalid number of parameters",
918
+ sexpr.end,
919
+ );
920
+ return manager.mkArraySort(head.text === "Set" ? [parameters[0], SORT_BOOL] : parameters);
921
+ }
922
+ const decl = sortDecls.get(head.text);
923
+ if (decl === undefined && hasSeq && (head.text === "Seq" || head.text === "RegEx")) {
924
+ const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
925
+ if (parameters.length !== 1)
926
+ throw new SmtParseError(
927
+ head.text === "Seq"
928
+ ? "Invalid sequence sort, expecting one parameter"
929
+ : "Invalid regex sort, expecting one parameter",
930
+ sexpr.end,
931
+ );
932
+ return head.text === "Seq"
933
+ ? manager.mkSeqSort(parameters[0])
934
+ : manager.mkReSort(parameters[0]);
935
+ }
936
+ if (decl === undefined && hasFpa && FPA_SORT_NAMES.has(head.text)) {
937
+ const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
938
+ if (head.text === "FloatingPoint") return mkFloatSort([], sexpr);
939
+ if (parameters.length > 0)
940
+ throw new SmtUnsupportedError("parameters on a floating-point sort");
941
+ return parseSort(head, context, bindings);
942
+ }
943
+ if (decl === undefined) {
944
+ if (THEORY_SORTS.has(head.text) && !isArray)
945
+ throw new SmtUnsupportedError(`the sort ${head.text}`);
946
+ throw new SmtParseError(`unknown sort '${head.text}'`, head);
947
+ }
948
+ const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
949
+ if (parameters.length !== getSortDeclArity(decl))
950
+ throw new SmtParseError("invalid number of parameters to sort constructor", sexpr.end);
951
+ return instantiateSort(decl, parameters, sexpr);
952
+ };
953
+
954
+ // parse_psort: Z3 makes the leaves and the indexed sorts of a sort definition, and an application
955
+ // of a builtin sort, which takes any number of parameters, only when the definition is used.
956
+ const checkPsort = (sexpr: SExpr, bindings: ReadonlyMap<string, number>) => {
957
+ const head = sexpr.kind === "list" ? sexpr.items[0] : undefined;
958
+ if (
959
+ head === undefined ||
960
+ !isSymbol(head) ||
961
+ head.text === "_" ||
962
+ sortDecls.has(head.text) ||
963
+ !isBuiltinParametricSort(head.text)
964
+ ) {
965
+ parseSort(sexpr, "", bindings);
966
+ return;
967
+ }
968
+ for (const item of (sexpr as SmtList).items.slice(1)) checkPsort(item, bindings);
969
+ };
970
+
971
+ const isBuiltinParametricSort = (name: string) =>
972
+ (hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && hasArrayExtensions))) ||
973
+ (hasSeq && (name === "Seq" || name === "RegEx")) ||
974
+ (hasFpa && FPA_SORT_NAMES.has(name));
975
+
976
+ const mkFloatSort = (indices: SExpr[], at: SExpr) => {
977
+ const ebitsIndex = indices[0];
978
+ const sbitsIndex = indices[1];
979
+ if (indices.length !== 2 || ebitsIndex.kind !== "numeral" || sbitsIndex.kind !== "numeral")
980
+ throw new SmtParseError(
981
+ "expecting two integer parameters to floating point sort (ebits, sbits)",
982
+ at.kind === "list" ? at.end : at,
983
+ );
984
+ const ebits = Number(ebitsIndex.text);
985
+ const sbits = Number(sbitsIndex.text);
986
+ const error = getFloatSortError(ebits, sbits);
987
+ if (error !== undefined) throw new SmtParseError(error, at.kind === "list" ? at.end : at);
988
+ return manager.mkFpSort(ebits, sbits);
989
+ };
990
+
991
+ const parseSort = (
992
+ sexpr: SExpr,
993
+ context: string,
994
+ bindings: ReadonlyMap<string, number> = NO_BINDINGS,
995
+ ): number => {
996
+ if (sexpr.kind === "list") {
997
+ if (!isSymbol(sexpr.items[0], "_")) return parseParametricSort(sexpr, context, bindings);
998
+ if (hasFpa && isSymbol(sexpr.items[1], "FloatingPoint"))
999
+ return mkFloatSort(sexpr.items.slice(2), sexpr);
1000
+ const width = sexpr.items[2];
1001
+ if (!hasBv && isSymbol(sexpr.items[1], "BitVec"))
1002
+ throw new SmtParseError("unknown sort 'BitVec'", width ?? sexpr.end);
1003
+ if (
1004
+ !isSymbol(sexpr.items[1], "BitVec") ||
1005
+ sexpr.items.length !== 3 ||
1006
+ width.kind !== "numeral"
1007
+ )
1008
+ throw new SmtUnsupportedError("indexed sorts");
1009
+ if (BigInt(width.text) === 0n)
1010
+ throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
1011
+ return manager.mkBvSort(Number(width.text));
1012
+ }
1013
+ const decl = sortDecls.get(sexpr.text);
1014
+ if (decl !== undefined) {
1015
+ if (getSortDeclArity(decl) !== 0)
1016
+ throw new SmtParseError("sort constructor expects parameters", sexpr);
1017
+ return instantiateSort(decl, [], sexpr);
1018
+ }
1019
+ const bound = bindings.get(sexpr.text);
1020
+ if (bound !== undefined) return bound;
1021
+ if (hasSeq && (SEQ_SORT_NAMES.has(sexpr.text) || sexpr.text === "Unicode")) {
1022
+ if (sexpr.text === "String" || sexpr.text === "StringSequence") return manager.mkStringSort();
1023
+ if (sexpr.text === "RegLan") return manager.mkReSort(manager.mkStringSort());
1024
+ if (sexpr.text === "Unicode") return manager.mkCharSort();
1025
+ throw new SmtParseError(
1026
+ sexpr.text === "Seq"
1027
+ ? "Invalid sequence sort, expecting one parameter"
1028
+ : "Invalid regex sort, expecting one parameter",
1029
+ sexpr,
1030
+ );
1031
+ }
1032
+ if (hasFpa && FPA_SORT_NAMES.has(sexpr.text)) {
1033
+ if (sexpr.text === "RoundingMode") return manager.mkRmSort();
1034
+ const bits = FPA_SORT_NAMES.get(sexpr.text);
1035
+ return bits === undefined ? mkFloatSort([], sexpr) : manager.mkFpSort(bits[0], bits[1]);
1036
+ }
1037
+ if (THEORY_SORTS.has(sexpr.text)) throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
1038
+ throw new SmtParseError(
1039
+ `${context === "" ? "" : `${context}: `}unknown sort '${sexpr.text}'`,
1040
+ sexpr,
1041
+ );
1042
+ };
1043
+
181
1044
  const lookup = (name: string) => {
182
1045
  for (let index = scopes.length - 1; index >= 0; index--) {
183
1046
  const binding = scopes[index].get(name);
@@ -186,40 +1049,22 @@ export const parseSmtlib = (
186
1049
  return undefined;
187
1050
  };
188
1051
 
189
- // basic_decl_plugin::join: Int and Real join to Real. Other sorts join only with themselves.
190
1052
  const getJoin = (args: number[]) => {
191
1053
  const argSorts = args.map((arg) => manager.sorts[arg]);
192
1054
  if (!argSorts.every(isArithSort)) return argSorts[0];
193
1055
  return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
194
1056
  };
195
1057
 
196
- // The sort of the arguments of a builtin, as Z3's decl plugins pick its declaration.
197
1058
  const getDomainSort = (op: number, args: number[]) => {
198
1059
  if (op === OP_ITE) return getJoin(args.slice(1));
199
1060
  if (op === OP_EQ || op === OP_DISTINCT) return getJoin(args);
200
1061
  if (COERCING_OPS.has(op)) return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
201
1062
  if (op === OP_ABS || op === OP_TO_REAL || op === OP_TO_INT) return manager.sorts[args[0]];
202
- if (op === OP_IDIV || op === OP_MOD) return SORT_INT;
203
- if (op === OP_DIV || op === OP_IS_INT) return SORT_REAL;
1063
+ if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
1064
+ if (op === OP_DIV || op === OP_IS_INT || REAL_FUNCTION_OPS.has(op)) return SORT_REAL;
204
1065
  return SORT_BOOL;
205
1066
  };
206
1067
 
207
- const getRange = (op: number, domainSort: number) =>
208
- op === OP_TO_REAL || op === OP_DIV
209
- ? SORT_REAL
210
- : op === OP_TO_INT || op === OP_IDIV || op === OP_MOD
211
- ? SORT_INT
212
- : op === OP_ITE ||
213
- op === OP_ABS ||
214
- op === OP_ADD ||
215
- op === OP_SUB ||
216
- op === OP_UMINUS ||
217
- op === OP_MUL
218
- ? domainSort
219
- : SORT_BOOL;
220
-
221
- // ast_manager::coerce_to: an Int argument of a Real position becomes to_real, and a Real argument
222
- // of an Int position to_int.
223
1068
  const coerce = (arg: number, sort: number) => {
224
1069
  const argSort = manager.sorts[arg];
225
1070
  if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
@@ -228,13 +1073,13 @@ export const parseSmtlib = (
228
1073
  : manager.mkApp(OP_TO_INT, [arg], SORT_INT);
229
1074
  };
230
1075
 
231
- // Coerces the arguments of an application to the sorts of its declaration, as Z3 does with its
232
- // default int_real_coercions, then checks their sorts and number, so the solver only sees
233
- // well-sorted terms, and that quantifiers occur only under Boolean connectives.
234
- const mkApp = (decl: number, inputArgs: number[], domainSort?: number) => {
1076
+ const mkApp = (decl: number, inputArgs: number[], at: SExpr, domainSort?: number) => {
235
1077
  const op = manager.funcDecls[decl].op;
236
1078
  const name = manager.funcDecls[decl].name;
237
- const isUninterpreted = op === OP_UNINTERPRETED;
1079
+ const isUninterpreted =
1080
+ op === OP_UNINTERPRETED ||
1081
+ op === OP_FUN_DEFINED ||
1082
+ manager.funcDecls[decl].family === FAMILY_DATATYPE;
238
1083
  const domain = manager.funcDecls[decl].domain;
239
1084
  const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
240
1085
  const getExpected = (index: number) =>
@@ -242,73 +1087,55 @@ export const parseSmtlib = (
242
1087
  const args = inputArgs.map((arg, index) =>
243
1088
  getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
244
1089
  );
245
- const isArity = (min: number, max: number) => args.length >= min && args.length <= max;
1090
+ const arity = ARITIES.get(op) ?? [1, Infinity];
246
1091
  const isArityOk = isUninterpreted
247
1092
  ? args.length === domain.length
248
- : op === OP_AND || op === OP_OR
249
- ? true
250
- : op === OP_ITE
251
- ? isArity(3, 3)
252
- : op === OP_EQ || op === OP_DISTINCT
253
- ? isArity(2, Infinity)
254
- : op === OP_NOT ||
255
- op === OP_UMINUS ||
256
- op === OP_ABS ||
257
- op === OP_TO_REAL ||
258
- op === OP_TO_INT ||
259
- op === OP_IS_INT
260
- ? isArity(1, 1)
261
- : op === OP_IMPLIES ||
262
- op === OP_XOR ||
263
- op === OP_IDIV ||
264
- op === OP_MOD ||
265
- op === OP_DIV ||
266
- op === OP_LE ||
267
- op === OP_GE ||
268
- op === OP_LT ||
269
- op === OP_GT
270
- ? isArity(2, 2)
271
- : isArity(1, Infinity);
1093
+ : args.length >= arity[0] && args.length <= arity[1];
272
1094
  const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
273
1095
  const isWellSorted =
274
1096
  isArityOk &&
275
1097
  (!isBuiltinArith || isArithSort(builtinSort)) &&
276
1098
  args.every((arg, index) => manager.sorts[arg] === getExpected(index));
277
- if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`);
1099
+ if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`, at);
278
1100
  return manager.mkApp(
279
1101
  decl,
280
1102
  args,
281
- isUninterpreted ? manager.funcDecls[decl].range : getRange(op, builtinSort),
1103
+ isUninterpreted ? manager.funcDecls[decl].range : (RANGES.get(op) ?? builtinSort),
282
1104
  );
283
1105
  };
284
1106
 
285
- const mkChain = (op: number, args: number[]) => {
1107
+ const mkChain = (op: number, args: number[], at: SExpr) => {
286
1108
  const domainSort = getDomainSort(op, args);
287
1109
  const pairs: number[] = [];
288
1110
  for (let index = 0; index + 1 < args.length; index++)
289
- pairs.push(mkApp(op, [args[index], args[index + 1]], domainSort));
290
- return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs);
1111
+ pairs.push(mkApp(op, [args[index], args[index + 1]], at, domainSort));
1112
+ return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs, at);
291
1113
  };
292
1114
 
293
- const expectBool = (expr: number) => {
294
- if (manager.sorts[expr] !== SORT_BOOL) throw new SmtParseError("expected a formula");
295
- return expr;
1115
+ const rejectPattern = (message: string, at: SExpr) => {
1116
+ if (!options.isIgnoringBadPatterns) throw new SmtParseError(message, at);
1117
+ return undefined;
296
1118
  };
297
1119
 
298
- // push_pattern_frame with ignore_bad_patterns: (t1 ... tn) is a multi-pattern, (f a ...) a pattern
299
- // of one term, and a pattern that starts with a constant is dropped unparsed.
300
- const parsePattern = (sexpr: SExpr) => {
301
- if (!Array.isArray(sexpr) || sexpr.length === 0) return undefined;
302
- const head = sexpr[0];
303
- if (Array.isArray(head)) return manager.mkPattern(sexpr.map(parseTerm));
304
- const decl = head === "true" || head === "false" ? -1 : funcs.get(head);
1120
+ const parsePattern = (sexpr: SExpr, at: SExpr) => {
1121
+ if (sexpr.kind === ")") {
1122
+ // Z3 skips a bad pattern as an s-expression, which cannot start with ')'.
1123
+ if (options.isIgnoringBadPatterns)
1124
+ throw new SmtParseError("invalid s-expression, unexpected ')'", sexpr);
1125
+ throw new SmtParseError("invalid pattern, '(' expected", sexpr);
1126
+ }
1127
+ if (sexpr.kind !== "list") return rejectPattern("invalid pattern, '(' expected", sexpr);
1128
+ if (sexpr.items.length === 0) return rejectPattern("invalid empty pattern", at);
1129
+ const head = sexpr.items[0];
1130
+ if (head.kind === "list") return manager.mkPattern(sexpr.items.map(parseTerm));
1131
+ const decl = head.text === "true" || head.text === "false" ? -1 : getFirstFunc(head.text);
305
1132
  if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
306
- return undefined;
1133
+ return rejectPattern("invalid constant pattern", head);
1134
+ if (head.kind !== "symbol")
1135
+ throw new SmtParseError("invalid pattern, '(' or identifier expected", head);
307
1136
  return manager.mkPattern([parseTerm(sexpr)]);
308
1137
  };
309
1138
 
310
- // pattern_validator: a pattern has no Boolean operator other than equality, no quantifier, and
311
- // every variable of its quantifier.
312
1139
  const isValidPattern = (pattern: number, numDecls: number) => {
313
1140
  const found = new Set<number>();
314
1141
  const isValid = (expr: number): boolean => {
@@ -331,196 +1158,1522 @@ export const parseSmtlib = (
331
1158
  return manager.everyArg(pattern, isValid) && found.size === numDecls;
332
1159
  };
333
1160
 
334
- const parseQuantifier = (list: SExpr[], isForall: boolean) => {
335
- const declarations = expectList(list[1]);
1161
+ const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr) => {
1162
+ const message = "invalid sorted variables, syntax error: ((<symbol> <sort>)*) expected";
1163
+ const declarations = expectList(sexpr, message, at).items.map((declaration) =>
1164
+ expectList(declaration, message, declaration),
1165
+ );
336
1166
  const scope = new Map<string, Binding>();
337
- const names = declarations.map((declaration) => expectSymbol(expectList(declaration)[0]));
1167
+ const names = declarations.map(
1168
+ (declaration) => expectSymbol(declaration.items[0], message, declaration).text,
1169
+ );
338
1170
  const varSorts = declarations.map((declaration, index) => {
339
- const sort = parseSort(expectList(declaration)[1]);
340
- scope.set(names[index], { kind: "var", depth: depth + index, sort });
1171
+ if (declaration.items.length !== 2) throw new SmtParseError(message, declaration.end);
1172
+ const sort = parseSort(declaration.items[1], "invalid sorted variables");
1173
+ scope.set(names[index], { kind: "var", depth: binders.depth + index, sort });
341
1174
  return sort;
342
1175
  });
343
1176
  scopes.push(scope);
344
- depth += varSorts.length;
1177
+ binders.depth += varSorts.length;
1178
+ return { names, varSorts };
1179
+ };
1180
+
1181
+ const unbindSortedVars = (count: number) => {
1182
+ scopes.pop();
1183
+ binders.depth -= count;
1184
+ };
1185
+
1186
+ const parseQuantifier = (list: SmtList, kind: number) => {
1187
+ if (list.items.length !== 3)
1188
+ throw new SmtParseError(
1189
+ "invalid quantified expression, syntax error: (forall|exists ((<symbol> <sort>)*) <expr>) expected",
1190
+ list.end,
1191
+ );
1192
+ const bound = bindSortedVars(list.items[1], list);
1193
+ const varSorts = bound.varSorts;
345
1194
  // parse_sorted_vars: the variables are created first, the first declared with the largest index,
346
1195
  // and the parser's stack holds them until the quantifier is created.
347
1196
  const boundVars = varSorts.map((sort, index) =>
348
1197
  manager.mkVar(varSorts.length - 1 - index, sort),
349
1198
  );
350
1199
  for (const boundVar of boundVars) manager.incRef(boundVar);
351
- const bodySExpr = list[2];
352
- const isAnnotated = Array.isArray(bodySExpr) && bodySExpr[0] === "!";
353
- const body = expectBool(parseTerm(isAnnotated ? bodySExpr[1] : bodySExpr));
1200
+ const bodySExpr = list.items[2];
1201
+ const isAnnotated = bodySExpr.kind === "list" && isSymbol(bodySExpr.items[0], "!");
1202
+ const annotations = bodySExpr.kind === "list" && isAnnotated ? bodySExpr.items : [];
1203
+ const parsedBody = parseTerm(isAnnotated ? annotations[1] : bodySExpr);
1204
+ if (kind !== QUANTIFIER_LAMBDA && manager.sorts[parsedBody] !== SORT_BOOL)
1205
+ throw new SmtParseError("expected a formula", bodySExpr);
1206
+ const attributes = Array.from(
1207
+ { length: Math.ceil((annotations.length - 2) / 2) },
1208
+ (_unused, index) => ({
1209
+ keyword: annotations[2 + 2 * index],
1210
+ value: annotations[3 + 2 * index],
1211
+ }),
1212
+ );
1213
+ const body = attributes.reduce(
1214
+ (labeled, attribute) =>
1215
+ attribute.keyword.kind === "keyword" &&
1216
+ (attribute.keyword.text === ":lblpos" || attribute.keyword.text === ":lblneg")
1217
+ ? mkLabel(labeled, attribute.keyword.text === ":lblpos", attribute.value, bodySExpr)
1218
+ : labeled,
1219
+ parsedBody,
1220
+ );
354
1221
  const patterns: number[] = [];
355
- let weight = 1;
356
- let qid = "";
357
- if (isAnnotated)
358
- for (let index = 2; index < bodySExpr.length; index += 2) {
359
- const keyword = bodySExpr[index];
360
- const value = bodySExpr[index + 1];
361
- if (keyword === ":pattern") {
362
- const pattern = parsePattern(value);
363
- if (pattern !== undefined) {
364
- manager.incRef(pattern);
365
- patterns.push(pattern);
366
- }
367
- } else if (keyword === ":weight") weight = Number(value);
368
- else if (keyword === ":qid") qid = expectSymbol(value);
1222
+ const noPatterns: number[] = [];
1223
+ for (const attribute of attributes) {
1224
+ if (attribute.keyword.kind !== "keyword") continue;
1225
+ if (attribute.keyword.text === ":no-pattern") {
1226
+ const noPattern = parseTerm(attribute.value ?? list.end);
1227
+ manager.incRef(noPattern);
1228
+ noPatterns.push(noPattern);
1229
+ continue;
369
1230
  }
370
- scopes.pop();
371
- depth -= varSorts.length;
1231
+ if (attribute.keyword.text !== ":pattern") continue;
1232
+ const pattern = parsePattern(
1233
+ attribute.value ?? (bodySExpr.kind === "list" ? bodySExpr.end : list.end),
1234
+ list.end,
1235
+ );
1236
+ if (pattern === undefined) continue;
1237
+ manager.incRef(pattern);
1238
+ patterns.push(pattern);
1239
+ }
1240
+ const getAttribute = (name: string) => {
1241
+ const value = attributes
1242
+ .filter(
1243
+ (attribute) =>
1244
+ attribute.keyword.kind === "keyword" &&
1245
+ attribute.keyword.text === name &&
1246
+ attribute.value?.kind !== "list",
1247
+ )
1248
+ .at(-1)?.value;
1249
+ return value?.kind === "list" ? undefined : value?.text;
1250
+ };
1251
+ const weight = Number(getAttribute(":weight") ?? 1);
1252
+ const qid = getAttribute(":qid") ?? "";
1253
+ const skid = getAttribute(":skolemid");
1254
+ unbindSortedVars(varSorts.length);
372
1255
  // pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
373
1256
  // and the valid ones after.
374
1257
  let numKept = 0;
375
1258
  for (const pattern of patterns) {
376
- if (!isValidPattern(pattern, varSorts.length)) continue;
1259
+ if (!isValidPattern(pattern, varSorts.length)) {
1260
+ rejectPattern("invalid pattern", list.end);
1261
+ continue;
1262
+ }
377
1263
  manager.incRef(pattern);
378
1264
  manager.decRef(patterns[numKept]);
379
1265
  patterns[numKept] = pattern;
380
1266
  numKept++;
381
1267
  }
382
1268
  for (const removed of patterns.splice(numKept)) manager.decRef(removed);
1269
+ if (patterns.length > 0 && noPatterns.length > 0)
1270
+ throw new SmtParseError("simultaneous patterns and no-patterns not supported", list.end);
383
1271
  const quantifier = manager.mkQuantifier({
384
- isForall,
1272
+ kind,
385
1273
  sorts: varSorts,
386
- names,
1274
+ names: bound.names,
387
1275
  body,
388
1276
  patterns,
1277
+ noPatterns,
389
1278
  weight,
390
1279
  qid,
1280
+ ...(skid === undefined ? {} : { skid }),
391
1281
  });
392
1282
  for (const pattern of patterns) manager.decRef(pattern);
1283
+ for (const noPattern of noPatterns) manager.decRef(noPattern);
393
1284
  for (const boundVar of boundVars) manager.decRef(boundVar);
394
1285
  return quantifier;
395
1286
  };
396
1287
 
397
- const parseLet = (list: SExpr[]) => {
1288
+ const parseLet = (list: SmtList) => {
1289
+ const message = "invalid let declaration, symbol expected";
398
1290
  const scope = new Map<string, Binding>();
399
- for (const binding of expectList(list[1])) {
400
- const pair = expectList(binding);
401
- const expr = parseTerm(pair[1]);
402
- scope.set(expectSymbol(pair[0]), { kind: "let", depth, expr });
1291
+ const exprs: number[] = [];
1292
+ for (const binding of expectList(list.items[1], message, list).items) {
1293
+ const pair = expectList(binding, message, binding);
1294
+ const name = expectSymbol(pair.items[0], message, pair);
1295
+ const expr = parseTerm(pair.items[1] ?? pair.end);
1296
+ exprs.push(expr);
1297
+ scope.set(name.text, { kind: "let", depth: binders.depth, expr });
403
1298
  }
404
1299
  scopes.push(scope);
405
- const body = parseTerm(list[2]);
1300
+ // Z3 takes the last expression on its stack, so a let without a body is its last binding.
1301
+ for (const body of list.items.slice(2)) exprs.push(parseTerm(body));
406
1302
  scopes.pop();
407
- return body;
408
- };
409
-
410
- const parseApp = (name: string, args: number[]) => {
411
- const chainable = CHAINABLE_OPS.get(name);
412
- if (chainable !== undefined) return mkChain(chainable, args);
413
- if (name === "-") return mkApp(args.length === 1 ? OP_UMINUS : OP_SUB, args);
414
- // ast_manager::mk_app: / is left associative, so more arguments nest to the left.
415
- if (name === "/" && args.length > 2)
416
- return args
417
- .slice(1)
418
- .reduce((dividend, divisor) => mkApp(OP_DIV, [dividend, divisor]), args[0]);
419
- const op = BUILTIN_OPS.get(name);
420
- if (op !== undefined) return mkApp(op, args);
421
- const decl = funcs.get(name);
422
- if (decl === undefined) throw new SmtParseError(`unknown function ${name}`);
423
- return mkApp(decl, args);
424
- };
425
-
426
- // A term without nested applications to parse first: a symbol, a quantifier, a let or an
427
- // annotation.
428
- const parseLeaf = (sexpr: SExpr): number => {
429
- if (typeof sexpr === "string") {
430
- if (/^[0-9]+$/.test(sexpr)) return manager.mkNumeral(BigInt(sexpr));
431
- const decimal = DECIMAL.exec(sexpr);
432
- if (decimal !== null)
433
- return manager.mkRealNumeral(
434
- Rational.of(BigInt(decimal[1] + decimal[2]), 10n ** BigInt(decimal[2].length)),
1303
+ const result = exprs.at(-1);
1304
+ if (result === undefined) throw new SmtParseError("invalid let expression", list.end);
1305
+ return result;
1306
+ };
1307
+
1308
+ const expandMacro = (macro: Macro, args: number[]) =>
1309
+ replaceFreeVars(manager, macro.body, (_variable, index, shift) => {
1310
+ const arg = args[args.length - 1 - index];
1311
+ return shift === 0
1312
+ ? arg
1313
+ : replaceFreeVars(manager, arg, (inner, innerIndex, innerShift) =>
1314
+ manager.mkVar(innerIndex + innerShift + shift, manager.sorts[inner]),
1315
+ );
1316
+ });
1317
+
1318
+ const isBvOpName = (name: string) =>
1319
+ hasBv &&
1320
+ BV_OP_NAMES.has(name) &&
1321
+ (!BV_EXTENSION_NAMES.has(name) || logic === undefined || BV_EXTENSION_LOGICS.has(logic));
1322
+
1323
+ const mkBvApp = (name: string, args: number[], indices: number[], at: SExpr) => {
1324
+ const op = BV_OP_NAMES.get(name) ?? -1;
1325
+ const signature = getBvSignature(
1326
+ manager,
1327
+ op,
1328
+ args.map((arg) => manager.sorts[arg]),
1329
+ indices,
1330
+ );
1331
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1332
+ const decl = manager.mkBvDecl(op, signature.name, indices, signature.domain, signature.range);
1333
+ return manager.mkApp(decl, args, signature.range);
1334
+ };
1335
+
1336
+ const isFpaOpName = (name: string) => hasFpa && FPA_OP_NAMES.has(name);
1337
+
1338
+ // pb_decl_plugin::get_op_names and mk_func_decl.
1339
+ const isPbOpName = (name: string) =>
1340
+ PB_OP_NAMES.has(name) &&
1341
+ (logic === undefined || logic === "QF_FD" || logic === "ALL" || logic === "HORN");
1342
+
1343
+ const mkPbTerm = (name: string, args: number[], parameters: Rational[], at: SExpr) => {
1344
+ const op = PB_OP_NAMES.get(name) ?? -1;
1345
+ if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
1346
+ throw new SmtParseError("invalid non-Boolean sort applied to Pseudo-Boolean relation", at);
1347
+ const isCardinality = op === OP_AT_MOST_K || op === OP_AT_LEAST_K;
1348
+ if (isCardinality && parameters.length !== 1)
1349
+ throw new SmtParseError("function expects one non-negative integer parameter", at);
1350
+ if (!isCardinality && parameters.length !== 1 + args.length)
1351
+ throw new SmtParseError("function expects arity+1 rational parameters", at);
1352
+ const decl = manager.mkPbDecl(
1353
+ op,
1354
+ parameters,
1355
+ args.map(() => SORT_BOOL),
1356
+ );
1357
+ return manager.mkApp(decl, args, SORT_BOOL);
1358
+ };
1359
+
1360
+ const mkFpaTerm = (name: string, args: number[], indices: number[], at: SExpr) => {
1361
+ const op = FPA_OP_NAMES.get(name) ?? -1;
1362
+ const getSignature = (innerArgs: number[]) => {
1363
+ const signature = getFpaSignature(
1364
+ manager,
1365
+ op,
1366
+ indices,
1367
+ innerArgs.map((arg) => manager.sorts[arg]),
1368
+ );
1369
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1370
+ return signature;
1371
+ };
1372
+ const signature = getSignature(args);
1373
+ if (signature.domain.length === args.length) return mkFpaAppOf(manager, signature, args);
1374
+ const pairs: number[] = [];
1375
+ for (let index = 0; index + 1 < args.length; index++) {
1376
+ const pair = [args[index], args[index + 1]];
1377
+ pairs.push(mkFpaAppOf(manager, getSignature(pair), pair));
1378
+ }
1379
+ return mkApp(OP_AND, pairs, at);
1380
+ };
1381
+
1382
+ const isSeqOpName = (name: string) =>
1383
+ hasSeq && (SEQ_OP_NAMES.has(name) || CHAR_OP_NAMES.has(name));
1384
+
1385
+ const mkSeqTerm = (
1386
+ name: string,
1387
+ args: number[],
1388
+ indices: number[],
1389
+ at: SExpr,
1390
+ range?: number,
1391
+ ) => {
1392
+ const signature = getSeqSignature(
1393
+ manager,
1394
+ SEQ_OP_NAMES.get(name) ?? CHAR_OP_NAMES.get(name) ?? -1,
1395
+ indices,
1396
+ args.map((arg) => manager.sorts[arg]),
1397
+ range,
1398
+ );
1399
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1400
+ return mkSeqAppOf(manager, signature, args);
1401
+ };
1402
+
1403
+ const parseUpolynomial = (sexpr: SExpr): bigint[] => {
1404
+ if (sexpr.kind === "numeral") return UPOLYNOMIALS.set([BigInt(sexpr.text)]);
1405
+ if (sexpr.kind === "decimal") {
1406
+ const parts = sexpr.text.split(".");
1407
+ const value = Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length));
1408
+ if (!value.isInt())
1409
+ throw new SmtParseError(
1410
+ "invalid univariate polynomial, integer coefficient expected",
1411
+ sexpr,
435
1412
  );
436
- if (sexpr === "true") return manager.trueExpr;
437
- if (sexpr === "false") return manager.falseExpr;
438
- const binding = lookup(sexpr);
439
- if (binding?.kind === "var") return manager.mkVar(depth - 1 - binding.depth, binding.sort);
1413
+ return UPOLYNOMIALS.set([value.num]);
1414
+ }
1415
+ if (sexpr.kind === "symbol") {
1416
+ if (sexpr.text !== "x")
1417
+ throw new SmtParseError("invalid univariate polynomial, variable 'x' expected", sexpr);
1418
+ return [0n, 1n];
1419
+ }
1420
+ if (sexpr.kind !== "list")
1421
+ throw new SmtParseError("invalid univariate polynomial, unexpected ", sexpr);
1422
+ const head = sexpr.items[0];
1423
+ if (!isSymbol(head))
1424
+ throw new SmtParseError("invalid univariate polynomial, symbol expected", sexpr);
1425
+ const operands = sexpr.items.slice(1);
1426
+ if (head.text === "^") {
1427
+ if (operands.length !== 2)
1428
+ throw new SmtParseError(
1429
+ "invalid univariate polynomial, '^' operator expects two arguments",
1430
+ sexpr,
1431
+ );
1432
+ const exponent = operands[1];
1433
+ if (exponent.kind !== "numeral" || BigInt(exponent.text) > 0xffffffffn)
1434
+ throw new SmtParseError(
1435
+ "invalid univariate polynomial, exponent must be an unsigned integer",
1436
+ exponent,
1437
+ );
1438
+ return UPOLYNOMIALS.pw(parseUpolynomial(operands[0]), Number(exponent.text));
1439
+ }
1440
+ const combine =
1441
+ head.text === "+"
1442
+ ? UPOLYNOMIALS.add
1443
+ : head.text === "-"
1444
+ ? UPOLYNOMIALS.sub
1445
+ : head.text === "*"
1446
+ ? UPOLYNOMIALS.mul
1447
+ : undefined;
1448
+ if (combine === undefined)
1449
+ throw new SmtParseError(
1450
+ "invalid univariate polynomial, '+', '-', '^' or '*' expected",
1451
+ sexpr,
1452
+ );
1453
+ if (operands.length === 0)
1454
+ throw new SmtParseError(
1455
+ `invalid univariate polynomial, '${head.text}' operator expects at least one argument`,
1456
+ sexpr,
1457
+ );
1458
+ const first = parseUpolynomial(operands[0]);
1459
+ if (head.text === "-" && operands.length === 1) return UPOLYNOMIALS.neg(first);
1460
+ return operands
1461
+ .slice(1)
1462
+ .reduce(
1463
+ (result, operand) => combine.call(UPOLYNOMIALS, result, parseUpolynomial(operand)),
1464
+ first,
1465
+ );
1466
+ };
1467
+
1468
+ const parseRootObj = (list: SmtList) => {
1469
+ const polynomial = list.items[1] ?? list.end;
1470
+ const index = list.items[2] ?? list.end;
1471
+ if (index.kind !== "numeral")
1472
+ throw new SmtParseError("invalid root-obj, (unsigned) integer expected", index);
1473
+ if (BigInt(index.text) > 0xffffffffn)
1474
+ throw new SmtParseError(
1475
+ "invalid root-obj, index must fit in an unsigned machine integer",
1476
+ index,
1477
+ );
1478
+ if (BigInt(index.text) === 0n)
1479
+ throw new SmtParseError("invalid root-obj, index must be >= 1", index);
1480
+ if (list.items.length > 3)
1481
+ throw new SmtParseError("invalid root-obj, ')' expected", list.items[3]);
1482
+ const coeffs = parseUpolynomial(polynomial);
1483
+ const follower = list.follower ?? list.end;
1484
+ if (coeffs.length === 0)
1485
+ throw new SmtParseError(
1486
+ "invalid root object, polynomial must not be the zero polynomial",
1487
+ follower,
1488
+ );
1489
+ const roots = manager.am.isolateUnivariateRoots(coeffs);
1490
+ const root = roots[Number(index.text) - 1];
1491
+ if (root === undefined)
1492
+ throw new SmtParseError(
1493
+ "invalid root object, polynomial does have sufficient roots",
1494
+ follower,
1495
+ );
1496
+ return manager.mkAlgebraicNumeral(root);
1497
+ };
1498
+
1499
+ const parseBvNumeral = (list: SmtList) => {
1500
+ const name = list.items[1];
1501
+ const indices = list.items.slice(2);
1502
+ if (
1503
+ isSymbol(name) &&
1504
+ isSeqOpName(name.text) &&
1505
+ indices.every((index) => index.kind === "numeral")
1506
+ )
1507
+ return mkSeqTerm(
1508
+ name.text,
1509
+ [],
1510
+ indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
1511
+ list.end,
1512
+ );
1513
+ if (
1514
+ isSymbol(name) &&
1515
+ isFpaOpName(name.text) &&
1516
+ indices.every((index) => index.kind === "numeral")
1517
+ ) {
1518
+ const signature = getFpaSignature(
1519
+ manager,
1520
+ FPA_OP_NAMES.get(name.text) ?? -1,
1521
+ indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
1522
+ [],
1523
+ );
1524
+ if (typeof signature === "string")
1525
+ throw new SmtParseError(signature, { line: list.end.line, column: list.end.column + 1 });
1526
+ return mkFpaAppOf(manager, signature, []);
1527
+ }
1528
+ const value = isSymbol(name) ? /^bv([0-9]+)$/.exec(name.text) : null;
1529
+ if (value === null) throw new SmtUnsupportedError("indexed identifiers");
1530
+ const width = list.items[2];
1531
+ if (list.items.length !== 3 || width.kind !== "numeral")
1532
+ throw new SmtParseError("invalid bit-vector constant, index expected", list.end);
1533
+ if (BigInt(width.text) === 0n)
1534
+ throw new SmtParseError("bit-vector size must be greater than zero", list.end);
1535
+ return manager.mkBvNumeral(BigInt(value[1]), Number(width.text));
1536
+ };
1537
+
1538
+ const mkArrayTerm = (op: number, inputArgs: number[], parameters: number[], at: SExpr) => {
1539
+ const signature = getArraySignature(
1540
+ manager,
1541
+ op,
1542
+ inputArgs.map((arg) => manager.sorts[arg]),
1543
+ parameters,
1544
+ );
1545
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1546
+ const args = inputArgs.map((arg, index) => coerce(arg, signature.domain[index]));
1547
+ const decl = manager.mkArrayDecl(
1548
+ op,
1549
+ signature.name,
1550
+ parameters,
1551
+ signature.domain,
1552
+ signature.range,
1553
+ );
1554
+ return manager.mkApp(decl, args, signature.range);
1555
+ };
1556
+
1557
+ const findFuncDecl = (sexpr: SmtToken) => {
1558
+ const decls = funcs.get(sexpr.text);
1559
+ if (decls !== undefined && decls.length > 1)
1560
+ throw new SmtParseError(
1561
+ `ambiguous function declaration reference, provide full signature to disambiguate (<symbol> (<sort>*) <sort>) ${sexpr.text}`,
1562
+ sexpr,
1563
+ );
1564
+ return decls?.[0];
1565
+ };
1566
+
1567
+ const throwAmbiguousConstant = (name: string, at: SExpr) => {
1568
+ throw new SmtParseError(
1569
+ `ambiguous constant reference, more than one constant with the same sort, use a qualified expression (as <symbol> <sort>) to disambiguate ${name}`,
1570
+ at,
1571
+ );
1572
+ };
1573
+
1574
+ // An exact signature wins, else the last one that matches once Int and Real coerce.
1575
+ const mkDeclaredApp = (
1576
+ name: string,
1577
+ decls: readonly number[],
1578
+ args: number[],
1579
+ range: number | undefined,
1580
+ at: SExpr,
1581
+ ) => {
1582
+ if (args.length === 0 && range === undefined) {
1583
+ if (decls.length > 1) throwAmbiguousConstant(name, at);
1584
+ return manager.funcDecls[decls[0]].domain.length > 0
1585
+ ? mkAsArray(manager, decls[0])
1586
+ : mkApp(decls[0], args, at);
1587
+ }
1588
+ const argSorts = args.map((arg) => manager.sorts[arg]);
1589
+ const candidates = decls.filter(
1590
+ (decl) =>
1591
+ (range === undefined || manager.funcDecls[decl].range === range) &&
1592
+ manager.funcDecls[decl].domain.length === args.length &&
1593
+ manager.funcDecls[decl].domain.every(
1594
+ (sort, index) =>
1595
+ sort === argSorts[index] || (isArithSort(sort) && isArithSort(argSorts[index])),
1596
+ ),
1597
+ );
1598
+ const found =
1599
+ candidates.find((decl) =>
1600
+ manager.funcDecls[decl].domain.every((sort, index) => sort === argSorts[index]),
1601
+ ) ?? candidates.at(-1);
1602
+ if (found !== undefined) return mkApp(found, args, at);
1603
+ if (args.length === 0 || range !== undefined) return undefined;
1604
+ if (decls.length > 1) throwAmbiguousConstant(name, at);
1605
+ const array = manager.funcDecls[decls[0]];
1606
+ if (array.domain.length > 0 || !manager.isArraySort(array.range)) return undefined;
1607
+ const parameters = manager.getSortParameters(array.range);
1608
+ if (
1609
+ parameters.length !== args.length + 1 ||
1610
+ argSorts.some((sort, index) => sort !== parameters[index])
1611
+ )
1612
+ return undefined;
1613
+ return mkArrayTerm(OP_SELECT, [mkApp(decls[0], [], at), ...args], [], at);
1614
+ };
1615
+
1616
+ const mkDatatypeInstanceApp = (name: string, args: number[], at: SExpr) => {
1617
+ const argSorts = args.map((arg) => manager.sorts[arg]);
1618
+ for (const def of manager.datatypeDefs.values())
1619
+ for (const [index, constructor] of def.constructors.entries()) {
1620
+ if (constructor.name !== name || constructor.accessors.length !== args.length) continue;
1621
+ const binding: number[] = [];
1622
+ const isMatch = constructor.accessors.every((accessor, position) => {
1623
+ if (accessor.range === argSorts[position]) return true;
1624
+ const parameter = manager.getTypeParameterIndex(accessor.range);
1625
+ if (parameter === -1) return false;
1626
+ if (binding[parameter] !== undefined && binding[parameter] !== argSorts[position])
1627
+ return false;
1628
+ binding[parameter] = argSorts[position];
1629
+ return true;
1630
+ });
1631
+ if (
1632
+ !isMatch ||
1633
+ binding.length !== def.parameters.length ||
1634
+ !def.parameters.every((_parameter, parameter) => binding[parameter] !== undefined)
1635
+ )
1636
+ continue;
1637
+ return mkApp(instantiateConstructor(manager, def, index, binding), args, at);
1638
+ }
1639
+ if (args.length !== 1 || !manager.isDatatypeSort(argSorts[0])) return undefined;
1640
+ for (const def of manager.datatypeDefs.values())
1641
+ for (const [index, constructor] of def.constructors.entries()) {
1642
+ const position = constructor.accessors.findIndex((accessor) => accessor.name === name);
1643
+ if (position === -1) continue;
1644
+ const sort = mkDatatypeSort(manager, def.name, [...manager.getSortParameters(argSorts[0])]);
1645
+ return mkApp(instantiateAccessor(manager, sort, index, position), args, at);
1646
+ }
1647
+ return undefined;
1648
+ };
1649
+
1650
+ const mkIsApp = (constructorName: SmtToken, args: number[], at: SExpr) => {
1651
+ const declared = findFuncDecl(constructorName);
1652
+ if (declared !== undefined) return mkApp(getConstructorIs(manager, declared), args, at);
1653
+ const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
1654
+ if (argSort === -1 || !manager.isDatatypeSort(argSort))
1655
+ throw new SmtUnsupportedError("the operator is");
1656
+ const constructor = getDatatypeConstructors(manager, argSort).find(
1657
+ (decl) => manager.funcDecls[decl].name === constructorName.text,
1658
+ );
1659
+ if (constructor === undefined)
1660
+ throw new SmtParseError(
1661
+ `invalid datatype recognizer, unknown constructor ${constructorName.text}`,
1662
+ at,
1663
+ );
1664
+ return mkApp(getConstructorIs(manager, constructor), args, at);
1665
+ };
1666
+
1667
+ const mkUpdateFieldApp = (accessorName: SmtToken, args: number[], at: SExpr) => {
1668
+ const accessor = findFuncDecl(accessorName);
1669
+ if (accessor === undefined)
1670
+ throw new SmtParseError(
1671
+ `invalid function declaration reference, unknown function ${accessorName.text}`,
1672
+ accessorName,
1673
+ );
1674
+ if (manager.funcDecls[accessor].op !== OP_DT_ACCESSOR)
1675
+ throw new SmtUnsupportedError("the operator update-field");
1676
+ return mkApp(mkUpdateField(manager, accessor), args, at);
1677
+ };
1678
+
1679
+ const getUnknownConstantMessage = (name: string, args: number[], range: number | undefined) => {
1680
+ const argSorts =
1681
+ args.length === 0
1682
+ ? ""
1683
+ : ` (${args.map((arg) => manager.getSortName(manager.sorts[arg])).join(" ")}) `;
1684
+ const declared = (funcs.get(name) ?? []).map((decl) => {
1685
+ const domain = manager.funcDecls[decl].domain.map((sort) => manager.getSortName(sort));
1686
+ return `\ndeclared: (declare-fun ${name} (${domain.join(" ")}) ${manager.getSortName(manager.funcDecls[decl].range)}) `;
1687
+ });
1688
+ return `unknown constant ${name}${argSorts}${range === undefined ? "" : `${manager.getSortName(range)} `}${declared.join("")}`;
1689
+ };
1690
+
1691
+ const parseFuncDeclRef = (sexpr: SExpr): MappedDecl => {
1692
+ if (sexpr.kind === "symbol") {
1693
+ const decl = findFuncDecl(sexpr);
1694
+ if (decl !== undefined) return { decl, ...manager.funcDecls[decl] };
1695
+ const unary = UNARY_BOOL_REFS.get(sexpr.text);
1696
+ if (unary !== undefined) return { decl: unary, domain: [SORT_BOOL], range: SORT_BOOL };
1697
+ const binary = BINARY_BOOL_REFS.get(sexpr.text);
1698
+ if (binary !== undefined)
1699
+ return { decl: binary, domain: [SORT_BOOL, SORT_BOOL], range: SORT_BOOL };
1700
+ throw new SmtUnsupportedError(`the declaration reference ${sexpr.text}`);
1701
+ }
1702
+ const name = sexpr.kind === "list" ? sexpr.items[0] : undefined;
1703
+ const domainList = sexpr.kind === "list" ? sexpr.items[1] : undefined;
1704
+ const rangeSort = sexpr.kind === "list" ? sexpr.items[2] : undefined;
1705
+ if (!isSymbol(name) || domainList?.kind !== "list" || rangeSort === undefined)
1706
+ throw new SmtUnsupportedError("the declaration reference");
1707
+ const domain = domainList.items.map((item) => parseSort(item, "Invalid function name"));
1708
+ const range = parseSort(rangeSort, "Invalid function name");
1709
+ const declared = funcs
1710
+ .get(name.text)
1711
+ ?.find(
1712
+ (decl) =>
1713
+ manager.funcDecls[decl].range === range &&
1714
+ manager.funcDecls[decl].domain.length === domain.length &&
1715
+ manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
1716
+ );
1717
+ if (declared !== undefined) return { decl: declared, domain, range };
1718
+ const builtin = CHAINABLE_OPS.get(name.text) ?? BUILTIN_OPS.get(name.text);
1719
+ if (builtin === undefined)
1720
+ throw new SmtUnsupportedError(`the declaration reference ${name.text}`);
1721
+ return { decl: builtin, domain, range: getBuiltinRange(builtin, domain) };
1722
+ };
1723
+
1724
+ const mkMapTerm = (mapped: MappedDecl, args: number[], at: SExpr) => {
1725
+ const signature = getMapSignature(
1726
+ manager,
1727
+ mapped,
1728
+ args.map((arg) => manager.sorts[arg]),
1729
+ );
1730
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1731
+ const decl = manager.mkArrayDecl(
1732
+ OP_ARRAY_MAP,
1733
+ signature.name,
1734
+ [mapped.decl],
1735
+ signature.domain,
1736
+ signature.range,
1737
+ );
1738
+ return manager.mkApp(decl, args, signature.range);
1739
+ };
1740
+
1741
+ const getArrayOp = (name: string) =>
1742
+ hasArrays
1743
+ ? (ARRAY_OPS.get(name) ?? (hasArrayExtensions ? ARRAY_EXTENSION_OPS.get(name) : undefined))
1744
+ : undefined;
1745
+
1746
+ const parseApp = (
1747
+ head: SmtToken,
1748
+ args: number[],
1749
+ at: SExpr,
1750
+ indices: number[] = [],
1751
+ range?: number,
1752
+ ) => {
1753
+ const name = head.text;
1754
+ // A bound variable applied to arguments selects from the array it stands for, one at a time.
1755
+ if (args.length > 0 && lookup(name) !== undefined)
1756
+ return args.reduce(
1757
+ (array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], at),
1758
+ parseLeaf(head),
1759
+ );
1760
+ if (indices.length > 0)
1761
+ return isFpaOpName(name)
1762
+ ? mkFpaTerm(name, args, indices, at)
1763
+ : isSeqOpName(name)
1764
+ ? mkSeqTerm(name, args, indices, at)
1765
+ : mkBvApp(name, args, indices, at);
1766
+ const macro = macros.get(name);
1767
+ // macros_find: a macro of another arity leaves the name to a declaration.
1768
+ if (macro !== undefined && (macro.domain.length === args.length || !funcs.has(name))) {
1769
+ const coerced = args.map((arg, index) => coerce(arg, macro.domain[index]));
1770
+ if (
1771
+ coerced.length !== macro.domain.length ||
1772
+ coerced.some((arg, index) => manager.sorts[arg] !== macro.domain[index])
1773
+ )
1774
+ throw new SmtParseError(`ill-sorted application of ${name}`, at);
1775
+ return expandMacro(macro, coerced);
1776
+ }
1777
+ const decls = funcs.get(name);
1778
+ const declared = decls === undefined ? undefined : mkDeclaredApp(name, decls, args, range, at);
1779
+ if (declared !== undefined) return declared;
1780
+ if (isSeqOpName(name)) return mkSeqTerm(name, args, indices, at, range);
1781
+ if (range !== undefined)
1782
+ throw new SmtParseError(getUnknownConstantMessage(name, args, range), at);
1783
+ if (isBvOpName(name)) return mkBvApp(name, args, indices, at);
1784
+ if (isFpaOpName(name)) return mkFpaTerm(name, args, indices, at);
1785
+ const arrayOp = getArrayOp(name);
1786
+ if (arrayOp !== undefined) return mkArrayTerm(arrayOp, args, [], at);
1787
+ const builtin = (logic === undefined ? LOGIC_FREE_ALIASES.get(name) : undefined) ?? name;
1788
+ const isTranscendental = TRANSCENDENTALS.has(builtin) && hasTranscendentals(logic);
1789
+ if (isTranscendental && args.length === 0 && builtin === "pi") return manager.piExpr;
1790
+ if (isTranscendental && args.length === 0 && builtin === "euler") return manager.eulerExpr;
1791
+ const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
1792
+ if (isTranscendental && transcendentalOp === undefined)
1793
+ throw new SmtUnsupportedError(`the operator ${name}`);
1794
+ const chainable = CHAINABLE_OPS.get(builtin);
1795
+ const arithOp =
1796
+ chainable ?? (builtin === "~" ? OP_UMINUS : (BUILTIN_OPS.get(builtin) ?? transcendentalOp));
1797
+ if (
1798
+ args.length === 0 &&
1799
+ arithOp !== undefined &&
1800
+ manager.funcDecls[arithOp].family === FAMILY_ARITH
1801
+ )
1802
+ throw new SmtParseError("no arguments supplied to arithmetical operator", head);
1803
+ if (chainable === OP_EQ && args.length < 2)
1804
+ throw new SmtParseError(
1805
+ getUnknownConstantMessage(name, args, undefined),
1806
+ args.length === 0 ? head : at,
1807
+ );
1808
+ if (chainable !== undefined) return mkChain(chainable, args, at);
1809
+ if (builtin === "~") return mkApp(OP_UMINUS, args, at);
1810
+ if (builtin === "-" && args.length === 1) return mkApp(OP_UMINUS, args, at);
1811
+ const op = BUILTIN_OPS.get(builtin) ?? transcendentalOp;
1812
+ if (op === undefined) {
1813
+ if (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name))
1814
+ throw new SmtUnsupportedError(`the operator ${name}`);
1815
+ const instance = mkDatatypeInstanceApp(name, args, at);
1816
+ if (instance !== undefined) return instance;
1817
+ throw new SmtParseError(
1818
+ getUnknownConstantMessage(name, args, undefined),
1819
+ args.length === 0 ? head : at,
1820
+ );
1821
+ }
1822
+ // xor is associative, so ast_manager::mk_app takes fewer than two arguments, which
1823
+ // bool_rewriter reduces to false or the argument.
1824
+ if (op === OP_XOR && args.length < 2) {
1825
+ if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
1826
+ throw new SmtParseError(`ill-sorted application of ${name}`, at);
1827
+ return args[0] ?? manager.falseExpr;
1828
+ }
1829
+ if (args.length <= 2 || !NESTED_OPS.has(op)) return mkApp(op, args, at);
1830
+ const domainSort = getDomainSort(op, args);
1831
+ return op === OP_XOR || op === OP_IMPLIES
1832
+ ? args
1833
+ .slice(0, -1)
1834
+ .reduceRight(
1835
+ (right, left) => mkApp(op, [left, right], at, domainSort),
1836
+ args[args.length - 1],
1837
+ )
1838
+ : args.slice(1).reduce((left, right) => mkApp(op, [left, right], at, domainSort), args[0]);
1839
+ };
1840
+
1841
+ const parseLeaf = (sexpr: SExpr): number => {
1842
+ if (sexpr.kind === "numeral")
1843
+ return isNumeralAsReal
1844
+ ? manager.mkRealNumeral(Rational.of(BigInt(sexpr.text), 1n))
1845
+ : manager.mkNumeral(BigInt(sexpr.text));
1846
+ if (sexpr.kind === "decimal") {
1847
+ const parts = sexpr.text.split(".");
1848
+ return manager.mkRealNumeral(
1849
+ Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length)),
1850
+ );
1851
+ }
1852
+ if (sexpr.kind === "bitvector") {
1853
+ const isBinary = sexpr.text[1] === "b";
1854
+ const digits = sexpr.text.slice(2);
1855
+ return manager.mkBvNumeral(
1856
+ BigInt(`0${isBinary ? "b" : "x"}${digits}`),
1857
+ digits.length * (isBinary ? 1 : 4),
1858
+ );
1859
+ }
1860
+ if (sexpr.kind === "string") return manager.mkString(parseZstring(sexpr.text, manager.maxChar));
1861
+ if (sexpr.kind === "symbol") {
1862
+ if (sexpr.text === "true") return manager.trueExpr;
1863
+ if (sexpr.text === "false") return manager.falseExpr;
1864
+ const binding = lookup(sexpr.text);
1865
+ if (binding?.kind === "var")
1866
+ return manager.mkVar(binders.depth - 1 - binding.depth, binding.sort);
440
1867
  // Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
441
1868
  // holds the terms it makes, but this parser holds no references, so it rebuilds the binding
442
1869
  // with replaceFreeVars.
443
1870
  if (binding !== undefined)
444
- return depth === binding.depth
1871
+ return binders.depth === binding.depth
445
1872
  ? binding.expr
446
1873
  : replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
447
- manager.mkVar(index + shift + depth - binding.depth, manager.sorts[variable]),
1874
+ manager.mkVar(index + shift + binders.depth - binding.depth, manager.sorts[variable]),
448
1875
  );
449
- return parseApp(sexpr, []);
450
- }
451
- const head = sexpr[0];
452
- if (head === "forall" || head === "exists") return parseQuantifier(sexpr, head === "forall");
453
- if (head === "let") return parseLet(sexpr);
454
- const named = parseTerm(sexpr[1]);
455
- // name_expr: cmd_context keeps a named expression as a macro.
456
- const nameIndex = sexpr.indexOf(":named");
457
- if (nameIndex !== -1) {
458
- manager.incRef(named);
459
- manager.mkMacro(expectSymbol(sexpr[nameIndex + 1]), named);
1876
+ return parseApp(sexpr, [], sexpr);
460
1877
  }
461
- return named;
1878
+ if (sexpr.kind !== "list") throw new SmtParseError("invalid expression", sexpr);
1879
+ const head = sexpr.items[0];
1880
+ if (isSymbol(head, "forall") || isSymbol(head, "exists") || isSymbol(head, "lambda"))
1881
+ return parseQuantifier(
1882
+ sexpr,
1883
+ head.text === "forall"
1884
+ ? QUANTIFIER_FORALL
1885
+ : head.text === "exists"
1886
+ ? QUANTIFIER_EXISTS
1887
+ : QUANTIFIER_LAMBDA,
1888
+ );
1889
+ if (isSymbol(head, "let")) return parseLet(sexpr);
1890
+ // Each attribute applies to the expression the attributes before it made.
1891
+ return sexpr.items.slice(2).reduce(
1892
+ (annotated, keyword, index, attributes) => {
1893
+ if (keyword.kind !== "keyword") return annotated;
1894
+ const value = attributes[index + 1];
1895
+ if (keyword.text === ":lblpos" || keyword.text === ":lblneg")
1896
+ return mkLabel(annotated, keyword.text === ":lblpos", value, sexpr);
1897
+ if (keyword.text !== ":named") return annotated;
1898
+ const name = expectSymbol(value, "invalid attribute value, symbol expected", sexpr).text;
1899
+ manager.incRef(annotated);
1900
+ lastNamed.name = name;
1901
+ lastNamed.expr = annotated;
1902
+ manager.mkMacro(name, annotated);
1903
+ declare(macros, name, { domain: [], range: manager.sorts[annotated], body: annotated });
1904
+ return annotated;
1905
+ },
1906
+ parseTerm(sexpr.items[1] ?? sexpr.end),
1907
+ );
1908
+ };
1909
+
1910
+ const mkLabel = (expr: number, isPositive: boolean, value: SExpr | undefined, at: SExpr) => {
1911
+ const name = expectSymbol(value, "invalid attribute value, symbol expected", at).text;
1912
+ if (manager.sorts[expr] !== SORT_BOOL)
1913
+ throw new SmtParseError("invalid labeled expression, expression must have Bool sort", at);
1914
+ return manager.mkLabel(isPositive, [name], expr);
462
1915
  };
463
1916
 
464
- // Applications keep their own stack, like Z3's parser, so deeply nested terms do not exhaust the
465
- // call stack.
466
1917
  const parseTerm = (sexpr: SExpr): number => {
467
1918
  const frames: ApplicationFrame[] = [];
468
1919
  const results: number[] = [];
469
1920
  const enter = (current: SExpr) => {
470
- const head = Array.isArray(current) ? current[0] : undefined;
471
- if (
472
- !Array.isArray(current) ||
473
- head === "forall" ||
474
- head === "exists" ||
475
- head === "let" ||
476
- head === "!"
477
- )
1921
+ if (current.kind !== "list") {
478
1922
  results.push(parseLeaf(current));
479
- else frames.push({ name: expectSymbol(head), list: current, start: results.length, next: 1 });
1923
+ return;
1924
+ }
1925
+ const head = current.items[0];
1926
+ if (head === undefined)
1927
+ throw new SmtParseError("invalid expression, unexpected ')'", current.end);
1928
+ if (head.kind === "list") {
1929
+ const name = head.items[1];
1930
+ const indices = head.items.slice(2);
1931
+ if (
1932
+ hasArrays &&
1933
+ isSymbol(head.items[0], "as") &&
1934
+ isSymbol(name, "const") &&
1935
+ head.items.length === 3
1936
+ ) {
1937
+ const sort = parseSort(head.items[2], "");
1938
+ frames.push({
1939
+ head: name,
1940
+ indices: [],
1941
+ build: (args) => mkArrayTerm(OP_CONST_ARRAY, args, [sort], current.end),
1942
+ list: current,
1943
+ start: results.length,
1944
+ next: 1,
1945
+ });
1946
+ return;
1947
+ }
1948
+ if (
1949
+ hasArrays &&
1950
+ hasArrayExtensions &&
1951
+ isSymbol(head.items[0], "_") &&
1952
+ isSymbol(name, "map") &&
1953
+ head.items.length === 3
1954
+ ) {
1955
+ const mapped = parseFuncDeclRef(head.items[2]);
1956
+ frames.push({
1957
+ head: name,
1958
+ indices: [],
1959
+ build: (args) => mkMapTerm(mapped, args, current.end),
1960
+ list: current,
1961
+ start: results.length,
1962
+ next: 1,
1963
+ });
1964
+ return;
1965
+ }
1966
+ const indexed = head.items[2];
1967
+ if (
1968
+ isSymbol(head.items[0], "_") &&
1969
+ (isSymbol(name, "is") || isSymbol(name, "update-field")) &&
1970
+ isSymbol(indexed) &&
1971
+ head.items.length === 3
1972
+ ) {
1973
+ frames.push({
1974
+ head: name,
1975
+ indices: [],
1976
+ build: (args) =>
1977
+ name.text === "is"
1978
+ ? mkIsApp(indexed, args, current.end)
1979
+ : mkUpdateFieldApp(indexed, args, current.end),
1980
+ list: current,
1981
+ start: results.length,
1982
+ next: 1,
1983
+ });
1984
+ return;
1985
+ }
1986
+ if (isSymbol(head.items[0], "as") && isSymbol(name) && head.items.length === 3) {
1987
+ const range = parseSort(head.items[2], "Invalid qualified identifier");
1988
+ frames.push({
1989
+ head: name,
1990
+ indices: [],
1991
+ build: (args) => parseApp(name, args, current.end, [], range),
1992
+ list: current,
1993
+ start: results.length,
1994
+ next: 1,
1995
+ });
1996
+ return;
1997
+ }
1998
+ if (
1999
+ isSymbol(head.items[0], "_") &&
2000
+ isSymbol(name) &&
2001
+ isPbOpName(name.text) &&
2002
+ indices.every((index) => index.kind === "numeral")
2003
+ ) {
2004
+ const parameters = indices.map((index) =>
2005
+ Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
2006
+ );
2007
+ frames.push({
2008
+ head: name,
2009
+ indices: [],
2010
+ build: (args) => mkPbTerm(name.text, args, parameters, current.end),
2011
+ list: current,
2012
+ start: results.length,
2013
+ next: 1,
2014
+ });
2015
+ return;
2016
+ }
2017
+ if (
2018
+ !isSymbol(head.items[0], "_") ||
2019
+ !isSymbol(name) ||
2020
+ !(isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)) ||
2021
+ !indices.every((index) => index.kind === "numeral")
2022
+ )
2023
+ throw new SmtUnsupportedError("indexed and qualified identifiers");
2024
+ frames.push({
2025
+ head: name,
2026
+ indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
2027
+ list: current,
2028
+ start: results.length,
2029
+ next: 1,
2030
+ });
2031
+ return;
2032
+ }
2033
+ if (head.kind !== "symbol")
2034
+ throw new SmtParseError("invalid function application, symbol expected", head);
2035
+ if (head.text === "_") {
2036
+ results.push(parseBvNumeral(current));
2037
+ return;
2038
+ }
2039
+ const qualified = current.items[1];
2040
+ if (head.text === "as" && isSymbol(qualified) && current.items.length === 3) {
2041
+ results.push(
2042
+ parseApp(
2043
+ qualified,
2044
+ [],
2045
+ qualified,
2046
+ [],
2047
+ parseSort(current.items[2], "Invalid qualified identifier"),
2048
+ ),
2049
+ );
2050
+ return;
2051
+ }
2052
+ if (head.text === "root-obj") {
2053
+ results.push(parseRootObj(current));
2054
+ return;
2055
+ }
2056
+ if (head.text === "as" || head.text === "match")
2057
+ throw new SmtUnsupportedError(`the expression ${head.text}`);
2058
+ if (["forall", "exists", "lambda", "let", "!"].includes(head.text))
2059
+ results.push(parseLeaf(current));
2060
+ else frames.push({ head, indices: [], list: current, start: results.length, next: 1 });
480
2061
  };
481
2062
  enter(sexpr);
482
2063
  while (frames.length > 0) {
483
2064
  const frame = frames[frames.length - 1];
484
- if (frame.next < frame.list.length) {
485
- enter(frame.list[frame.next++]);
2065
+ if (frame.next < frame.list.items.length) {
2066
+ enter(frame.list.items[frame.next++]);
486
2067
  continue;
487
2068
  }
488
2069
  frames.pop();
489
- results.push(parseApp(frame.name, results.splice(frame.start)));
2070
+ if (frame.list.items.length === 1)
2071
+ throw new SmtParseError("invalid function application, arguments missing", frame.list.end);
2072
+ const args = results.splice(frame.start);
2073
+ results.push(
2074
+ frame.build?.(args) ?? parseApp(frame.head, args, frame.list.end, frame.indices),
2075
+ );
490
2076
  }
491
2077
  return results[0];
492
2078
  };
493
2079
 
494
- let hasCheckSat = false;
495
- for (const command of readSExprs(tokenize(text))) {
496
- const list = expectList(command);
497
- const name = expectSymbol(list[0]);
498
- if (name === "declare-sort") {
499
- if (list[2] !== undefined && list[2] !== "0")
500
- throw new SmtUnsupportedError("parametric sorts are not supported");
501
- sorts.set(expectSymbol(list[1]), manager.mkSort(expectSymbol(list[1])));
502
- } else if (name === "declare-fun" || name === "declare-const") {
503
- const domain = name === "declare-fun" ? expectList(list[2]).map(parseSort) : [];
504
- const range = parseSort(name === "declare-fun" ? list[3] : list[2]);
505
- // builtin_signature_collides and is_transcendental_shadow_decl each apply the builtin of that
506
- // name to fresh variables, which they then release.
507
- for (let round = 0; round < 2; round++) {
508
- const vars = domain.map((sort, index) => manager.mkVar(index, sort));
509
- for (const domainVar of vars) manager.incRef(domainVar);
510
- for (const domainVar of vars) manager.decRef(domainVar);
2080
+ const parseDomain = (sexpr: SExpr | undefined, at: SExpr) => {
2081
+ const context = "Parsing function declaration. Expecting sort list '('";
2082
+ return expectList(sexpr, context, at).items.map((item) => parseSort(item, context));
2083
+ };
2084
+
2085
+ const parseSortParameters = (sexpr: SExpr | undefined, message: string, at: SExpr) =>
2086
+ expectList(sexpr, "invalid sort declaration, parameters missing", at).items.map(
2087
+ (item) => expectSymbol(item, message, item).text,
2088
+ );
2089
+
2090
+ const bindTypeParameters = (names: string[]) =>
2091
+ new Map(names.map((name, index) => [name, manager.mkTypeParameter(index)]));
2092
+
2093
+ const parseAccessorSort = (
2094
+ sexpr: SExpr,
2095
+ bindings: ReadonlyMap<string, number>,
2096
+ datatypeIndexes: ReadonlyMap<string, number>,
2097
+ missing: string[],
2098
+ ) => {
2099
+ if (sexpr.kind === "list") return parseSort(sexpr, "", bindings);
2100
+ if (sexpr.kind !== "symbol")
2101
+ throw new SmtParseError("invalid sort, symbol, '_' or '(' expected", sexpr);
2102
+ if (sortDecls.has(sexpr.text) || bindings.has(sexpr.text))
2103
+ return parseSort(sexpr, "", bindings);
2104
+ const index = datatypeIndexes.get(sexpr.text);
2105
+ if (index !== undefined) return -1 - index;
2106
+ missing.push(sexpr.text);
2107
+ return SORT_BOOL;
2108
+ };
2109
+
2110
+ const parseConstructors = (
2111
+ items: SExpr[],
2112
+ bindings: ReadonlyMap<string, number>,
2113
+ datatypeIndexes: ReadonlyMap<string, number>,
2114
+ missing: string[],
2115
+ at: SExpr,
2116
+ ): ConstructorDef[] => {
2117
+ if (items.length === 0)
2118
+ throw new SmtParseError(
2119
+ "invalid datatype declaration, datatype does not have any constructors",
2120
+ at,
2121
+ );
2122
+ return items.map((item) => {
2123
+ if (isSymbol(item)) return { name: item.text, recognizer: `is-${item.text}`, accessors: [] };
2124
+ const constructor = expectList(
2125
+ item,
2126
+ "invalid datatype declaration, '(' or ')' expected",
2127
+ item,
2128
+ );
2129
+ const name = expectSymbol(
2130
+ constructor.items[0],
2131
+ "invalid constructor declaration, symbol (constructor name) expected",
2132
+ constructor,
2133
+ ).text;
2134
+ const accessors = constructor.items.slice(1).map((accessorItem) => {
2135
+ const accessor = expectList(
2136
+ accessorItem,
2137
+ "invalid datatype declaration, '(' or ')' expected",
2138
+ accessorItem,
2139
+ );
2140
+ const accessorName = expectSymbol(
2141
+ accessor.items[0],
2142
+ "invalid accessor declaration, symbol (accessor name) expected",
2143
+ accessor,
2144
+ ).text;
2145
+ const range = parseAccessorSort(
2146
+ accessor.items[1] ?? accessor.end,
2147
+ bindings,
2148
+ datatypeIndexes,
2149
+ missing,
2150
+ );
2151
+ if (accessor.items.length > 2)
2152
+ throw new SmtParseError("invalid accessor declaration, ')' expected", accessor.items[2]);
2153
+ return { name: accessorName, range };
2154
+ });
2155
+ return { name, recognizer: `is-${name}`, accessors };
2156
+ });
2157
+ };
2158
+
2159
+ const parseDatatypeBody = (
2160
+ sexpr: SExpr | undefined,
2161
+ datatypeIndexes: ReadonlyMap<string, number>,
2162
+ missing: string[],
2163
+ at: SExpr,
2164
+ ) => {
2165
+ const body = expectList(sexpr, "invalid datatype declaration, '(' expected", at);
2166
+ if (!isSymbol(body.items[0], "par"))
2167
+ return {
2168
+ parameters: [],
2169
+ constructors: parseConstructors(body.items, NO_BINDINGS, datatypeIndexes, missing, body),
2170
+ };
2171
+ const parameters = parseSortParameters(
2172
+ body.items[1],
2173
+ "invalid sort parameter, symbol or ')' expected",
2174
+ body,
2175
+ );
2176
+ const constructors = expectList(
2177
+ body.items[2],
2178
+ "invalid constructor declaration after par, '(' expected",
2179
+ body,
2180
+ );
2181
+ return {
2182
+ parameters: parameters.map((_name, index) => manager.mkTypeParameter(index)),
2183
+ constructors: parseConstructors(
2184
+ constructors.items,
2185
+ bindTypeParameters(parameters),
2186
+ datatypeIndexes,
2187
+ missing,
2188
+ constructors,
2189
+ ),
2190
+ };
2191
+ };
2192
+
2193
+ const commitDatatypes = (defs: DatatypeDef[], missing: string[], at: SExpr, end: SExpr) => {
2194
+ if (missing.length > 0)
2195
+ throw new SmtParseError(`invalid datatype declaration, unknown sort '${missing[0]}'`, at);
2196
+ const sorts = mkDatatypes(manager, defs);
2197
+ if (typeof sorts === "string") throw new SmtParseError(sorts, end);
2198
+ for (const def of defs) undo.push(() => removeDatatype(manager, def.name));
2199
+ defs.forEach((def, index) => {
2200
+ if (def.parameters.length === 0) insertDatatypeDecls(sorts[index], end);
2201
+ });
2202
+ for (const def of defs) {
2203
+ const names = def.constructors.flatMap((constructor) =>
2204
+ constructor.accessors.map((accessor) => accessor.name),
2205
+ );
2206
+ const duplicated = names.find((name, index) => names.indexOf(name) !== index);
2207
+ if (duplicated !== undefined)
2208
+ throw new SmtParseError(
2209
+ `invalid datatype declaration, repeated accessor identifier '${duplicated}'`,
2210
+ at,
2211
+ );
2212
+ }
2213
+ };
2214
+
2215
+ const declareSortDecl = (name: string, decl: SortDecl, at: SExpr) => {
2216
+ if (sortDecls.has(name)) throw new SmtParseError(`sort already defined ${name}`, at);
2217
+ declare(sortDecls, name, decl);
2218
+ };
2219
+
2220
+ const declareDatatypes = (list: SmtList) => {
2221
+ const declaration = expectList(
2222
+ list.items[1],
2223
+ "invalid sort declaration, parameters missing",
2224
+ list,
2225
+ );
2226
+ const isSmt26 = declaration.items[0]?.kind === "list";
2227
+ const datatypeIndexes = new Map<string, number>();
2228
+ const names: string[] = [];
2229
+ const arities: number[] = [];
2230
+ const parameterNames: string[] = [];
2231
+ declaration.items.forEach((item, index) => {
2232
+ if (!isSmt26) {
2233
+ parameterNames.push(
2234
+ expectSymbol(item, "invalid sort parameter, symbol or ')' expected", item).text,
2235
+ );
2236
+ return;
2237
+ }
2238
+ const sortDeclaration = expectList(item, "invalid sort declaration, '(' expected", item);
2239
+ const name = expectSymbol(
2240
+ sortDeclaration.items[0],
2241
+ "invalid sort name, identified expected",
2242
+ sortDeclaration,
2243
+ ).text;
2244
+ const arity = sortDeclaration.items[1];
2245
+ if (arity?.kind !== "numeral")
2246
+ throw new SmtParseError(
2247
+ "invalid sort declaration, arity expected",
2248
+ arity ?? sortDeclaration.end,
2249
+ );
2250
+ if (sortDeclaration.items.length > 2)
2251
+ throw new SmtParseError("invalid sort declaration, ')' expected", sortDeclaration.items[2]);
2252
+ datatypeIndexes.set(name, index);
2253
+ names.push(name);
2254
+ arities.push(Number(arity.text));
2255
+ declareSortDecl(
2256
+ name,
2257
+ { kind: "datatype", name, arity: Number(arity.text), siblings: [], instances: new Map() },
2258
+ sortDeclaration,
2259
+ );
2260
+ });
2261
+ const bodies = expectList(list.items[2], "invalid datatype declaration, '(' expected", list);
2262
+ // A datatype of the older syntax may refer to any datatype of its declaration.
2263
+ if (!isSmt26)
2264
+ bodies.items.forEach((item, index) => {
2265
+ const datatype = expectList(
2266
+ item,
2267
+ "invalid datatype declaration, '(' or ')' expected",
2268
+ item,
2269
+ );
2270
+ const name = expectSymbol(
2271
+ datatype.items[0],
2272
+ "invalid datatype declaration, symbol (datatype name) expected",
2273
+ datatype,
2274
+ ).text;
2275
+ datatypeIndexes.set(name, index);
2276
+ names.push(name);
2277
+ });
2278
+ const missing: string[] = [];
2279
+ const typeParameters = parameterNames.map((_name, index) => manager.mkTypeParameter(index));
2280
+ const bindings = bindTypeParameters(parameterNames);
2281
+ const defs = bodies.items.map((item, index) => {
2282
+ if (isSmt26) {
2283
+ if (index >= names.length)
2284
+ throw new SmtParseError(
2285
+ "invalid datatype declaration, too many data-type bodies defined",
2286
+ item,
2287
+ );
2288
+ return mkDatatypeDef(
2289
+ manager,
2290
+ names[index],
2291
+ Array.from({ length: arities[index] }, (_unused, parameter) =>
2292
+ manager.mkTypeParameter(parameter),
2293
+ ),
2294
+ parseDatatypeBody(item, datatypeIndexes, missing, list).constructors,
2295
+ );
511
2296
  }
512
- funcs.set(expectSymbol(list[1]), manager.mkFuncDecl(expectSymbol(list[1]), domain, range));
2297
+ const datatype = expectList(item, "invalid datatype declaration, '(' or ')' expected", item);
2298
+ return mkDatatypeDef(
2299
+ manager,
2300
+ names[index],
2301
+ typeParameters,
2302
+ parseConstructors(datatype.items.slice(1), bindings, datatypeIndexes, missing, datatype),
2303
+ );
2304
+ });
2305
+ if (defs.length < arities.length)
2306
+ throw new SmtParseError(
2307
+ "invalid datatype declaration, too few datatype definitions compared to declared sorts",
2308
+ bodies.end,
2309
+ );
2310
+ if (list.items.length > 3)
2311
+ throw new SmtParseError("invalid datatype declaration", list.items[3]);
2312
+ if (defs.length === 0) return;
2313
+ commitDatatypes(defs, missing, declaration, list.end);
2314
+ if (isSmt26) return;
2315
+ for (const def of defs)
2316
+ declareSortDecl(
2317
+ def.name,
2318
+ {
2319
+ kind: "datatype",
2320
+ name: def.name,
2321
+ arity: def.parameters.length,
2322
+ siblings: defs.length > 1 ? names : [],
2323
+ instances: new Map(),
2324
+ },
2325
+ list.end,
2326
+ );
2327
+ };
2328
+
2329
+ const declareDatatype = (list: SmtList) => {
2330
+ const name = expectSymbol(list.items[1], "unexpected token used as datatype name", list);
2331
+ const missing: string[] = [];
2332
+ const bodyList = list.items[2];
2333
+ const arity =
2334
+ bodyList?.kind === "list" &&
2335
+ isSymbol(bodyList.items[0], "par") &&
2336
+ bodyList.items[1]?.kind === "list"
2337
+ ? bodyList.items[1].items.length
2338
+ : 0;
2339
+ declareSortDecl(
2340
+ name.text,
2341
+ { kind: "datatype", name: name.text, arity, siblings: [], instances: new Map() },
2342
+ name,
2343
+ );
2344
+ const body = parseDatatypeBody(bodyList, new Map([[name.text, 0]]), missing, list);
2345
+ if (list.items.length > 3)
2346
+ throw new SmtParseError("invalid end of datatype declaration, ')' expected", list.items[3]);
2347
+ commitDatatypes(
2348
+ [mkDatatypeDef(manager, name.text, body.parameters, body.constructors)],
2349
+ missing,
2350
+ name,
2351
+ list.end,
2352
+ );
2353
+ };
2354
+
2355
+ // parse_rec_fun_decl: the variables are bound only while the range is parsed.
2356
+ const declareRecFun = (items: SExpr[], at: SExpr) => {
2357
+ const symbol = expectSymbol(
2358
+ items[0],
2359
+ "invalid function/constant definition, symbol expected",
2360
+ at,
2361
+ );
2362
+ const bound = bindSortedVars(items[1], at);
2363
+ const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
2364
+ unbindSortedVars(bound.varSorts.length);
2365
+ return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
2366
+ };
2367
+
2368
+ // parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
2369
+ const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
2370
+ const bound = bindSortedVars(variables, body);
2371
+ const parsed = parseTerm(body);
2372
+ unbindSortedVars(bound.varSorts.length);
2373
+ const range = manager.funcDecls[decl].range;
2374
+ if (manager.sorts[parsed] !== range)
2375
+ throw new SmtParseError(
2376
+ `invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[parsed])}`,
2377
+ next,
2378
+ );
2379
+ setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsed);
2380
+ };
2381
+
2382
+ // parse_define and insert_macro: Z3 declares a macro as a recursive function with one case, which
2383
+ // a reference without arguments takes as an array. The reference that the body with its variables
2384
+ // reversed keeps stands for Z3's macro_decls, and those of the variables for the definition's.
2385
+ const defineMacroFunc = (name: string, domain: number[], body: number) => {
2386
+ const count = domain.length;
2387
+ if (count > 1) {
2388
+ const subst = new VarSubst(manager, true);
2389
+ subst.apply(
2390
+ body,
2391
+ domain.map((sort, index) => manager.mkVar(index, sort)),
2392
+ );
2393
+ subst.release();
2394
+ }
2395
+ for (const [index, sort] of domain.entries()) manager.incRef(manager.mkVar(index, sort));
2396
+ const reversedVars = domain.map((_, index) => manager.mkVar(index, domain[count - index - 1]));
2397
+ for (const reversedVar of reversedVars) manager.incRef(reversedVar);
2398
+ const decl = manager.mkRecFuncDecl(name, domain, manager.sorts[body]);
2399
+ for (const reversedVar of reversedVars) manager.decRef(reversedVar);
2400
+ setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, true, body);
2401
+ declare(funcs, name, [...(funcs.get(name) ?? []), decl]);
2402
+ };
2403
+
2404
+ const declareCommand = (list: SmtList) => {
2405
+ const name = list.items[0].kind === "list" ? "" : list.items[0].text;
2406
+ if (name === "define-fun-rec") {
2407
+ const decl = declareRecFun(list.items.slice(1), list.end);
2408
+ insertFunc(decl, list.items[4] ?? list.end);
2409
+ defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
2410
+ return;
2411
+ }
2412
+ if (name === "define-funs-rec") {
2413
+ const message = "invalid recursive function definition, '(' expected";
2414
+ const signatures = expectList(list.items[1], message, list.end).items.map((signature) => {
2415
+ const declaration = expectList(signature, message, signature);
2416
+ const items = declaration.items;
2417
+ if (items.length > 3)
2418
+ throw new SmtParseError("invalid recursive function definition, ')' expected", items[3]);
2419
+ return { items, decl: declareRecFun(items, declaration.end) };
2420
+ });
2421
+ for (const signature of signatures) insertFunc(signature.decl, list.items[2] ?? list.end);
2422
+ const bodies = expectList(list.items[2], message, list.end);
2423
+ signatures.forEach((signature, index) => {
2424
+ const body = bodies.items[index];
2425
+ if (body === undefined)
2426
+ throw new SmtParseError(
2427
+ "the number of declarations does not match number of supplied definitions",
2428
+ bodies.end,
2429
+ );
2430
+ defineRecFun(
2431
+ signature.decl,
2432
+ signature.items[1],
2433
+ body,
2434
+ bodies.items[index + 1] ?? bodies.end,
2435
+ );
2436
+ });
2437
+ const extra = bodies.items[signatures.length];
2438
+ if (extra !== undefined)
2439
+ throw new SmtParseError("invalid recursive function definition, ')' expected", extra);
2440
+ return;
2441
+ }
2442
+ if (name === "declare-datatypes") {
2443
+ declareDatatypes(list);
2444
+ return;
2445
+ }
2446
+ if (name === "declare-datatype") {
2447
+ declareDatatype(list);
2448
+ return;
2449
+ }
2450
+ const symbol = expectSymbol(list.items[1], "invalid declaration, symbol expected", list);
2451
+ if (name === "declare-sort") {
2452
+ if (sortDecls.has(symbol.text))
2453
+ throw new SmtParseError("invalid sort declaration, sort already declared/defined", symbol);
2454
+ const arity = list.items[2];
2455
+ if (arity !== undefined && arity.kind !== "numeral")
2456
+ throw new SmtParseError(
2457
+ "invalid sort declaration, arity (<numeral>) or ')' expected",
2458
+ arity,
2459
+ );
2460
+ if (list.items.length > 3)
2461
+ throw new SmtParseError("invalid sort declaration, ')' expected", list.items[3]);
2462
+ declare(
2463
+ sortDecls,
2464
+ symbol.text,
2465
+ arity === undefined || arity.text === "0"
2466
+ ? { kind: "sort", sort: manager.mkSort(symbol.text) }
2467
+ : { kind: "user", name: symbol.text, arity: Number(arity.text) },
2468
+ );
2469
+ return;
2470
+ }
2471
+ if (name === "define-sort") {
2472
+ if (sortDecls.has(symbol.text))
2473
+ throw new SmtParseError("invalid sort definition, sort already declared/defined", symbol);
2474
+ const parameters = parseSortParameters(
2475
+ list.items[2],
2476
+ "invalid sort parameter, symbol or ')' expected",
2477
+ list,
2478
+ );
2479
+ const body = list.items[3] ?? list.end;
2480
+ checkPsort(body, bindTypeParameters(parameters));
2481
+ declare(sortDecls, symbol.text, { kind: "definition", parameters, body });
2482
+ return;
2483
+ }
2484
+ if (name === "define-fun" || name === "define-const") {
2485
+ const isConst = name === "define-const";
2486
+ const bound = isConst ? { names: [], varSorts: [] } : bindSortedVars(list.items[2], list);
2487
+ const range = parseSort(
2488
+ list.items[isConst ? 2 : 3] ?? list.end,
2489
+ isConst ? "Invalid constant definition" : "Invalid function definition",
2490
+ );
2491
+ const body = parseTerm(list.items[isConst ? 3 : 4] ?? list.end);
2492
+ if (!isConst) unbindSortedVars(bound.varSorts.length);
2493
+ const coerced = coerce(body, range);
2494
+ if (manager.sorts[coerced] !== range)
2495
+ throw new SmtParseError(
2496
+ isConst
2497
+ ? "invalid constant definition, sort mismatch"
2498
+ : "invalid function/constant definition, sort mismatch",
2499
+ list.end,
2500
+ );
2501
+ manager.incRef(coerced);
2502
+ declare(macros, symbol.text, { domain: bound.varSorts, range, body: coerced });
2503
+ defineMacroFunc(symbol.text, bound.varSorts, coerced);
2504
+ return;
2505
+ }
2506
+ const domain = name === "declare-fun" ? parseDomain(list.items[2], list) : [];
2507
+ const range = parseSort(
2508
+ list.items[name === "declare-fun" ? 3 : 2] ?? list.end,
2509
+ name === "declare-fun" ? "Invalid function declaration" : "Invalid constant declaration",
2510
+ );
2511
+ // Z3's builtin_signature_collides and is_transcendental_shadow_decl each make and release fresh variables of the domain.
2512
+ for (let round = 0; round < 2; round++) {
2513
+ const vars = domain.map((sort, index) => manager.mkVar(index, sort));
2514
+ for (const domainVar of vars) manager.incRef(domainVar);
2515
+ for (const domainVar of vars) manager.decRef(domainVar);
2516
+ }
2517
+ const decl = manager.mkFuncDecl(symbol.text, domain, range);
2518
+ checkDecl(decl, list.end);
2519
+ if (macros.has(symbol.text))
2520
+ throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
2521
+ const existing = funcs.get(symbol.text) ?? [];
2522
+ if (
2523
+ existing.some(
2524
+ (decl) =>
2525
+ manager.funcDecls[decl].range === range &&
2526
+ manager.funcDecls[decl].domain.length === domain.length &&
2527
+ manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
2528
+ )
2529
+ )
2530
+ throw new SmtParseError(
2531
+ `invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
2532
+ list.end,
2533
+ );
2534
+ declare(funcs, symbol.text, [...existing, decl]);
2535
+ };
2536
+
2537
+ const parseFormula = (sexpr: SExpr) => {
2538
+ const assertion = parseTerm(sexpr);
2539
+ if (manager.sorts[assertion] !== SORT_BOOL)
2540
+ throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
2541
+ manager.incRef(assertion);
2542
+ return assertion;
2543
+ };
2544
+
2545
+ // An assertion is named when the last name of its term is its own.
2546
+ const parseAssertion = (sexpr: SExpr) => {
2547
+ lastNamed.expr = -1;
2548
+ const formula = parseFormula(sexpr);
2549
+ return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
2550
+ };
2551
+
2552
+ const push = () => scopeStarts.push(undo.length);
2553
+
2554
+ const pop = () => {
2555
+ const start = scopeStarts.pop() ?? 0;
2556
+ for (const restore of undo.splice(start).reverse()) restore();
2557
+ };
2558
+
2559
+ const isUsed = (name: string) => funcs.has(name) || BUILTIN_NAMES.has(name);
2560
+
2561
+ const isClashing = (decl: number) => {
2562
+ const domain = manager.funcDecls[decl].domain;
2563
+ const decls = funcs.get(String(manager.funcDecls[decl].name)) ?? [];
2564
+ return (
2565
+ decls.includes(decl) &&
2566
+ decls.some(
2567
+ (other) =>
2568
+ other !== decl &&
2569
+ manager.funcDecls[other].domain.length === domain.length &&
2570
+ manager.funcDecls[other].domain.every((sort, index) => sort === domain[index]),
2571
+ )
2572
+ );
2573
+ };
2574
+
2575
+ // The first declaration of each name, in the slot order of cmd_context's dictionary.
2576
+ const getDeclaredFuncs = () => {
2577
+ const table = new ObjMap<true>((decl) => getSymbolHash(manager.funcDecls[decl].name));
2578
+ for (const decls of funcs.values()) table.set(decls[0], true);
2579
+ return [...table.keys()];
2580
+ };
2581
+
2582
+ // Z3 registers each named term and defined function as a recursive function definition.
2583
+ const hasDefinitions = () =>
2584
+ macros.size > 0 ||
2585
+ [...funcs.values()].some((decls) => decls.some((decl) => manager.recFunDefs.has(decl)));
2586
+
2587
+ return {
2588
+ declareCommand,
2589
+ insertFunc,
2590
+ getFuncs: (name: string) => funcs.get(name) ?? [],
2591
+ hasDefinitions,
2592
+ parseTerm,
2593
+ parseSort: (sexpr: SExpr) => parseSort(sexpr, ""),
2594
+ parseFormula,
2595
+ parseAssertion,
2596
+ getLogicError: logicChecker.checkExpr,
2597
+ push,
2598
+ pop,
2599
+ isUsed,
2600
+ isClashing,
2601
+ getDeclaredFuncs,
2602
+ };
2603
+ };
2604
+
2605
+ export type SmtlibReader = ReturnType<typeof createSmtlibReader>;
2606
+
2607
+ export const DECLARATIONS = new Set([
2608
+ "declare-sort",
2609
+ "declare-datatypes",
2610
+ "declare-datatype",
2611
+ "declare-fun",
2612
+ "declare-const",
2613
+ "define-fun",
2614
+ "define-const",
2615
+ "define-sort",
2616
+ "define-fun-rec",
2617
+ "define-funs-rec",
2618
+ ]);
2619
+
2620
+ // Z3 reports an error in a command, skips the command and goes on.
2621
+ export const parseSmtlib = (
2622
+ text: string,
2623
+ manager: AstManager,
2624
+ assertExpr: (assertion: number) => void,
2625
+ report: (error: SmtParseError) => void,
2626
+ ): SmtProblem => {
2627
+ const commands = createCommandReader(text);
2628
+ const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0 };
2629
+ const assertions: number[] = [];
2630
+ const runCommand = (list: SmtList) => {
2631
+ const name = expectSymbol(list.items[0], "invalid command, symbol expected", list).text;
2632
+ const option = list.items[1];
2633
+ const value = list.items[2];
2634
+ if (
2635
+ name === "set-option" &&
2636
+ option?.kind === "keyword" &&
2637
+ option.text === ":rlimit" &&
2638
+ value?.kind === "numeral"
2639
+ )
2640
+ state.rlimit = Number(value.text);
2641
+ if (name === "set-logic") {
2642
+ if (!isSymbol(option))
2643
+ throw new SmtParseError("invalid logic name, symbol expected", option ?? list.end);
2644
+ if (state.logic !== "") throw new SmtParseError("the logic has already been set", list.end);
2645
+ if (assertions.length > 0)
2646
+ throw new SmtParseError("logic must be set before initialization", list.end);
2647
+ if (!isSupportedLogic(option.text)) return;
2648
+ state.logic = option.text;
2649
+ state.reader = createSmtlibReader(manager, option.text);
2650
+ } else if (DECLARATIONS.has(name)) {
2651
+ if (name.startsWith("define-"))
2652
+ throw new SmtUnsupportedError(`the command ${name} is not supported`);
2653
+ state.reader.declareCommand(list);
513
2654
  } else if (name === "assert") {
514
- // cmd_context::assert_expr keeps the assertion, and passes it to the solver.
515
- const assertion = expectBool(parseTerm(list[1]));
516
- manager.incRef(assertion);
2655
+ const assertion = state.reader.parseFormula(list.items[1] ?? list.end);
2656
+ const logicError = state.reader.getLogicError(assertion);
2657
+ if (logicError !== undefined) {
2658
+ manager.decRef(assertion);
2659
+ throw new SmtParseError(logicError, list.end);
2660
+ }
517
2661
  assertions.push(assertion);
518
2662
  assertExpr(assertion);
519
- } else if (name === "check-sat") {
520
- hasCheckSat = true;
521
- break;
522
- } else if (name === "push" || name === "pop" || name === "define-fun" || name === "define-sort")
2663
+ } else if (name === "push" || name === "pop")
523
2664
  throw new SmtUnsupportedError(`the command ${name} is not supported`);
2665
+ };
2666
+ for (;;) {
2667
+ try {
2668
+ const list = commands.read();
2669
+ if (list === undefined) return { assertions, hasCheckSat: false, rlimit: state.rlimit };
2670
+ if (isSymbol(list.items[0], "check-sat"))
2671
+ return { assertions, hasCheckSat: true, rlimit: state.rlimit };
2672
+ runCommand(list);
2673
+ } catch (error) {
2674
+ if (!(error instanceof SmtParseError)) throw error;
2675
+ report(error);
2676
+ commands.skip(report);
2677
+ }
524
2678
  }
525
- return { assertions, hasCheckSat };
526
2679
  };