tla-ts 0.0.10-dev.094b9b512 → 0.0.10-dev.09e53c2a6

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 (487) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +3 -0
  5. package/dist/index.d.ts +3 -0
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +146 -58
  10. package/dist/prove.js +142 -54
  11. package/dist/run.cjs +45 -43
  12. package/dist/run.js +47 -45
  13. package/dist/transfer.cjs +39 -36
  14. package/dist/transfer.js +23 -20
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/check.ts +203 -33
  20. package/src/cli/tlapm.ts +268 -71
  21. package/src/cli/tlc-output.ts +3 -3
  22. package/src/cli/tlc-usage.ts +0 -1
  23. package/src/cli/tlc.ts +15 -1
  24. package/src/dependencies.ts +23 -2
  25. package/src/environment.ts +10 -5
  26. package/src/errors.ts +1 -1
  27. package/src/exit-codes.ts +1 -0
  28. package/src/liveness-checker.ts +530 -201
  29. package/src/liveness.ts +47 -32
  30. package/src/obligations/action.ts +0 -2
  31. package/src/obligations/anonymize.ts +2 -6
  32. package/src/obligations/equality.ts +0 -2
  33. package/src/obligations/expression.ts +0 -2
  34. package/src/obligations/format.ts +0 -2
  35. package/src/obligations/generate.ts +0 -2
  36. package/src/obligations/index.ts +8 -7
  37. package/src/obligations/levels.ts +0 -2
  38. package/src/obligations/module.ts +0 -2
  39. package/src/obligations/normalize.ts +0 -2
  40. package/src/obligations/operators.ts +0 -2
  41. package/src/obligations/pragma.ts +2 -2
  42. package/src/obligations/printer.ts +0 -2
  43. package/src/obligations/proof.ts +0 -2
  44. package/src/obligations/regroup.ts +0 -2
  45. package/src/obligations/simplify.ts +0 -2
  46. package/src/obligations/subexpression.ts +1 -4
  47. package/src/obligations/substitution.ts +0 -2
  48. package/src/obligations/temporal.ts +0 -2
  49. package/src/obligations/tuples.ts +0 -2
  50. package/src/parallel.ts +2 -2
  51. package/src/parser.ts +151 -42
  52. package/src/pretty-print.ts +1 -1
  53. package/src/prover/deciders.ts +1 -8
  54. package/src/prover/isabelle/encode.ts +0 -2
  55. package/src/prover/isabelle/isar/attrib.ts +86 -55
  56. package/src/prover/isabelle/isar/context.ts +25 -26
  57. package/src/prover/isabelle/isar/induct.ts +2 -12
  58. package/src/prover/isabelle/isar/method.ts +6 -10
  59. package/src/prover/isabelle/isar/proof.ts +40 -39
  60. package/src/prover/isabelle/isar/rule-cases.ts +6 -16
  61. package/src/prover/isabelle/isar/theory.ts +16 -17
  62. package/src/prover/isabelle/isar/toplevel.ts +46 -56
  63. package/src/prover/isabelle/isar/type-check.ts +0 -2
  64. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  65. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  66. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  67. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  68. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  69. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  70. package/src/prover/isabelle/provers/clasimp.ts +0 -2
  71. package/src/prover/isabelle/provers/classical.ts +1 -3
  72. package/src/prover/isabelle/provers/hypsubst.ts +0 -2
  73. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  74. package/src/prover/isabelle/pure/consts.ts +0 -2
  75. package/src/prover/isabelle/pure/conv.ts +0 -2
  76. package/src/prover/isabelle/pure/drule.ts +0 -2
  77. package/src/prover/isabelle/pure/envir.ts +0 -2
  78. package/src/prover/isabelle/pure/goal.ts +0 -2
  79. package/src/prover/isabelle/pure/logic.ts +0 -2
  80. package/src/prover/isabelle/pure/name.ts +0 -2
  81. package/src/prover/isabelle/pure/net.ts +0 -2
  82. package/src/prover/isabelle/pure/object-logic.ts +0 -2
  83. package/src/prover/isabelle/pure/pattern.ts +0 -2
  84. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  85. package/src/prover/isabelle/pure/rewriter.ts +0 -2
  86. package/src/prover/isabelle/pure/search.ts +0 -2
  87. package/src/prover/isabelle/pure/seq.ts +0 -2
  88. package/src/prover/isabelle/pure/simplifier.ts +0 -2
  89. package/src/prover/isabelle/pure/table.ts +0 -2
  90. package/src/prover/isabelle/pure/tactic.ts +0 -2
  91. package/src/prover/isabelle/pure/tactical.ts +0 -2
  92. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  93. package/src/prover/isabelle/pure/term.ts +0 -2
  94. package/src/prover/isabelle/pure/thm.ts +0 -2
  95. package/src/prover/isabelle/pure/type.ts +0 -2
  96. package/src/prover/isabelle/pure/unify.ts +0 -2
  97. package/src/prover/isabelle/pure/variable.ts +0 -2
  98. package/src/prover/isabelle/tla/classical-setup.ts +0 -2
  99. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  100. package/src/prover/isabelle/tools/intuitionistic.ts +0 -2
  101. package/src/prover/ocaml.ts +4 -1
  102. package/src/prover/prep/action.ts +1 -0
  103. package/src/prover/prep/methods.ts +55 -6
  104. package/src/prover/prep/normalize.ts +4 -1
  105. package/src/prover/prove.ts +58 -32
  106. package/src/prover/ptl/decide.ts +43 -63
  107. package/src/prover/smt/context.ts +10 -14
  108. package/src/prover/smt/data.ts +51 -45
  109. package/src/prover/smt/encode.ts +1 -2
  110. package/src/prover/smt/rewrite.ts +1 -0
  111. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +0 -2
  112. package/src/prover/smt/solver/ackr-helper.ts +0 -3
  113. package/src/prover/smt/solver/ackr-model-converter.ts +1 -8
  114. package/src/prover/smt/solver/act-cache.ts +0 -1
  115. package/src/prover/smt/solver/add-bounds-tactic.ts +0 -1
  116. package/src/prover/smt/solver/aig-tactic.ts +25 -16
  117. package/src/prover/smt/solver/aig.ts +2 -3
  118. package/src/prover/smt/solver/arith-rewriter.ts +4 -7
  119. package/src/prover/smt/solver/arith-terms.ts +0 -2
  120. package/src/prover/smt/solver/array-decl-plugin.ts +0 -1
  121. package/src/prover/smt/solver/array-rewriter.ts +1 -4
  122. package/src/prover/smt/solver/asserted-formulas.ts +1 -2
  123. package/src/prover/smt/solver/ast-lt.ts +1 -2
  124. package/src/prover/smt/solver/ast-util.ts +4 -5
  125. package/src/prover/smt/solver/ast.ts +113 -157
  126. package/src/prover/smt/solver/auf-solver.ts +0 -1
  127. package/src/prover/smt/solver/bit-blast-tactic.ts +2 -11
  128. package/src/prover/smt/solver/bit-blaster.ts +0 -3
  129. package/src/prover/smt/solver/bound-manager.ts +39 -29
  130. package/src/prover/smt/solver/bound-simplifier.ts +0 -2
  131. package/src/prover/smt/solver/bv-bound-chk.ts +2 -10
  132. package/src/prover/smt/solver/bv-decl-plugin.ts +0 -1
  133. package/src/prover/smt/solver/bv-divrem-bounds.ts +0 -2
  134. package/src/prover/smt/solver/bv-rewriter.ts +14 -18
  135. package/src/prover/smt/solver/bv1-blast.ts +1 -11
  136. package/src/prover/smt/solver/bv2fpa-converter.ts +0 -1
  137. package/src/prover/smt/solver/bv2int-rewriter.ts +0 -1
  138. package/src/prover/smt/solver/bv2real-rewriter.ts +0 -1
  139. package/src/prover/smt/solver/card2bv.ts +0 -2
  140. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  141. package/src/prover/smt/solver/cg-table.ts +19 -16
  142. package/src/prover/smt/solver/check-logic.ts +6 -2
  143. package/src/prover/smt/solver/clause.ts +0 -1
  144. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +0 -2
  145. package/src/prover/smt/solver/conflict-resolution.ts +8 -8
  146. package/src/prover/smt/solver/context.ts +21 -12
  147. package/src/prover/smt/solver/ctx-simplify.ts +0 -1
  148. package/src/prover/smt/solver/ctx-solver-simplify.ts +0 -2
  149. package/src/prover/smt/solver/datatype-decl-plugin.ts +7 -10
  150. package/src/prover/smt/solver/datatype-rewriter.ts +0 -1
  151. package/src/prover/smt/solver/demodulator.ts +2 -5
  152. package/src/prover/smt/solver/dependent-expr-state.ts +16 -3
  153. package/src/prover/smt/solver/der.ts +0 -1
  154. package/src/prover/smt/solver/diff-neq.ts +0 -1
  155. package/src/prover/smt/solver/distribute-forall.ts +1 -11
  156. package/src/prover/smt/solver/dom-simplify.ts +1 -3
  157. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -9
  158. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  159. package/src/prover/smt/solver/e-matching.ts +6 -7
  160. package/src/prover/smt/solver/elim-small-bv-tactic.ts +0 -1
  161. package/src/prover/smt/solver/elim-uncnstr.ts +3 -16
  162. package/src/prover/smt/solver/enode.ts +16 -10
  163. package/src/prover/smt/solver/eq2bv-tactic.ts +0 -1
  164. package/src/prover/smt/solver/euf/arith-axioms.ts +0 -1
  165. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -7
  166. package/src/prover/smt/solver/euf/arith-solver.ts +0 -6
  167. package/src/prover/smt/solver/euf/array-axioms.ts +0 -1
  168. package/src/prover/smt/solver/euf/array-internalize.ts +20 -11
  169. package/src/prover/smt/solver/euf/array-solver.ts +0 -2
  170. package/src/prover/smt/solver/euf/bv-ackerman.ts +0 -2
  171. package/src/prover/smt/solver/euf/bv-internalize.ts +0 -2
  172. package/src/prover/smt/solver/euf/bv-solver.ts +0 -2
  173. package/src/prover/smt/solver/euf/dt-solver.ts +19 -21
  174. package/src/prover/smt/solver/euf/egraph.ts +66 -44
  175. package/src/prover/smt/solver/euf/euf-solver.ts +37 -35
  176. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -53
  177. package/src/prover/smt/solver/euf/mam.ts +6 -50
  178. package/src/prover/smt/solver/euf/q-ematch.ts +26 -96
  179. package/src/prover/smt/solver/euf/q-mbi.ts +4 -4
  180. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -4
  181. package/src/prover/smt/solver/euf/q-solver.ts +3 -3
  182. package/src/prover/smt/solver/euf/th-solver.ts +1 -9
  183. package/src/prover/smt/solver/euf/th-solvers.ts +0 -1
  184. package/src/prover/smt/solver/expr-ref.ts +0 -1
  185. package/src/prover/smt/solver/expr-safe-replace.ts +0 -1
  186. package/src/prover/smt/solver/expr2polynomial.ts +0 -1
  187. package/src/prover/smt/solver/factor.ts +1 -12
  188. package/src/prover/smt/solver/fd-solver.ts +1 -5
  189. package/src/prover/smt/solver/fingerprints.ts +0 -1
  190. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  191. package/src/prover/smt/solver/flat-literals.ts +0 -1
  192. package/src/prover/smt/solver/fm-tactic.ts +25 -14
  193. package/src/prover/smt/solver/fpa-decl-plugin.ts +0 -1
  194. package/src/prover/smt/solver/fpa-rewriter.ts +13 -14
  195. package/src/prover/smt/solver/fpa2bv-converter.ts +10 -7
  196. package/src/prover/smt/solver/fpa2bv-rewriter.ts +0 -1
  197. package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -3
  198. package/src/prover/smt/solver/goal.ts +0 -1
  199. package/src/prover/smt/solver/goal2nlsat.ts +0 -2
  200. package/src/prover/smt/solver/guard-set.ts +0 -1
  201. package/src/prover/smt/solver/hash.ts +0 -1
  202. package/src/prover/smt/solver/hashtable.ts +0 -1
  203. package/src/prover/smt/solver/inf-eps.ts +1 -2
  204. package/src/prover/smt/solver/inj-axiom.ts +0 -1
  205. package/src/prover/smt/solver/internalizer.ts +41 -3
  206. package/src/prover/smt/solver/lackr.ts +0 -2
  207. package/src/prover/smt/solver/lbool.ts +0 -1
  208. package/src/prover/smt/solver/lia2card.ts +1 -2
  209. package/src/prover/smt/solver/lia2pb.ts +18 -5
  210. package/src/prover/smt/solver/literal.ts +0 -1
  211. package/src/prover/smt/solver/logic-tactics.ts +0 -4
  212. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  213. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  214. package/src/prover/smt/solver/lp/containers.ts +0 -1
  215. package/src/prover/smt/solver/lp/core-solver.ts +0 -3
  216. package/src/prover/smt/solver/lp/cross-nested.ts +0 -1
  217. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  218. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  219. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  220. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  221. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  222. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  223. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  224. package/src/prover/smt/solver/lp/int-cube.ts +0 -1
  225. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  226. package/src/prover/smt/solver/lp/lar-solver.ts +1 -2
  227. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  228. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  229. package/src/prover/smt/solver/lp/maximize-term.ts +0 -3
  230. package/src/prover/smt/solver/lp/nex-creator.ts +0 -1
  231. package/src/prover/smt/solver/lp/nex.ts +0 -1
  232. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  233. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  234. package/src/prover/smt/solver/lp/nla-core.ts +25 -6
  235. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  236. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  237. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  238. package/src/prover/smt/solver/lp/nla-grobner.ts +0 -2
  239. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  240. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  241. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  242. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  243. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  244. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  245. package/src/prover/smt/solver/lp/nla-powers.ts +144 -108
  246. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  247. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  248. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -19
  249. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  250. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  251. package/src/prover/smt/solver/lp/nra-solver.ts +97 -62
  252. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  253. package/src/prover/smt/solver/lp/pdd-interval.ts +0 -1
  254. package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
  255. package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
  256. package/src/prover/smt/solver/lp/pdd.ts +2 -2
  257. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  258. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  259. package/src/prover/smt/solver/lp/union-find.ts +0 -1
  260. package/src/prover/smt/solver/macro-finder.ts +1 -4
  261. package/src/prover/smt/solver/mam-compiler.ts +13 -14
  262. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  263. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -13
  264. package/src/prover/smt/solver/max-cliques.ts +0 -2
  265. package/src/prover/smt/solver/maxcore.ts +6 -15
  266. package/src/prover/smt/solver/maximize-ac-sharing.ts +0 -2
  267. package/src/prover/smt/solver/maxlex.ts +0 -8
  268. package/src/prover/smt/solver/maxsmt-base.ts +7 -1
  269. package/src/prover/smt/solver/maxsmt.ts +0 -1
  270. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -12
  271. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +0 -1
  272. package/src/prover/smt/solver/mbp/mbp-plugin.ts +10 -3
  273. package/src/prover/smt/solver/mbp/mbp-qel.ts +0 -1
  274. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -10
  275. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +1 -19
  276. package/src/prover/smt/solver/model-based-opt.ts +0 -1
  277. package/src/prover/smt/solver/model-checker.ts +2 -3
  278. package/src/prover/smt/solver/model-evaluator.ts +9 -6
  279. package/src/prover/smt/solver/model-finder.ts +0 -1
  280. package/src/prover/smt/solver/model-generator.ts +0 -1
  281. package/src/prover/smt/solver/model-macro-solver.ts +3 -4
  282. package/src/prover/smt/solver/model-printer.ts +0 -1
  283. package/src/prover/smt/solver/mpf.ts +0 -1
  284. package/src/prover/smt/solver/mus.ts +0 -1
  285. package/src/prover/smt/solver/muz/dl-context.ts +57 -15
  286. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +0 -1
  287. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -22
  288. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -3
  289. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +0 -6
  290. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -11
  291. package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -14
  292. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -4
  293. package/src/prover/smt/solver/muz/dl-rule-set.ts +0 -30
  294. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -4
  295. package/src/prover/smt/solver/muz/dl-rule.ts +91 -55
  296. package/src/prover/smt/solver/muz/hnf.ts +6 -6
  297. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  298. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -5
  299. package/src/prover/smt/solver/muz/rule-properties.ts +195 -37
  300. package/src/prover/smt/solver/muz/spacer-context.ts +109 -98
  301. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -4
  302. package/src/prover/smt/solver/muz/spacer-generalizers.ts +0 -3
  303. package/src/prover/smt/solver/muz/spacer-manager.ts +0 -6
  304. package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -4
  305. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +4 -15
  306. package/src/prover/smt/solver/muz/spacer-util.ts +2 -29
  307. package/src/prover/smt/solver/muz/substitution.ts +88 -39
  308. package/src/prover/smt/solver/nla2bv-tactic.ts +0 -1
  309. package/src/prover/smt/solver/nlqsat.ts +4 -4
  310. package/src/prover/smt/solver/nlsat/algebraic.ts +1 -4
  311. package/src/prover/smt/solver/nlsat/atoms.ts +0 -2
  312. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  313. package/src/prover/smt/solver/nlsat/explain.ts +5 -1
  314. package/src/prover/smt/solver/nlsat/interval-set.ts +0 -1
  315. package/src/prover/smt/solver/nlsat/levelwise.ts +2 -3
  316. package/src/prover/smt/solver/nlsat/mpbq.ts +0 -1
  317. package/src/prover/smt/solver/nlsat/polynomial.ts +0 -2
  318. package/src/prover/smt/solver/nlsat/solver.ts +47 -44
  319. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +2 -3
  320. package/src/prover/smt/solver/nlsat/transcendentals.ts +0 -2
  321. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  322. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +0 -3
  323. package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
  324. package/src/prover/smt/solver/nlsat-tactic.ts +0 -1
  325. package/src/prover/smt/solver/nnf.ts +0 -1
  326. package/src/prover/smt/solver/normalize-bounds.ts +0 -1
  327. package/src/prover/smt/solver/occf.ts +0 -1
  328. package/src/prover/smt/solver/opt-context.ts +10 -10
  329. package/src/prover/smt/solver/opt-nlsat.ts +68 -59
  330. package/src/prover/smt/solver/opt-pareto.ts +0 -2
  331. package/src/prover/smt/solver/opt-preprocess.ts +0 -1
  332. package/src/prover/smt/solver/opt-solver.ts +16 -8
  333. package/src/prover/smt/solver/opt-value.ts +0 -1
  334. package/src/prover/smt/solver/optsmt.ts +12 -11
  335. package/src/prover/smt/solver/parallel-tactic.ts +0 -2
  336. package/src/prover/smt/solver/pattern-inference.ts +2 -3
  337. package/src/prover/smt/solver/pb-rewriter.ts +14 -26
  338. package/src/prover/smt/solver/pb2bv-tactic.ts +0 -2
  339. package/src/prover/smt/solver/poly-rewriter.ts +2 -3
  340. package/src/prover/smt/solver/probes.ts +3 -5
  341. package/src/prover/smt/solver/propagate-values.ts +4 -1
  342. package/src/prover/smt/solver/proto-model.ts +5 -6
  343. package/src/prover/smt/solver/pull-quant.ts +0 -1
  344. package/src/prover/smt/solver/purify-arith.ts +50 -16
  345. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -3
  346. package/src/prover/smt/solver/qe-lite-der.ts +0 -1
  347. package/src/prover/smt/solver/qe-lite-fm.ts +0 -1
  348. package/src/prover/smt/solver/qe-lite.ts +0 -1
  349. package/src/prover/smt/solver/qe-mbp.ts +13 -24
  350. package/src/prover/smt/solver/qe.ts +45 -55
  351. package/src/prover/smt/solver/qel.ts +0 -1
  352. package/src/prover/smt/solver/qi-queue.ts +0 -1
  353. package/src/prover/smt/solver/qsat.ts +71 -97
  354. package/src/prover/smt/solver/quant-hoist.ts +2 -1
  355. package/src/prover/smt/solver/quant-tactics.ts +0 -1
  356. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  357. package/src/prover/smt/solver/quantifier-manager.ts +0 -1
  358. package/src/prover/smt/solver/quasi-macros.ts +9 -20
  359. package/src/prover/smt/solver/random-gen.ts +0 -1
  360. package/src/prover/smt/solver/rational.ts +17 -1
  361. package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -20
  362. package/src/prover/smt/solver/recfun-rewriter.ts +1 -2
  363. package/src/prover/smt/solver/reduce-args.ts +0 -1
  364. package/src/prover/smt/solver/reduce-bv-size.ts +0 -1
  365. package/src/prover/smt/solver/ref-vector.ts +0 -1
  366. package/src/prover/smt/solver/relevancy.ts +0 -1
  367. package/src/prover/smt/solver/rewriter-tpl.ts +6 -3
  368. package/src/prover/smt/solver/rewriter.ts +1 -2
  369. package/src/prover/smt/solver/rlimit.ts +13 -1
  370. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -48
  371. package/src/prover/smt/solver/sat/big.ts +0 -1
  372. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -8
  373. package/src/prover/smt/solver/sat/clause.ts +2 -20
  374. package/src/prover/smt/solver/sat/cleaner.ts +0 -2
  375. package/src/prover/smt/solver/sat/config.ts +5 -8
  376. package/src/prover/smt/solver/sat/consequences.ts +1 -2
  377. package/src/prover/smt/solver/sat/elim-eqs.ts +0 -2
  378. package/src/prover/smt/solver/sat/goal2sat.ts +1 -3
  379. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -14
  380. package/src/prover/smt/solver/sat/model-converter.ts +1 -21
  381. package/src/prover/smt/solver/sat/pb-constraint.ts +0 -3
  382. package/src/prover/smt/solver/sat/pb-solver.ts +49 -25
  383. package/src/prover/smt/solver/sat/probing.ts +22 -21
  384. package/src/prover/smt/solver/sat/sat-tactic.ts +0 -1
  385. package/src/prover/smt/solver/sat/sat2goal.ts +9 -15
  386. package/src/prover/smt/solver/sat/scc.ts +1 -2
  387. package/src/prover/smt/solver/sat/simplifier.ts +15 -59
  388. package/src/prover/smt/solver/sat/solver.ts +22 -23
  389. package/src/prover/smt/solver/sat/var-queue.ts +0 -2
  390. package/src/prover/smt/solver/sat/watch-list.ts +7 -3
  391. package/src/prover/smt/solver/search-tree.ts +0 -1
  392. package/src/prover/smt/solver/seq-axioms.ts +1 -4
  393. package/src/prover/smt/solver/seq-decl-plugin.ts +9 -13
  394. package/src/prover/smt/solver/seq-derive.ts +8 -10
  395. package/src/prover/smt/solver/seq-eq-approx.ts +0 -2
  396. package/src/prover/smt/solver/seq-eq-solver.ts +7 -8
  397. package/src/prover/smt/solver/seq-factory.ts +2 -4
  398. package/src/prover/smt/solver/seq-monadic.ts +0 -2
  399. package/src/prover/smt/solver/seq-range-predicate.ts +18 -8
  400. package/src/prover/smt/solver/seq-re-rewriter.ts +3 -129
  401. package/src/prover/smt/solver/seq-re-util.ts +7 -26
  402. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -2
  403. package/src/prover/smt/solver/seq-regex-live.ts +4 -6
  404. package/src/prover/smt/solver/seq-rewriter.ts +1 -6
  405. package/src/prover/smt/solver/seq-skolem.ts +0 -1
  406. package/src/prover/smt/solver/seq-subset.ts +0 -1
  407. package/src/prover/smt/solver/seq-view-witness.ts +0 -2
  408. package/src/prover/smt/solver/smt-consequences.ts +0 -2
  409. package/src/prover/smt/solver/smt-kernel.ts +0 -2
  410. package/src/prover/smt/solver/smt-logics.ts +0 -1
  411. package/src/prover/smt/solver/smt-setup.ts +18 -14
  412. package/src/prover/smt/solver/smt2-printer.ts +0 -2
  413. package/src/prover/smt/solver/smtlib-parser.ts +1204 -582
  414. package/src/prover/smt/solver/smtlib-script.ts +868 -730
  415. package/src/prover/smt/solver/solve-eqs.ts +0 -2
  416. package/src/prover/smt/solver/solver.ts +1 -2
  417. package/src/prover/smt/solver/static-features.ts +0 -5
  418. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  419. package/src/prover/smt/solver/tactic.ts +66 -16
  420. package/src/prover/smt/solver/term-enumeration.ts +0 -1
  421. package/src/prover/smt/solver/theory-array.ts +25 -60
  422. package/src/prover/smt/solver/theory-bv.ts +13 -52
  423. package/src/prover/smt/solver/theory-char.ts +0 -1
  424. package/src/prover/smt/solver/theory-datatype.ts +0 -1
  425. package/src/prover/smt/solver/theory-finite-set.ts +2 -2
  426. package/src/prover/smt/solver/theory-fpa.ts +46 -79
  427. package/src/prover/smt/solver/theory-lra-axioms.ts +0 -1
  428. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -1
  429. package/src/prover/smt/solver/theory-lra-final-check.ts +0 -1
  430. package/src/prover/smt/solver/theory-lra-internalize.ts +8 -1
  431. package/src/prover/smt/solver/theory-lra-model.ts +0 -1
  432. package/src/prover/smt/solver/theory-lra-propagate.ts +0 -1
  433. package/src/prover/smt/solver/theory-lra-state.ts +0 -1
  434. package/src/prover/smt/solver/theory-lra.ts +0 -6
  435. package/src/prover/smt/solver/theory-pb.ts +10 -8
  436. package/src/prover/smt/solver/theory-polymorphism.ts +3 -4
  437. package/src/prover/smt/solver/theory-recfun.ts +2 -3
  438. package/src/prover/smt/solver/theory-seq-regex.ts +3 -7
  439. package/src/prover/smt/solver/theory-seq-solve.ts +5 -7
  440. package/src/prover/smt/solver/theory-seq-state.ts +6 -15
  441. package/src/prover/smt/solver/theory-seq.ts +32 -55
  442. package/src/prover/smt/solver/theory.ts +16 -2
  443. package/src/prover/smt/solver/tseitin-cnf.ts +3 -5
  444. package/src/prover/smt/solver/var-subst.ts +6 -6
  445. package/src/prover/smt/table.ts +3 -2
  446. package/src/prover/zenon/decide.ts +9 -13
  447. package/src/prover/zenon/encode.ts +0 -2
  448. package/src/prover/zenon/eqrel.ts +0 -2
  449. package/src/prover/zenon/equality-rules.ts +0 -2
  450. package/src/prover/zenon/expr.ts +0 -2
  451. package/src/prover/zenon/index-table.ts +0 -2
  452. package/src/prover/zenon/isar-case.ts +0 -2
  453. package/src/prover/zenon/isar.ts +0 -2
  454. package/src/prover/zenon/llproof.ts +0 -2
  455. package/src/prover/zenon/mltoll.ts +0 -2
  456. package/src/prover/zenon/node.ts +12 -13
  457. package/src/prover/zenon/parse.ts +0 -2
  458. package/src/prover/zenon/phrase.ts +0 -2
  459. package/src/prover/zenon/proof.ts +0 -2
  460. package/src/prover/zenon/propositional-rules.ts +0 -2
  461. package/src/prover/zenon/rules.ts +0 -2
  462. package/src/prover/zenon/search.ts +0 -2
  463. package/src/prover/zenon/tla/functions.ts +0 -2
  464. package/src/prover/zenon/tla/llproof.ts +0 -2
  465. package/src/prover/zenon/tla/records.ts +0 -2
  466. package/src/prover/zenon/tla/rewrites.ts +0 -2
  467. package/src/prover/zenon/tla/sets.ts +1 -3
  468. package/src/prover/zenon/tla/terms.ts +0 -2
  469. package/src/prover/zenon/tla/tla.ts +0 -2
  470. package/src/resolve.ts +1 -2
  471. package/src/runtime.ts +4 -0
  472. package/src/sany/levels.ts +0 -2
  473. package/src/sany/linter.ts +0 -2
  474. package/src/search.ts +160 -36
  475. package/src/simulate.ts +3 -0
  476. package/src/standard-definitions.ts +4 -0
  477. package/src/state-graph.ts +0 -2
  478. package/src/successors.ts +1 -1
  479. package/src/symmetry.ts +2 -2
  480. package/src/tableau.ts +2 -2
  481. package/src/tlc/fingerprint.ts +81 -9
  482. package/src/tlc/summary.ts +29 -14
  483. package/src/tlc/tlcext-operators.ts +44 -12
  484. package/src/typed-tier.ts +6535 -0
  485. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
  486. package/src/prover/smt/solver/z3-license.txt +0 -10
  487. package/src/prover/zenon/LICENSE +0 -32
@@ -1,12 +1,10 @@
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
1
  import { SmtParseError, SmtUnsupportedError } from "../../../errors";
4
2
  import {
5
3
  type AstManager,
6
4
  getSymbolHash,
7
5
  FAMILY_ARITH,
8
6
  FAMILY_BASIC,
9
- FAMILY_DATATYPE,
7
+ KIND_APP,
10
8
  KIND_QUANTIFIER,
11
9
  KIND_VAR,
12
10
  OP_ABS,
@@ -23,6 +21,7 @@ import {
23
21
  OP_DISTINCT,
24
22
  OP_DIV,
25
23
  OP_DT_ACCESSOR,
24
+ OP_DT_CONSTRUCTOR,
26
25
  OP_EQ,
27
26
  OP_GE,
28
27
  OP_GT,
@@ -37,6 +36,7 @@ import {
37
36
  OP_MUL,
38
37
  OP_NOT,
39
38
  OP_OR,
39
+ OP_PATTERN,
40
40
  OP_POWER,
41
41
  OP_POWER0,
42
42
  OP_SIN,
@@ -62,8 +62,6 @@ import {
62
62
  OP_TRUE,
63
63
  OP_FALSE,
64
64
  OP_UMINUS,
65
- OP_UNINTERPRETED,
66
- OP_FUN_DEFINED,
67
65
  OP_XOR,
68
66
  SORT_BOOL,
69
67
  SORT_INT,
@@ -100,6 +98,7 @@ import {
100
98
  mkFpaAppOf,
101
99
  } from "./fpa-decl-plugin";
102
100
  import { createLogicChecker } from "./check-logic";
101
+ import { shrink } from "./array";
103
102
  import { ObjMap } from "./hashtable";
104
103
  import {
105
104
  CHAR_OP_NAMES,
@@ -120,6 +119,7 @@ import {
120
119
  isSupportedLogic,
121
120
  } from "./smt-logics";
122
121
  import { setRecFunDefinition } from "./recfun-decl-plugin";
122
+ import { DEFAULT_PRINT_OPTIONS, printExpr } from "./smt2-printer";
123
123
  import { replaceFreeVars, VarSubst } from "./var-subst";
124
124
  import { UpolynomialManager } from "./nlsat/upolynomial";
125
125
 
@@ -147,25 +147,27 @@ export interface SmtList {
147
147
  offset: number;
148
148
  // Z3 reports an error in making an application at its closing parenthesis.
149
149
  end: SmtToken;
150
+ // The token after a root-obj or an indexed or qualified identifier, where Z3 reports an error in
151
+ // making it.
150
152
  follower?: SmtToken;
153
+ // The command that a list a command reader read is part of.
154
+ root?: SmtList;
151
155
  }
152
156
 
153
157
  export type SExpr = SmtToken | SmtList;
154
158
 
155
- interface VarBinding {
156
- kind: "var";
157
- depth: number;
158
- sort: number;
159
+ // smt2parser's local: a term, and the number of binders around it where it was bound.
160
+ interface Local {
161
+ expr: number;
162
+ level: number;
159
163
  }
160
164
 
161
- interface LetBinding {
162
- kind: "let";
163
- depth: number;
165
+ interface ParsedTerm {
164
166
  expr: number;
167
+ isOwned: boolean;
168
+ root: SmtList | undefined;
165
169
  }
166
170
 
167
- type Binding = VarBinding | LetBinding;
168
-
169
171
  interface Macro {
170
172
  domain: number[];
171
173
  range: number;
@@ -214,15 +216,103 @@ interface SmtProblem {
214
216
  rlimit: number;
215
217
  }
216
218
 
217
- interface ApplicationFrame {
219
+ interface QualifiedHead {
218
220
  head: SmtToken;
219
221
  indices: number[];
220
222
  build?: (args: number[]) => number;
223
+ }
224
+
225
+ interface ApplicationFrame extends QualifiedHead {
226
+ kind: "application";
227
+ list: SmtList;
228
+ isTail: boolean;
229
+ start: number;
230
+ next: number;
231
+ }
232
+
233
+ // An application whose head is a term, which selects from the array it stands for.
234
+ interface SelectionFrame {
235
+ kind: "selection";
221
236
  list: SmtList;
237
+ isTail: boolean;
222
238
  start: number;
223
239
  next: number;
224
240
  }
225
241
 
242
+ interface LetFrame {
243
+ kind: "let";
244
+ list: SmtList;
245
+ bindings: SmtList;
246
+ names: string[];
247
+ isInDecls: boolean;
248
+ isTail: boolean;
249
+ start: number;
250
+ next: number;
251
+ }
252
+
253
+ interface LetDeclFrame {
254
+ kind: "let-decl";
255
+ list: SmtList;
256
+ next: number;
257
+ }
258
+
259
+ interface QuantifierFrame {
260
+ kind: "quantifier";
261
+ list: SmtList;
262
+ quantifierKind: number;
263
+ names: string[];
264
+ varSorts: number[];
265
+ weight: number;
266
+ qid: string;
267
+ skid: string | undefined;
268
+ isTail: boolean;
269
+ start: number;
270
+ patternStart: number;
271
+ noPatternStart: number;
272
+ next: number;
273
+ }
274
+
275
+ interface AttributeFrame {
276
+ kind: "attribute";
277
+ list: SmtList;
278
+ quantifier: QuantifierFrame | undefined;
279
+ lastKeyword: string;
280
+ isTail: boolean;
281
+ start: number;
282
+ next: number;
283
+ }
284
+
285
+ interface PatternFrame {
286
+ kind: "pattern";
287
+ list: SmtList;
288
+ start: number;
289
+ next: number;
290
+ }
291
+
292
+ // smt2parser.cpp's expr_frame.
293
+ type TermFrame =
294
+ | ApplicationFrame
295
+ | SelectionFrame
296
+ | LetFrame
297
+ | LetDeclFrame
298
+ | QuantifierFrame
299
+ | AttributeFrame
300
+ | PatternFrame;
301
+
302
+ const QUANTIFIER_KINDS = new Map([
303
+ ["forall", QUANTIFIER_FORALL],
304
+ ["exists", QUANTIFIER_EXISTS],
305
+ ["lambda", QUANTIFIER_LAMBDA],
306
+ ]);
307
+
308
+ const LET_MESSAGE = "invalid let declaration, symbol expected";
309
+
310
+ // The attributes that consume_attributes takes only in the body of a quantifier.
311
+ const QUANTIFIER_ATTRIBUTES = new Set([":weight", ":skolemid", ":qid", ":pattern", ":no-pattern"]);
312
+
313
+ const IS_PARAMETER_MESSAGE =
314
+ "invalid parameter to datatype function arity == 1 && num_parameters == 1 && parameters[0].is_ast() && is_func_decl(parameters[0].get_ast())";
315
+
226
316
  const BUILTIN_OPS = new Map<string, number>([
227
317
  ["and", OP_AND],
228
318
  ["-", OP_SUB],
@@ -389,17 +479,19 @@ const THEORY_OPERATORS = new Set([
389
479
  "transitive-closure",
390
480
  ]);
391
481
 
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]);
482
+ // func_decl_info of the builtin declarations: associative to both sides, flat, and associative to
483
+ // the left only. => alone is associative to the right only.
484
+ const ASSOCIATIVE_OPS = new Set([OP_AND, OP_OR, OP_XOR, OP_ADD, OP_MUL]);
485
+ const FLAT_OPS = new Set([OP_AND, OP_OR, OP_ADD, OP_MUL]);
486
+ const LEFT_ASSOCIATIVE_OPS = new Set([OP_SUB, OP_DIV, OP_IDIV]);
395
487
 
488
+ // arith_decl_plugin's use_coercion.
396
489
  const COERCING_OPS = new Set([
397
490
  OP_ADD,
398
491
  OP_SUB,
399
492
  OP_UMINUS,
400
493
  OP_MUL,
401
494
  OP_POWER,
402
- OP_POWER0,
403
495
  OP_LE,
404
496
  OP_GE,
405
497
  OP_LT,
@@ -424,30 +516,12 @@ const REAL_FUNCTION_OPS = new Set([
424
516
  OP_LOG,
425
517
  ]);
426
518
 
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]],
519
+ // The arity of each builtin declaration but distinct, which takes the arguments it is given.
520
+ const ARITIES = new Map<number, number>([
521
+ [OP_ITE, 3],
433
522
  ...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
434
523
  .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]]),
524
+ .map((op): [number, number] => [op, 1]),
451
525
  ]);
452
526
 
453
527
  const RANGES = new Map<number, number>([
@@ -483,6 +557,7 @@ const CHAINABLE_OPS = new Map<string, number>([
483
557
  ["<", OP_LT],
484
558
  [">", OP_GT],
485
559
  ]);
560
+ const CHAINABLE_DECLS = new Set(CHAINABLE_OPS.values());
486
561
 
487
562
  const BV_EXTENSION_NAMES = new Set([
488
563
  "bvumul_noovfl",
@@ -544,6 +619,9 @@ interface MappedDecl {
544
619
  }
545
620
  const ARRAY_EXTENSION_LOGICS = new Set(["HORN", "ALL"]);
546
621
 
622
+ // arith_decl_plugin::get_sort_names gives these logics no Int.
623
+ const INT_FREE_LOGICS = new Set(["NRA", "QF_NRA", "QF_NTA", "QF_UFNRA"]);
624
+
547
625
  const BUILTIN_NAMES = new Set([
548
626
  "true",
549
627
  "false",
@@ -558,6 +636,14 @@ const BUILTIN_NAMES = new Set([
558
636
  ...CHAR_OP_NAMES.keys(),
559
637
  ]);
560
638
 
639
+ const FOLLOWED_HEADS = new Set(["root-obj", "_", "as"]);
640
+
641
+ const FF_LITERAL = /^#f-?[0-9]+m[0-9]+$/;
642
+ const FF_LOGICS = new Set(["QF_FF", "QF_FFA", "ALL", "HO_ALL"]);
643
+
644
+ // rational::is_unsigned of a numeral token.
645
+ const isUnsigned = (numeral: string) => BigInt(numeral) >= 0n && BigInt(numeral) <= 0xffffffffn;
646
+
561
647
  const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
562
648
 
563
649
  const createScanner = (text: string) => {
@@ -607,6 +693,11 @@ const createScanner = (text: string) => {
607
693
  { line: state.line, column: getColumn() },
608
694
  );
609
695
  const current = text[state.index];
696
+ if (character === "|" && current === "\\")
697
+ throw new SmtParseError("invalid character '\\' in quoted symbol", {
698
+ line: state.line,
699
+ column: getColumn(),
700
+ });
610
701
  advance();
611
702
  // Z3's scanner starts the line before it reads past a newline in a quoted symbol or a
612
703
  // string, so the columns of the rest of the line count one more.
@@ -630,7 +721,36 @@ const createScanner = (text: string) => {
630
721
  }
631
722
  if (character === "#") {
632
723
  advance();
633
- readWhile(/[0-9A-Za-z]/);
724
+ const radix = text[state.index];
725
+ if (radix === "|") {
726
+ advance();
727
+ while (state.index < text.length) {
728
+ const current = text[state.index];
729
+ advance();
730
+ if (current !== "|" || text[state.index] !== "#") continue;
731
+ advance();
732
+ break;
733
+ }
734
+ continue;
735
+ }
736
+ if (radix === "f") {
737
+ advance();
738
+ readWhile(/[0-9m-]/);
739
+ return getToken("symbol");
740
+ }
741
+ if (radix !== "x" && radix !== "b")
742
+ throw new SmtParseError("invalid bit-vector literal, expecting 'x' or 'b'", {
743
+ line: state.line,
744
+ column: getColumn(),
745
+ });
746
+ advance();
747
+ const digitsStart = state.index;
748
+ readWhile(radix === "x" ? /[0-9a-fA-F]/ : /[01]/);
749
+ if (state.index === digitsStart)
750
+ throw new SmtParseError("invalid empty bit-vector literal", {
751
+ line: state.line,
752
+ column: getColumn(),
753
+ });
634
754
  return getToken("bitvector");
635
755
  }
636
756
  if (character === ":" || SYMBOL_CHARACTER.test(character)) {
@@ -666,13 +786,13 @@ export const createCommandReader = (text: string) => {
666
786
  offset: open.offset,
667
787
  end: open,
668
788
  };
669
- let rootObject: SmtList | undefined;
789
+ let followed: SmtList | undefined;
670
790
  for (let current = root; ;) {
671
791
  const token = take();
672
792
  if (token === undefined)
673
793
  throw new SmtParseError("unexpected end of file", scanner.getPosition());
674
- if (rootObject !== undefined) rootObject.follower = token;
675
- rootObject = undefined;
794
+ if (followed !== undefined) followed.follower = token;
795
+ followed = undefined;
676
796
  if (token.kind === "(") {
677
797
  const list: SmtList = {
678
798
  kind: "list",
@@ -681,6 +801,7 @@ export const createCommandReader = (text: string) => {
681
801
  column: token.column,
682
802
  offset: token.offset,
683
803
  end: token,
804
+ root,
684
805
  };
685
806
  current.items.push(list);
686
807
  stack.push(current);
@@ -693,7 +814,8 @@ export const createCommandReader = (text: string) => {
693
814
  continue;
694
815
  }
695
816
  current.end = token;
696
- if (isSymbol(current.items[0], "root-obj")) rootObject = current;
817
+ if (isSymbol(current.items[0]) && FOLLOWED_HEADS.has(current.items[0].text))
818
+ followed = current;
697
819
  state.depth--;
698
820
  const parent = stack.pop();
699
821
  if (parent === undefined) return root;
@@ -730,6 +852,28 @@ export const createCommandReader = (text: string) => {
730
852
  export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
731
853
  sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
732
854
 
855
+ // The identifier Z3's scanner read last, which check_next prints after "got".
856
+ const getLastId = (sexpr: SExpr | undefined): string | undefined => {
857
+ if (sexpr === undefined) return undefined;
858
+ if (sexpr.kind !== "list")
859
+ return sexpr.kind === "symbol" || sexpr.kind === "keyword" ? sexpr.text : undefined;
860
+ return getLastIdBefore(sexpr.items, sexpr.items.length);
861
+ };
862
+
863
+ const getLastIdBefore = (items: SExpr[], end: number): string | undefined => {
864
+ for (let index = end - 1; index >= 0; index--) {
865
+ const id = getLastId(items[index]);
866
+ if (id !== undefined) return id;
867
+ }
868
+ return undefined;
869
+ };
870
+
871
+ const isSimpleIndex = (index: SExpr) =>
872
+ index.kind === "numeral" ||
873
+ index.kind === "bitvector" ||
874
+ index.kind === "decimal" ||
875
+ index.kind === "keyword";
876
+
733
877
  const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtList => {
734
878
  if (sexpr?.kind !== "list") throw new SmtParseError(message, sexpr ?? at);
735
879
  return sexpr;
@@ -747,16 +891,13 @@ export const createSmtlibReader = (
747
891
  ) => {
748
892
  const hasArith = logic === undefined || logicHasArith(logic);
749
893
  const hasBv = logic === undefined || logicHasBv(logic);
750
- const isNumeralAsReal = logic !== undefined && logicHasRealsOnly(logic);
751
894
  const logicChecker = createLogicChecker(manager, logic);
752
895
  const sortDecls = new Map<string, SortDecl>([
753
896
  ["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
- ]
897
+ ...(hasArith && !(logic !== undefined && INT_FREE_LOGICS.has(logic))
898
+ ? [["Int", { kind: "sort", sort: SORT_INT }] as const]
759
899
  : []),
900
+ ...(hasArith ? [["Real", { kind: "sort", sort: SORT_REAL }] as const] : []),
760
901
  ...(logic === undefined ? [["List", { kind: "list" }] as const] : []),
761
902
  ]);
762
903
  const funcs = new Map<string, readonly number[]>();
@@ -765,8 +906,25 @@ export const createSmtlibReader = (
765
906
  const notifiedSorts = new Set<number>();
766
907
  const undo: (() => void)[] = [];
767
908
  const scopeStarts: number[] = [];
768
- const scopes: Map<string, Binding>[] = [];
909
+ // smt2parser's m_env, a scoped symbol table: one map, and the trail of what each scope shadowed.
910
+ const locals = new Map<string, Local>();
911
+ const shadowedNames: string[] = [];
912
+ const shadowedLocals: (Local | undefined)[] = [];
913
+ const localScopes: number[] = [];
769
914
  const binders = { depth: 0 };
915
+ // smt2parser's expr_stack, pattern_stack and nopattern_stack, which hold a reference to each term.
916
+ // -1 on the first stands for a pattern that Z3 ignores.
917
+ const exprStack: number[] = [];
918
+ const patternStack: number[] = [];
919
+ const noPatternStack: number[] = [];
920
+ // The term that parseTerm returns leaves the stack before its caller takes a reference. One that
921
+ // only the stack held keeps a reference in pending until a term of another command is parsed, and
922
+ // one that nothing held, in floating or, where its command is not known, in unrooted, gets one
923
+ // there when another term is parsed while its caller may still read it.
924
+ const parsed: ParsedTerm = { expr: -1, isOwned: false, root: undefined };
925
+ const floating: number[] = [];
926
+ const unrooted: number[] = [];
927
+ const pending: number[] = [];
770
928
 
771
929
  const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
772
930
  const previous = names.get(name);
@@ -781,9 +939,20 @@ export const createSmtlibReader = (
781
939
  const hasFpa = logic === undefined || logicHasFpa(logic);
782
940
  const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
783
941
  const hasSeq = logic === undefined || logicHasSeq(logic);
942
+ const restricted = {
943
+ isNumeralAsReal: logic !== undefined && logicHasRealsOnly(logic),
944
+ hasSetSort: hasArrayExtensions,
945
+ hasFf: logic === undefined || FF_LOGICS.has(logic),
946
+ };
784
947
 
785
948
  const getFirstFunc = (name: string) => funcs.get(name)?.[0];
786
949
 
950
+ // func_decls::signatures_collide: the domain, and the range unless it is -1.
951
+ const hasSignature = (decl: number, domain: readonly number[], range: number) =>
952
+ (range === -1 || manager.funcDecls[decl].range === range) &&
953
+ manager.funcDecls[decl].domain.length === domain.length &&
954
+ manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]);
955
+
787
956
  const checkDecl = (decl: number, at: SExpr) => {
788
957
  const error = logicChecker.checkDecl(decl);
789
958
  if (error !== undefined) throw new SmtParseError(error, at);
@@ -909,7 +1078,8 @@ export const createSmtlibReader = (
909
1078
  ): number => {
910
1079
  const head = sexpr.items[0];
911
1080
  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);
1081
+ const isArray =
1082
+ ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && restricted.hasSetSort);
913
1083
  if (isArray && hasArrays) {
914
1084
  const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
915
1085
  if (head.text === "Set" ? parameters.length !== 1 : parameters.length < 2)
@@ -941,7 +1111,7 @@ export const createSmtlibReader = (
941
1111
  return parseSort(head, context, bindings);
942
1112
  }
943
1113
  if (decl === undefined) {
944
- if (THEORY_SORTS.has(head.text) && !isArray)
1114
+ if (THEORY_SORTS.has(head.text) && !isLackingSort(head.text))
945
1115
  throw new SmtUnsupportedError(`the sort ${head.text}`);
946
1116
  throw new SmtParseError(`unknown sort '${head.text}'`, head);
947
1117
  }
@@ -968,8 +1138,20 @@ export const createSmtlibReader = (
968
1138
  for (const item of (sexpr as SmtList).items.slice(1)) checkPsort(item, bindings);
969
1139
  };
970
1140
 
1141
+ // Z3 does not know the sorts of a theory that the logic lacks.
1142
+ const isLackingSort = (name: string) =>
1143
+ name === "Set"
1144
+ ? !hasArrays || !restricted.hasSetSort
1145
+ : ARRAY_SORT_NAMES.has(name)
1146
+ ? !hasArrays
1147
+ : name === "BitVec"
1148
+ ? !hasBv
1149
+ : SEQ_SORT_NAMES.has(name) || name === "Unicode"
1150
+ ? !hasSeq
1151
+ : FPA_SORT_NAMES.has(name) && !hasFpa;
1152
+
971
1153
  const isBuiltinParametricSort = (name: string) =>
972
- (hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && hasArrayExtensions))) ||
1154
+ (hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && restricted.hasSetSort))) ||
973
1155
  (hasSeq && (name === "Seq" || name === "RegEx")) ||
974
1156
  (hasFpa && FPA_SORT_NAMES.has(name));
975
1157
 
@@ -993,19 +1175,31 @@ export const createSmtlibReader = (
993
1175
  context: string,
994
1176
  bindings: ReadonlyMap<string, number> = NO_BINDINGS,
995
1177
  ): number => {
1178
+ if (sexpr.kind === ")")
1179
+ throw new SmtParseError(`${context} invalid sort, unexpected ')'`, sexpr);
996
1180
  if (sexpr.kind === "list") {
997
1181
  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");
1182
+ // parse_indexed_sort.
1183
+ const name = sexpr.items[1];
1184
+ if (!isSymbol(name))
1185
+ throw new SmtParseError("invalid indexed sort, symbol expected", name ?? sexpr.end);
1186
+ if (hasFpa && name.text === "FloatingPoint") return mkFloatSort(sexpr.items.slice(2), sexpr);
1187
+ const indices = sexpr.items.slice(2);
1188
+ if (isLackingSort(name.text) || !(THEORY_SORTS.has(name.text) || sortDecls.has(name.text)))
1189
+ throw new SmtParseError(`unknown sort '${name.text}'`, indices[0] ?? sexpr.end);
1190
+ if (name.text !== "BitVec") throw new SmtUnsupportedError("indexed sorts");
1191
+ for (const index of indices) {
1192
+ if (index.kind !== "numeral")
1193
+ throw new SmtParseError("invalid indexed sort, integer or ')' expected", index);
1194
+ if (!isUnsigned(index.text))
1195
+ throw new SmtParseError(
1196
+ "invalid indexed identifier, index is too big to fit in an unsigned machine integer",
1197
+ index,
1198
+ );
1199
+ }
1200
+ const width = indices[0];
1201
+ if (indices.length !== 1 || width.kind !== "numeral")
1202
+ throw new SmtParseError("expecting one integer parameter to bit-vector sort", sexpr.end);
1009
1203
  if (BigInt(width.text) === 0n)
1010
1204
  throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
1011
1205
  return manager.mkBvSort(Number(width.text));
@@ -1034,106 +1228,222 @@ export const createSmtlibReader = (
1034
1228
  const bits = FPA_SORT_NAMES.get(sexpr.text);
1035
1229
  return bits === undefined ? mkFloatSort([], sexpr) : manager.mkFpSort(bits[0], bits[1]);
1036
1230
  }
1037
- if (THEORY_SORTS.has(sexpr.text)) throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
1231
+ if (THEORY_SORTS.has(sexpr.text) && !isLackingSort(sexpr.text))
1232
+ throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
1038
1233
  throw new SmtParseError(
1039
1234
  `${context === "" ? "" : `${context}: `}unknown sort '${sexpr.text}'`,
1040
1235
  sexpr,
1041
1236
  );
1042
1237
  };
1043
1238
 
1044
- const lookup = (name: string) => {
1045
- for (let index = scopes.length - 1; index >= 0; index--) {
1046
- const binding = scopes[index].get(name);
1047
- if (binding !== undefined) return binding;
1239
+ const beginScope = () => localScopes.push(shadowedNames.length);
1240
+
1241
+ const insertLocal = (name: string, expr: number) => {
1242
+ shadowedNames.push(name);
1243
+ shadowedLocals.push(locals.get(name));
1244
+ locals.set(name, { expr, level: binders.depth });
1245
+ };
1246
+
1247
+ const endScope = () => {
1248
+ const start = localScopes.pop() ?? 0;
1249
+ for (let index = shadowedNames.length - 1; index >= start; index--) {
1250
+ const shadowed = shadowedLocals[index];
1251
+ if (shadowed === undefined) locals.delete(shadowedNames[index]);
1252
+ else locals.set(shadowedNames[index], shadowed);
1048
1253
  }
1049
- return undefined;
1254
+ shrink(shadowedNames, start);
1255
+ shrink(shadowedLocals, start);
1050
1256
  };
1051
1257
 
1052
- const getJoin = (args: number[]) => {
1053
- const argSorts = args.map((arg) => manager.sorts[arg]);
1054
- if (!argSorts.every(isArithSort)) return argSorts[0];
1055
- return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
1258
+ const pushRef = (stack: number[], expr: number) => {
1259
+ if (expr !== -1) manager.incRef(expr);
1260
+ stack.push(expr);
1056
1261
  };
1057
1262
 
1058
- const getDomainSort = (op: number, args: number[]) => {
1059
- if (op === OP_ITE) return getJoin(args.slice(1));
1060
- if (op === OP_EQ || op === OP_DISTINCT) return getJoin(args);
1061
- if (COERCING_OPS.has(op)) return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
1062
- if (op === OP_ABS || op === OP_TO_REAL || op === OP_TO_INT) return manager.sorts[args[0]];
1063
- if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
1263
+ // ref_vector::shrink, which releases from the new end on.
1264
+ const shrinkRefs = (stack: number[], size: number) => {
1265
+ for (let index = size; index < stack.length; index++)
1266
+ if (stack[index] !== -1) manager.decRef(stack[index]);
1267
+ shrink(stack, size);
1268
+ };
1269
+
1270
+ const releasePending = () => {
1271
+ for (const expr of pending) manager.decRef(expr);
1272
+ shrink(pending, 0);
1273
+ };
1274
+
1275
+ const protect = (exprs: number[]) => {
1276
+ for (const expr of exprs)
1277
+ if (manager.ids[expr] !== -1 && manager.getRefCount(expr) === 0) pushRef(pending, expr);
1278
+ shrink(exprs, 0);
1279
+ };
1280
+
1281
+ // push_local: var_shifter moves the free variables of a term that was bound under fewer binders.
1282
+ // Its cache holds the terms it makes, which replaceFreeVars rebuilds.
1283
+ const getLocalTerm = (local: Local) => {
1284
+ if (local.level === binders.depth) return local.expr;
1285
+ if (manager.kinds[local.expr] === KIND_VAR)
1286
+ return manager.mkVar(
1287
+ manager.values[local.expr] + binders.depth - local.level,
1288
+ manager.sorts[local.expr],
1289
+ );
1290
+ return replaceFreeVars(manager, local.expr, (variable, index, shift) =>
1291
+ manager.mkVar(index + shift + binders.depth - local.level, manager.sorts[variable]),
1292
+ );
1293
+ };
1294
+
1295
+ // basic_decl_plugin::join.
1296
+ const getJoin = (left: number, right: number, at: SExpr) => {
1297
+ if (left === right) return left;
1298
+ if (isArithSort(left) && isArithSort(right)) return left === SORT_REAL ? left : right;
1299
+ if (left === SORT_BOOL && isArithSort(right)) return right;
1300
+ if (right === SORT_BOOL && isArithSort(left)) return left;
1301
+ throw new SmtParseError(
1302
+ `Sorts ${manager.getSortName(left)} and ${manager.getSortName(right)} are incompatible`,
1303
+ at,
1304
+ );
1305
+ };
1306
+
1307
+ const getJoinOfArgs = (args: number[], at: SExpr) =>
1308
+ args.reduce((join, arg) => getJoin(join, manager.sorts[arg], at), manager.sorts[args[0]]);
1309
+
1310
+ // basic_decl_plugin::mk_func_decl and arith_decl_plugin::mk_func_decl: the sort of the arguments
1311
+ // that the declaration takes, the condition of ite aside, or -1 where the plugin makes none.
1312
+ const getDomainSort = (op: number, args: number[], at: SExpr) => {
1313
+ if (op === OP_ITE)
1314
+ return args.length === 3 ? getJoin(manager.sorts[args[1]], manager.sorts[args[2]], at) : -1;
1315
+ if (op === OP_EQ) return args.length >= 2 ? getJoinOfArgs(args, at) : -1;
1316
+ if (op === OP_DISTINCT) return args.length === 0 ? SORT_BOOL : getJoinOfArgs(args, at);
1317
+ if (manager.funcDecls[op].family === FAMILY_BASIC) return SORT_BOOL;
1318
+ if (COERCING_OPS.has(op))
1319
+ return args.some((arg) => manager.sorts[arg] === SORT_REAL) ? SORT_REAL : SORT_INT;
1064
1320
  if (op === OP_DIV || op === OP_IS_INT || REAL_FUNCTION_OPS.has(op)) return SORT_REAL;
1065
- return SORT_BOOL;
1321
+ if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
1322
+ return manager.sorts[args[0]] === SORT_REAL ? SORT_REAL : SORT_INT;
1066
1323
  };
1067
1324
 
1325
+ // ast_manager::coerce_to.
1068
1326
  const coerce = (arg: number, sort: number) => {
1069
1327
  const argSort = manager.sorts[arg];
1070
- if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
1071
- return sort === SORT_REAL
1072
- ? manager.mkApp(OP_TO_REAL, [arg], SORT_REAL)
1073
- : manager.mkApp(OP_TO_INT, [arg], SORT_INT);
1074
- };
1075
-
1076
- const mkApp = (decl: number, inputArgs: number[], at: SExpr, domainSort?: number) => {
1077
- const op = manager.funcDecls[decl].op;
1078
- const name = manager.funcDecls[decl].name;
1079
- const isUninterpreted =
1080
- op === OP_UNINTERPRETED ||
1081
- op === OP_FUN_DEFINED ||
1082
- manager.funcDecls[decl].family === FAMILY_DATATYPE;
1083
- const domain = manager.funcDecls[decl].domain;
1084
- const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
1085
- const getExpected = (index: number) =>
1086
- isUninterpreted ? domain[index] : op === OP_ITE && index === 0 ? SORT_BOOL : builtinSort;
1087
- const args = inputArgs.map((arg, index) =>
1088
- getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
1328
+ if (argSort === sort || !isArithSort(sort)) return arg;
1329
+ if (isArithSort(argSort))
1330
+ return sort === SORT_REAL
1331
+ ? manager.mkApp(OP_TO_REAL, [arg], SORT_REAL)
1332
+ : manager.mkApp(OP_TO_INT, [arg], SORT_INT);
1333
+ if (argSort !== SORT_BOOL) return arg;
1334
+ const one = manager.mkNumeralOfSort(Rational.of(1n), sort);
1335
+ return manager.mkApp(OP_ITE, [arg, one, manager.mkNumeralOfSort(Rational.of(0n), sort)], sort);
1336
+ };
1337
+
1338
+ // A declaration of the script has its own domain, and a builtin one takes domainSort.
1339
+ const getArity = (decl: number, numArgs: number, domainSort: number) =>
1340
+ domainSort === -1
1341
+ ? manager.funcDecls[decl].domain.length
1342
+ : decl === OP_DISTINCT
1343
+ ? numArgs
1344
+ : (ARITIES.get(decl) ?? 2);
1345
+
1346
+ const getExpectedSort = (decl: number, index: number, domainSort: number) =>
1347
+ domainSort === -1
1348
+ ? manager.funcDecls[decl].domain[index]
1349
+ : decl === OP_ITE && index === 0
1350
+ ? SORT_BOOL
1351
+ : domainSort;
1352
+
1353
+ const formatDecl = (decl: number, numArgs: number, domainSort: number) => {
1354
+ const domain = Array.from({ length: getArity(decl, numArgs, domainSort) }, (_unused, index) =>
1355
+ manager.getSortName(getExpectedSort(decl, index, domainSort)),
1089
1356
  );
1090
- const arity = ARITIES.get(op) ?? [1, Infinity];
1091
- const isArityOk = isUninterpreted
1092
- ? args.length === domain.length
1093
- : args.length >= arity[0] && args.length <= arity[1];
1094
- const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
1095
- const isWellSorted =
1096
- isArityOk &&
1097
- (!isBuiltinArith || isArithSort(builtinSort)) &&
1098
- args.every((arg, index) => manager.sorts[arg] === getExpected(index));
1099
- if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`, at);
1357
+ const range =
1358
+ domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort);
1359
+ return `(declare-fun ${String(manager.funcDecls[decl].name)} (${domain.join(" ")}) ${manager.getSortName(range)})`;
1360
+ };
1361
+
1362
+ // ast_manager::mk_app_core: coercion_needed, coerce_to and check_args.
1363
+ const mkAppCore = (decl: number, args: number[], at: SExpr, domainSort: number) => {
1364
+ const isAssociative = domainSort !== -1 && ASSOCIATIVE_OPS.has(decl);
1365
+ const isCoercing =
1366
+ (isAssociative || getArity(decl, args.length, domainSort) === args.length) &&
1367
+ args.some((arg, index) => {
1368
+ const expected = getExpectedSort(decl, index, domainSort);
1369
+ return isArithSort(expected) && expected !== manager.sorts[arg];
1370
+ });
1371
+ const coerced = isCoercing
1372
+ ? args.map((arg, index) => coerce(arg, getExpectedSort(decl, index, domainSort)))
1373
+ : args;
1374
+ for (let index = 0; index < coerced.length; index++) {
1375
+ const sort = manager.sorts[coerced[index]];
1376
+ if (sort !== getExpectedSort(decl, index, domainSort))
1377
+ throw new SmtParseError(
1378
+ `Sort mismatch at argument #${index + 1} for function ${formatDecl(decl, args.length, domainSort)} supplied sort is ${manager.getSortName(sort)}`,
1379
+ at,
1380
+ );
1381
+ }
1382
+ // Z3 keeps xor, / and div of fewer than two arguments until its rewriters make false or the
1383
+ // argument of them, which those of this port do not.
1384
+ if (
1385
+ coerced.length < 2 &&
1386
+ domainSort !== -1 &&
1387
+ (decl === OP_XOR || LEFT_ASSOCIATIVE_OPS.has(decl))
1388
+ )
1389
+ return coerced[0] ?? manager.falseExpr;
1100
1390
  return manager.mkApp(
1101
1391
  decl,
1102
- args,
1103
- isUninterpreted ? manager.funcDecls[decl].range : (RANGES.get(op) ?? builtinSort),
1392
+ coerced,
1393
+ domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort),
1104
1394
  );
1105
1395
  };
1106
1396
 
1107
- const mkChain = (op: number, args: number[], at: SExpr) => {
1108
- const domainSort = getDomainSort(op, args);
1397
+ // ast_manager::mk_app.
1398
+ const mkApp = (decl: number, args: number[], at: SExpr, domainSort = -1): number => {
1399
+ const isBuiltin = domainSort !== -1;
1400
+ const isAssociative = isBuiltin && ASSOCIATIVE_OPS.has(decl);
1401
+ const isLeftAssociative = isAssociative || (isBuiltin && LEFT_ASSOCIATIVE_OPS.has(decl));
1402
+ const isRightAssociative = isAssociative || (isBuiltin && decl === OP_IMPLIES);
1403
+ const isChainable = isBuiltin && CHAINABLE_DECLS.has(decl);
1404
+ if (
1405
+ getArity(decl, args.length, domainSort) !== args.length &&
1406
+ ((!isLeftAssociative && !isRightAssociative && !isChainable) ||
1407
+ (args.length < 2 && manager.funcDecls[decl].family === FAMILY_BASIC && !isAssociative))
1408
+ ) {
1409
+ const environment = { options: DEFAULT_PRINT_OPTIONS, isUsed, isClashing };
1410
+ // Z3 prints an error without the newlines that end it.
1411
+ throw new SmtParseError(
1412
+ `Wrong number of arguments (${args.length}) passed to function ${formatDecl(decl, args.length, domainSort)} ${args
1413
+ .map((arg) => `\narg: ${printExpr(manager, environment, arg)}\n`)
1414
+ .join("")}`.replace(/\n+$/, ""),
1415
+ at,
1416
+ );
1417
+ }
1418
+ if (args.length === 1 && isChainable) return manager.trueExpr;
1419
+ if (args.length <= 2 || (isBuiltin && FLAT_OPS.has(decl)))
1420
+ return mkAppCore(decl, args, at, domainSort);
1421
+ if (isRightAssociative)
1422
+ return args
1423
+ .slice(0, -2)
1424
+ .reduceRight(
1425
+ (right, left) => mkAppCore(decl, [left, right], at, domainSort),
1426
+ mkAppCore(decl, args.slice(-2), at, domainSort),
1427
+ );
1428
+ if (isLeftAssociative)
1429
+ return args
1430
+ .slice(2)
1431
+ .reduce(
1432
+ (left, right) => mkAppCore(decl, [left, right], at, domainSort),
1433
+ mkAppCore(decl, args.slice(0, 2), at, domainSort),
1434
+ );
1435
+ if (!isChainable) return mkAppCore(decl, args, at, domainSort);
1109
1436
  const pairs: number[] = [];
1110
- for (let index = 0; index + 1 < args.length; index++)
1111
- pairs.push(mkApp(op, [args[index], args[index + 1]], at, domainSort));
1112
- return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs, at);
1113
- };
1114
-
1115
- const rejectPattern = (message: string, at: SExpr) => {
1116
- if (!options.isIgnoringBadPatterns) throw new SmtParseError(message, at);
1117
- return undefined;
1437
+ for (let index = 1; index < args.length; index++)
1438
+ pairs.push(mkAppCore(decl, [args[index - 1], args[index]], at, domainSort));
1439
+ return mkApp(OP_AND, pairs, at, SORT_BOOL);
1118
1440
  };
1119
1441
 
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);
1132
- if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
1133
- return rejectPattern("invalid constant pattern", head);
1134
- if (head.kind !== "symbol")
1135
- throw new SmtParseError("invalid pattern, '(' or identifier expected", head);
1136
- return manager.mkPattern([parseTerm(sexpr)]);
1442
+ // ast_manager::mk_pattern.
1443
+ const mkPattern = (terms: number[], at: SExpr) => {
1444
+ if (terms.some((term) => manager.kinds[term] !== KIND_APP))
1445
+ throw new SmtParseError("patterns cannot be variables or quantifiers", at);
1446
+ return manager.mkPattern(terms);
1137
1447
  };
1138
1448
 
1139
1449
  const isValidPattern = (pattern: number, numDecls: number) => {
@@ -1158,151 +1468,90 @@ export const createSmtlibReader = (
1158
1468
  return manager.everyArg(pattern, isValid) && found.size === numDecls;
1159
1469
  };
1160
1470
 
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
- );
1166
- const scope = new Map<string, Binding>();
1167
- const names = declarations.map(
1168
- (declaration) => expectSymbol(declaration.items[0], message, declaration).text,
1169
- );
1170
- const varSorts = declarations.map((declaration, index) => {
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 });
1174
- return sort;
1175
- });
1176
- scopes.push(scope);
1471
+ // parse_sorted_vars: the variables are created the first declared with the largest index, and
1472
+ // the stack holds them. previousId is the identifier before the list.
1473
+ const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr, previousId: string) => {
1474
+ if (sexpr?.kind !== "list")
1475
+ throw new SmtParseError(
1476
+ `invalid list of sorted variables, '(' expected got ${getLastId(sexpr) ?? previousId}`,
1477
+ sexpr ?? at,
1478
+ );
1479
+ const names: string[] = [];
1480
+ const varSorts: number[] = [];
1481
+ for (const [index, declaration] of sexpr.items.entries()) {
1482
+ if (declaration.kind !== "list")
1483
+ throw new SmtParseError(
1484
+ `invalid sorted variable, '(' expected got ${getLastId(declaration) ?? getLastIdBefore(sexpr.items, index) ?? previousId}`,
1485
+ declaration,
1486
+ );
1487
+ const name = declaration.items[0];
1488
+ if (!isSymbol(name))
1489
+ throw new SmtParseError(
1490
+ "invalid sorted variable, symbol expected",
1491
+ name ?? declaration.end,
1492
+ );
1493
+ names.push(name.text);
1494
+ varSorts.push(parseSort(declaration.items[1] ?? declaration.end, "invalid sorted variables"));
1495
+ const extra = declaration.items[2];
1496
+ if (extra !== undefined)
1497
+ throw new SmtParseError(
1498
+ `invalid sorted variable, ')' expected got ${getLastId(extra) ?? getLastId(declaration.items[1]) ?? name.text}`,
1499
+ extra,
1500
+ );
1501
+ }
1502
+ beginScope();
1177
1503
  binders.depth += varSorts.length;
1504
+ for (const [index, sort] of varSorts.entries()) {
1505
+ const boundVar = manager.mkVar(varSorts.length - 1 - index, sort);
1506
+ pushRef(exprStack, boundVar);
1507
+ insertLocal(names[index], boundVar);
1508
+ }
1178
1509
  return { names, varSorts };
1179
1510
  };
1180
1511
 
1181
1512
  const unbindSortedVars = (count: number) => {
1182
- scopes.pop();
1513
+ endScope();
1183
1514
  binders.depth -= count;
1184
1515
  };
1185
1516
 
1186
- const parseQuantifier = (list: SmtList, kind: number) => {
1187
- if (list.items.length !== 3)
1517
+ // pop_quant_frame, up to the quantifier.
1518
+ const mkParsedQuantifier = (frame: QuantifierFrame) => {
1519
+ const list = frame.list;
1520
+ const numDecls = frame.varSorts.length;
1521
+ if (exprStack.length - frame.start !== numDecls + 1)
1188
1522
  throw new SmtParseError(
1189
1523
  "invalid quantified expression, syntax error: (forall|exists ((<symbol> <sort>)*) <expr>) expected",
1190
1524
  list.end,
1191
1525
  );
1192
- const bound = bindSortedVars(list.items[1], list);
1193
- const varSorts = bound.varSorts;
1194
- // parse_sorted_vars: the variables are created first, the first declared with the largest index,
1195
- // and the parser's stack holds them until the quantifier is created.
1196
- const boundVars = varSorts.map((sort, index) =>
1197
- manager.mkVar(varSorts.length - 1 - index, sort),
1198
- );
1199
- for (const boundVar of boundVars) manager.incRef(boundVar);
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
- );
1221
- const patterns: number[] = [];
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;
1230
- }
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);
1255
- // pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
1256
- // and the valid ones after.
1257
- let numKept = 0;
1258
- for (const pattern of patterns) {
1259
- if (!isValidPattern(pattern, varSorts.length)) {
1260
- rejectPattern("invalid pattern", list.end);
1526
+ let numKept = frame.patternStart;
1527
+ for (let index = frame.patternStart; index < patternStack.length; index++) {
1528
+ const pattern = patternStack[index];
1529
+ if (!isValidPattern(pattern, numDecls)) {
1530
+ if (!options.isIgnoringBadPatterns) throw new SmtParseError("invalid pattern", list.end);
1261
1531
  continue;
1262
1532
  }
1263
1533
  manager.incRef(pattern);
1264
- manager.decRef(patterns[numKept]);
1265
- patterns[numKept] = pattern;
1534
+ manager.decRef(patternStack[numKept]);
1535
+ patternStack[numKept] = pattern;
1266
1536
  numKept++;
1267
1537
  }
1268
- for (const removed of patterns.splice(numKept)) manager.decRef(removed);
1269
- if (patterns.length > 0 && noPatterns.length > 0)
1538
+ shrinkRefs(patternStack, numKept);
1539
+ const body = exprStack[exprStack.length - 1];
1540
+ if (frame.quantifierKind !== QUANTIFIER_LAMBDA && manager.sorts[body] !== SORT_BOOL)
1541
+ throw new SmtParseError("quantifier body must be a Boolean expression", list.end);
1542
+ if (patternStack.length > frame.patternStart && noPatternStack.length > frame.noPatternStart)
1270
1543
  throw new SmtParseError("simultaneous patterns and no-patterns not supported", list.end);
1271
- const quantifier = manager.mkQuantifier({
1272
- kind,
1273
- sorts: varSorts,
1274
- names: bound.names,
1544
+ return manager.mkQuantifier({
1545
+ kind: frame.quantifierKind,
1546
+ sorts: frame.varSorts,
1547
+ names: frame.names,
1275
1548
  body,
1276
- patterns,
1277
- noPatterns,
1278
- weight,
1279
- qid,
1280
- ...(skid === undefined ? {} : { skid }),
1549
+ patterns: patternStack.slice(frame.patternStart),
1550
+ noPatterns: noPatternStack.slice(frame.noPatternStart),
1551
+ weight: frame.weight,
1552
+ qid: frame.qid,
1553
+ ...(frame.skid === undefined ? {} : { skid: frame.skid }),
1281
1554
  });
1282
- for (const pattern of patterns) manager.decRef(pattern);
1283
- for (const noPattern of noPatterns) manager.decRef(noPattern);
1284
- for (const boundVar of boundVars) manager.decRef(boundVar);
1285
- return quantifier;
1286
- };
1287
-
1288
- const parseLet = (list: SmtList) => {
1289
- const message = "invalid let declaration, symbol expected";
1290
- const scope = new Map<string, Binding>();
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 });
1298
- }
1299
- scopes.push(scope);
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));
1302
- scopes.pop();
1303
- const result = exprs.at(-1);
1304
- if (result === undefined) throw new SmtParseError("invalid let expression", list.end);
1305
- return result;
1306
1555
  };
1307
1556
 
1308
1557
  const expandMacro = (macro: Macro, args: number[]) =>
@@ -1376,7 +1625,7 @@ export const createSmtlibReader = (
1376
1625
  const pair = [args[index], args[index + 1]];
1377
1626
  pairs.push(mkFpaAppOf(manager, getSignature(pair), pair));
1378
1627
  }
1379
- return mkApp(OP_AND, pairs, at);
1628
+ return mkApp(OP_AND, pairs, at, SORT_BOOL);
1380
1629
  };
1381
1630
 
1382
1631
  const isSeqOpName = (name: string) =>
@@ -1496,43 +1745,136 @@ export const createSmtlibReader = (
1496
1745
  return manager.mkAlgebraicNumeral(root);
1497
1746
  };
1498
1747
 
1499
- const parseBvNumeral = (list: SmtList) => {
1748
+ const isKnownOperator = (name: string) => BUILTIN_NAMES.has(name) || THEORY_OPERATOR.test(name);
1749
+
1750
+ // parse_indexed_identifier_core.
1751
+ const getIndexedName = (list: SmtList) => {
1500
1752
  const name = list.items[1];
1753
+ if (!isSymbol(name))
1754
+ throw new SmtParseError("invalid indexed identifier, symbol expected", name ?? list.end);
1755
+ for (const index of list.items.slice(2)) {
1756
+ if (index.kind === "string")
1757
+ throw new SmtParseError(
1758
+ "invalid indexed identifier, integer, identifier or '(' expected",
1759
+ index,
1760
+ );
1761
+ // parse_func_decl_ref of an index that is a symbol.
1762
+ if (
1763
+ index.kind === "symbol" &&
1764
+ name.text !== "is" &&
1765
+ !isUsed(index.text) &&
1766
+ !macros.has(index.text)
1767
+ )
1768
+ throw new SmtParseError(
1769
+ `invalid function declaration reference, unknown function ${index.text}`,
1770
+ index,
1771
+ );
1772
+ }
1773
+ return name;
1774
+ };
1775
+
1776
+ // parse_qualified_identifier_core on (as <identifier> <sort>), up to the sort.
1777
+ const parseQualifierSort = (list: SmtList) => {
1778
+ const target = list.items[1];
1779
+ if (target === undefined || (target.kind !== "symbol" && target.kind !== "list"))
1780
+ throw new SmtParseError(
1781
+ `invalid (indexed) identifier, '(_' or symbol expected got ${getLastId(target) ?? "as"}`,
1782
+ target ?? list.end,
1783
+ );
1784
+ if (target.kind === "list") {
1785
+ if (!isSymbol(target.items[0], "_"))
1786
+ throw new SmtParseError(
1787
+ "invalid indexed identifier, '_' expected",
1788
+ target.items[0] ?? target.end,
1789
+ );
1790
+ getIndexedName(target);
1791
+ }
1792
+ const sort = parseSort(list.items[2] ?? list.end, "Invalid qualified identifier");
1793
+ const extra = list.items[3];
1794
+ if (extra !== undefined)
1795
+ throw new SmtParseError(
1796
+ `invalid qualified identifier, ')' expected got ${getLastId(extra) ?? getLastIdBefore(list.items, 3) ?? "as"}`,
1797
+ extra,
1798
+ );
1799
+ return sort;
1800
+ };
1801
+
1802
+ // parse_qualified_name on (_ <symbol> <index>*). Z3 makes the term once it has read past the
1803
+ // closing parenthesis, where at is.
1804
+ const parseIndexedTerm = (list: SmtList, at: SExpr, range?: number) => {
1805
+ const name = getIndexedName(list);
1501
1806
  const indices = list.items.slice(2);
1502
- if (
1503
- isSymbol(name) &&
1504
- isSeqOpName(name.text) &&
1505
- indices.every((index) => index.kind === "numeral")
1506
- )
1807
+ const local = locals.get(name.text);
1808
+ if (local !== undefined) {
1809
+ if (indices.length > 0)
1810
+ throw new SmtParseError("invalid indexed identifier, symbol is a local declaration", at);
1811
+ return getLocalTerm(local);
1812
+ }
1813
+ const value = /^bv([0-9]+)$/.exec(name.text);
1814
+ if (value !== null) {
1815
+ const width = indices[0];
1816
+ const digits =
1817
+ indices.length !== 1
1818
+ ? "-1"
1819
+ : width.kind === "bitvector"
1820
+ ? `0${width.text.slice(1)}`
1821
+ : width.kind === "numeral"
1822
+ ? width.text
1823
+ : "-1";
1824
+ if (!isUnsigned(digits))
1825
+ throw new SmtParseError("invalid bit-vector constant, index expected", at);
1826
+ if (BigInt(digits) === 0n)
1827
+ throw new SmtParseError("bit-vector size must be greater than zero", at);
1828
+ return manager.mkBvNumeral(BigInt(value[1]), Number(BigInt(digits)));
1829
+ }
1830
+ const isNumbered = indices.every((index) => index.kind === "numeral");
1831
+ if (isNumbered && isSeqOpName(name.text))
1507
1832
  return mkSeqTerm(
1508
1833
  name.text,
1509
1834
  [],
1510
1835
  indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
1511
- list.end,
1836
+ at,
1512
1837
  );
1513
- if (
1514
- isSymbol(name) &&
1515
- isFpaOpName(name.text) &&
1516
- indices.every((index) => index.kind === "numeral")
1517
- ) {
1838
+ if (isNumbered && isFpaOpName(name.text)) {
1518
1839
  const signature = getFpaSignature(
1519
1840
  manager,
1520
1841
  FPA_OP_NAMES.get(name.text) ?? -1,
1521
1842
  indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
1522
1843
  [],
1523
1844
  );
1524
- if (typeof signature === "string")
1525
- throw new SmtParseError(signature, { line: list.end.line, column: list.end.column + 1 });
1845
+ if (typeof signature === "string") throw new SmtParseError(signature, at);
1526
1846
  return mkFpaAppOf(manager, signature, []);
1527
1847
  }
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));
1848
+ if (isKnownOperator(name.text) || !indices.every(isSimpleIndex))
1849
+ throw new SmtUnsupportedError("indexed identifiers");
1850
+ return parseApp(name, [], at, [], range);
1851
+ };
1852
+
1853
+ // parse_qualified_name.
1854
+ const parseQualifiedName = (list: SmtList) => {
1855
+ const at = list.follower ?? list.end;
1856
+ if (isSymbol(list.items[0], "_")) return parseIndexedTerm(list, at);
1857
+ const sort = parseQualifierSort(list);
1858
+ const target = list.items[1];
1859
+ const local = isSymbol(target) ? locals.get(target.text) : undefined;
1860
+ if (isSymbol(target) && local === undefined)
1861
+ return hasArrays && target.text === "const"
1862
+ ? mkArrayTerm(OP_CONST_ARRAY, [], [sort], at)
1863
+ : parseApp(target, [], at, [], sort);
1864
+ const term =
1865
+ local === undefined
1866
+ ? parseIndexedTerm(
1867
+ expectList(target, "invalid indexed identifier, '_' expected", list),
1868
+ at,
1869
+ sort,
1870
+ )
1871
+ : getLocalTerm(local);
1872
+ if (manager.sorts[term] !== sort)
1873
+ throw new SmtParseError(
1874
+ `sort mismatch in qualified identifier, expected: ${manager.getSortName(sort)}, got: ${manager.getSortName(manager.sorts[term])}`,
1875
+ at,
1876
+ );
1877
+ return term;
1536
1878
  };
1537
1879
 
1538
1880
  const mkArrayTerm = (op: number, inputArgs: number[], parameters: number[], at: SExpr) => {
@@ -1595,10 +1937,7 @@ export const createSmtlibReader = (
1595
1937
  sort === argSorts[index] || (isArithSort(sort) && isArithSort(argSorts[index])),
1596
1938
  ),
1597
1939
  );
1598
- const found =
1599
- candidates.find((decl) =>
1600
- manager.funcDecls[decl].domain.every((sort, index) => sort === argSorts[index]),
1601
- ) ?? candidates.at(-1);
1940
+ const found = candidates.find((decl) => hasSignature(decl, argSorts, -1)) ?? candidates.at(-1);
1602
1941
  if (found !== undefined) return mkApp(found, args, at);
1603
1942
  if (args.length === 0 || range !== undefined) return undefined;
1604
1943
  if (decls.length > 1) throwAmbiguousConstant(name, at);
@@ -1649,10 +1988,23 @@ export const createSmtlibReader = (
1649
1988
 
1650
1989
  const mkIsApp = (constructorName: SmtToken, args: number[], at: SExpr) => {
1651
1990
  const declared = findFuncDecl(constructorName);
1652
- if (declared !== undefined) return mkApp(getConstructorIs(manager, declared), args, at);
1991
+ // datatype::decl::plugin::mk_is.
1992
+ if (declared !== undefined) {
1993
+ if (args.length !== 1) throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
1994
+ if (!manager.isDatatypeSort(manager.sorts[args[0]]))
1995
+ throw new SmtParseError(
1996
+ "invalid parameter to datatype function u().is_datatype(domain[0])",
1997
+ at,
1998
+ );
1999
+ if (manager.sorts[args[0]] !== manager.funcDecls[declared].range)
2000
+ throw new SmtParseError("invalid sort argument passed to recognizer", at);
2001
+ if (manager.funcDecls[declared].op !== OP_DT_CONSTRUCTOR)
2002
+ throw new SmtParseError("expecting constructor argument to recognizer", at);
2003
+ return manager.mkApp(getConstructorIs(manager, declared), args, SORT_BOOL);
2004
+ }
1653
2005
  const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
1654
2006
  if (argSort === -1 || !manager.isDatatypeSort(argSort))
1655
- throw new SmtUnsupportedError("the operator is");
2007
+ throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
1656
2008
  const constructor = getDatatypeConstructors(manager, argSort).find(
1657
2009
  (decl) => manager.funcDecls[decl].name === constructorName.text,
1658
2010
  );
@@ -1671,9 +2023,23 @@ export const createSmtlibReader = (
1671
2023
  `invalid function declaration reference, unknown function ${accessorName.text}`,
1672
2024
  accessorName,
1673
2025
  );
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);
2026
+ // datatype::decl::plugin::mk_update_field.
2027
+ if (args.length !== 2)
2028
+ throw new SmtParseError("invalid number of arguments for datatype field update", at);
2029
+ const funcDecl = manager.funcDecls[accessor];
2030
+ if (funcDecl.op !== OP_DT_ACCESSOR)
2031
+ throw new SmtParseError(
2032
+ "datatype field update requires a datatype accessor as the second argument",
2033
+ at,
2034
+ );
2035
+ if (funcDecl.domain[0] !== manager.sorts[args[0]])
2036
+ throw new SmtParseError("first argument to field update should be a data-type", at);
2037
+ if (funcDecl.range !== manager.sorts[args[1]])
2038
+ throw new SmtParseError(
2039
+ `second argument to field update should be ${manager.getSortName(funcDecl.range)} instead of ${manager.getSortName(manager.sorts[args[1]])}`,
2040
+ at,
2041
+ );
2042
+ return manager.mkApp(mkUpdateField(manager, accessor), args, funcDecl.domain[0]);
1677
2043
  };
1678
2044
 
1679
2045
  const getUnknownConstantMessage = (name: string, args: number[], range: number | undefined) => {
@@ -1706,14 +2072,7 @@ export const createSmtlibReader = (
1706
2072
  throw new SmtUnsupportedError("the declaration reference");
1707
2073
  const domain = domainList.items.map((item) => parseSort(item, "Invalid function name"));
1708
2074
  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
- );
2075
+ const declared = funcs.get(name.text)?.find((decl) => hasSignature(decl, domain, range));
1717
2076
  if (declared !== undefined) return { decl: declared, domain, range };
1718
2077
  const builtin = CHAINABLE_OPS.get(name.text) ?? BUILTIN_OPS.get(name.text);
1719
2078
  if (builtin === undefined)
@@ -1752,10 +2111,11 @@ export const createSmtlibReader = (
1752
2111
  ) => {
1753
2112
  const name = head.text;
1754
2113
  // 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)
2114
+ const local = locals.get(name);
2115
+ if (args.length > 0 && local !== undefined)
1756
2116
  return args.reduce(
1757
2117
  (array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], at),
1758
- parseLeaf(head),
2118
+ getLocalTerm(local),
1759
2119
  );
1760
2120
  if (indices.length > 0)
1761
2121
  return isFpaOpName(name)
@@ -1764,19 +2124,31 @@ export const createSmtlibReader = (
1764
2124
  ? mkSeqTerm(name, args, indices, at)
1765
2125
  : mkBvApp(name, args, indices, at);
1766
2126
  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])
2127
+ // macros_find: a macro takes its own sorts, and Int for Real or Real for Int. Any other
2128
+ // application leaves the name to a declaration.
2129
+ if (
2130
+ macro !== undefined &&
2131
+ macro.domain.length === args.length &&
2132
+ args.every(
2133
+ (arg, index) =>
2134
+ manager.sorts[arg] === macro.domain[index] ||
2135
+ (isArithSort(manager.sorts[arg]) && isArithSort(macro.domain[index])),
1773
2136
  )
1774
- throw new SmtParseError(`ill-sorted application of ${name}`, at);
1775
- return expandMacro(macro, coerced);
1776
- }
2137
+ )
2138
+ return expandMacro(
2139
+ macro,
2140
+ args.map((arg, index) => coerce(arg, macro.domain[index])),
2141
+ );
1777
2142
  const decls = funcs.get(name);
1778
2143
  const declared = decls === undefined ? undefined : mkDeclaredApp(name, decls, args, range, at);
1779
2144
  if (declared !== undefined) return declared;
2145
+ // cmd_context::mk_app: a constant that starts with #f is a finite-field literal.
2146
+ if (args.length === 0 && name.startsWith("#f")) {
2147
+ if (!FF_LITERAL.test(name))
2148
+ throw new SmtParseError("invalid finite-field literal, expected #f<integer>m<prime>", at);
2149
+ if (!restricted.hasFf) throw new SmtParseError("logic does not support finite fields", at);
2150
+ throw new SmtUnsupportedError("finite-field literals");
2151
+ }
1780
2152
  if (isSeqOpName(name)) return mkSeqTerm(name, args, indices, at, range);
1781
2153
  if (range !== undefined)
1782
2154
  throw new SmtParseError(getUnknownConstantMessage(name, args, range), at);
@@ -1791,56 +2163,30 @@ export const createSmtlibReader = (
1791
2163
  const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
1792
2164
  if (isTranscendental && transcendentalOp === undefined)
1793
2165
  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));
2166
+ const named =
2167
+ builtin === "~"
2168
+ ? OP_UMINUS
2169
+ : (CHAINABLE_OPS.get(builtin) ?? BUILTIN_OPS.get(builtin) ?? transcendentalOp);
1797
2170
  if (
1798
2171
  args.length === 0 &&
1799
- arithOp !== undefined &&
1800
- manager.funcDecls[arithOp].family === FAMILY_ARITH
2172
+ named !== undefined &&
2173
+ manager.funcDecls[named].family === FAMILY_ARITH
1801
2174
  )
1802
2175
  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]);
2176
+ // arith_decl_plugin::fix_kind.
2177
+ const op = named === OP_SUB && args.length === 1 ? OP_UMINUS : named;
2178
+ const domainSort = op === undefined ? -1 : getDomainSort(op, args, at);
2179
+ if (op !== undefined && domainSort !== -1) return mkApp(op, args, at, domainSort);
2180
+ if (op === undefined && (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name)))
2181
+ throw new SmtUnsupportedError(`the operator ${name}`);
2182
+ const instance = mkDatatypeInstanceApp(name, args, at);
2183
+ if (instance !== undefined) return instance;
2184
+ throw new SmtParseError(getUnknownConstantMessage(name, args, undefined), at);
1839
2185
  };
1840
2186
 
1841
- const parseLeaf = (sexpr: SExpr): number => {
2187
+ const parseLeaf = (sexpr: SmtToken): number => {
1842
2188
  if (sexpr.kind === "numeral")
1843
- return isNumeralAsReal
2189
+ return restricted.isNumeralAsReal
1844
2190
  ? manager.mkRealNumeral(Rational.of(BigInt(sexpr.text), 1n))
1845
2191
  : manager.mkNumeral(BigInt(sexpr.text));
1846
2192
  if (sexpr.kind === "decimal") {
@@ -1859,222 +2205,452 @@ export const createSmtlibReader = (
1859
2205
  }
1860
2206
  if (sexpr.kind === "string") return manager.mkString(parseZstring(sexpr.text, manager.maxChar));
1861
2207
  if (sexpr.kind === "symbol") {
2208
+ const local = locals.get(sexpr.text);
2209
+ if (local !== undefined) return getLocalTerm(local);
1862
2210
  if (sexpr.text === "true") return manager.trueExpr;
1863
2211
  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);
1867
- // Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
1868
- // holds the terms it makes, but this parser holds no references, so it rebuilds the binding
1869
- // with replaceFreeVars.
1870
- if (binding !== undefined)
1871
- return binders.depth === binding.depth
1872
- ? binding.expr
1873
- : replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
1874
- manager.mkVar(index + shift + binders.depth - binding.depth, manager.sorts[variable]),
1875
- );
1876
2212
  return parseApp(sexpr, [], sexpr);
1877
2213
  }
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),
2214
+ throw new SmtParseError(
2215
+ sexpr.kind === "keyword"
2216
+ ? "invalid expression, unexpected keyword"
2217
+ : "invalid expression, unexpected ')'",
2218
+ sexpr,
1907
2219
  );
1908
2220
  };
1909
2221
 
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);
1915
- };
1916
-
1917
- const parseTerm = (sexpr: SExpr): number => {
1918
- const frames: ApplicationFrame[] = [];
1919
- const results: number[] = [];
1920
- const enter = (current: SExpr) => {
2222
+ // name_expr and cmd_context::insert of a named term. Z3 reports an error at the token after the
2223
+ // name.
2224
+ const nameExpr = (expr: number, name: string, at: SExpr) => {
2225
+ if (manager.freeVarBounds[expr] > 0)
2226
+ throw new SmtParseError("invalid named expression, expression contains free variables", at);
2227
+ if (macros.get(name)?.domain.length === 0)
2228
+ throw new SmtParseError("named expression already defined", at);
2229
+ if ((funcs.get(name) ?? []).some((decl) => hasSignature(decl, [], manager.sorts[expr])))
2230
+ throw new SmtParseError(
2231
+ `invalid named expression, declaration already defined with this name ${name}`,
2232
+ at,
2233
+ );
2234
+ manager.incRef(expr);
2235
+ lastNamed.name = name;
2236
+ lastNamed.expr = expr;
2237
+ manager.mkMacro(name, expr);
2238
+ declare(macros, name, { domain: [], range: manager.sorts[expr], body: expr });
2239
+ };
2240
+
2241
+ // push_app_frame's parse_qualified_identifier_core, on a head that is (_ <symbol> <index>*) or
2242
+ // (as <identifier> <sort>).
2243
+ const parseQualifiedHead = (list: SmtList, head: SmtList): QualifiedHead => {
2244
+ if (isSymbol(head.items[0], "as")) {
2245
+ const range = parseQualifierSort(head);
2246
+ const target = head.items[1];
2247
+ if (!isSymbol(target)) throw new SmtUnsupportedError("indexed and qualified identifiers");
2248
+ return {
2249
+ head: target,
2250
+ indices: [],
2251
+ build:
2252
+ hasArrays && target.text === "const"
2253
+ ? (args) => mkArrayTerm(OP_CONST_ARRAY, args, [range], list.end)
2254
+ : (args) => parseApp(target, args, list.end, [], range),
2255
+ };
2256
+ }
2257
+ const name = getIndexedName(head);
2258
+ const indices = head.items.slice(2);
2259
+ const indexed = indices[0];
2260
+ if (hasArrays && hasArrayExtensions && name.text === "map" && indices.length === 1) {
2261
+ const mapped = parseFuncDeclRef(indexed);
2262
+ return { head: name, indices: [], build: (args) => mkMapTerm(mapped, args, list.end) };
2263
+ }
2264
+ if ((name.text === "is" || name.text === "update-field") && indices.length === 1) {
2265
+ if (!isSymbol(indexed)) throw new SmtUnsupportedError("indexed and qualified identifiers");
2266
+ return {
2267
+ head: name,
2268
+ indices: [],
2269
+ build: (args) =>
2270
+ name.text === "is"
2271
+ ? mkIsApp(indexed, args, list.end)
2272
+ : mkUpdateFieldApp(indexed, args, list.end),
2273
+ };
2274
+ }
2275
+ const isNumbered = indices.every((index) => index.kind === "numeral");
2276
+ if (isNumbered && isPbOpName(name.text)) {
2277
+ const parameters = indices.map((index) =>
2278
+ Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
2279
+ );
2280
+ return {
2281
+ head: name,
2282
+ indices: [],
2283
+ build: (args) => mkPbTerm(name.text, args, parameters, list.end),
2284
+ };
2285
+ }
2286
+ if (isNumbered && (isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)))
2287
+ return {
2288
+ head: name,
2289
+ indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
2290
+ };
2291
+ // cmd_context::mk_app finds a name that no theory knows among the declarations, whatever its
2292
+ // indices are.
2293
+ if (isKnownOperator(name.text) || !indices.every(isSimpleIndex))
2294
+ throw new SmtUnsupportedError("indexed and qualified identifiers");
2295
+ return { head: name, indices: [] };
2296
+ };
2297
+
2298
+ // parse_expr. Z3 leaves the term on its stack until the command ends. A tail term is one whose
2299
+ // value is the value of the whole: it stays off the stack, in parsed, so that the caller of
2300
+ // parseTerm can have a term that nothing else holds without a reference of the parser's.
2301
+ const runTerm = (sexpr: SExpr, isRootTail: boolean) => {
2302
+ const root = sexpr.kind === "list" ? sexpr.root : undefined;
2303
+ if (root === undefined || root === parsed.root) protect(floating);
2304
+ else {
2305
+ releasePending();
2306
+ shrink(floating, 0);
2307
+ parsed.root = root;
2308
+ }
2309
+ protect(unrooted);
2310
+ const frames: TermFrame[] = [];
2311
+ // The value of a frame replaces what the frame left on the stack. Z3 holds it in an expr_ref
2312
+ // meanwhile.
2313
+ const deliver = (expr: number, isTail: boolean, start: number) => {
2314
+ const isOwned = !isTail || manager.getRefCount(expr) > 0;
2315
+ if (isOwned) manager.incRef(expr);
2316
+ shrinkRefs(exprStack, start);
2317
+ if (!isTail) {
2318
+ exprStack.push(expr);
2319
+ return;
2320
+ }
2321
+ parsed.expr = expr;
2322
+ parsed.isOwned = isOwned;
2323
+ };
2324
+ // push_pattern_frame.
2325
+ const enterPattern = (value: SExpr, frame: AttributeFrame) => {
2326
+ if (value.kind !== "list") {
2327
+ if (!options.isIgnoringBadPatterns)
2328
+ throw new SmtParseError("invalid pattern, '(' expected", value);
2329
+ // Z3 skips a bad pattern as an s-expression, which cannot start with ')'.
2330
+ if (value.kind === ")")
2331
+ throw new SmtParseError("invalid s-expression, unexpected ')'", value);
2332
+ frame.next++;
2333
+ exprStack.push(-1);
2334
+ return;
2335
+ }
2336
+ frame.next++;
2337
+ const first = value.items[0];
2338
+ if (first === undefined) {
2339
+ exprStack.push(-1);
2340
+ return;
2341
+ }
2342
+ if (first.kind === "list") {
2343
+ frames.push({ kind: "pattern", list: value, start: exprStack.length, next: 0 });
2344
+ return;
2345
+ }
2346
+ const decl = first.text === "true" || first.text === "false" ? -1 : getFirstFunc(first.text);
2347
+ if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0)) {
2348
+ if (!options.isIgnoringBadPatterns)
2349
+ throw new SmtParseError("invalid constant pattern", first);
2350
+ exprStack.push(-1);
2351
+ return;
2352
+ }
2353
+ if (first.kind !== "symbol")
2354
+ throw new SmtParseError("invalid pattern, '(' or identifier expected", first);
2355
+ frames.push({
2356
+ kind: "application",
2357
+ list: value,
2358
+ head: first,
2359
+ indices: [],
2360
+ isTail: false,
2361
+ start: exprStack.length,
2362
+ next: 1,
2363
+ });
2364
+ };
2365
+ const enter = (current: SExpr, isTail: boolean) => {
1921
2366
  if (current.kind !== "list") {
1922
- results.push(parseLeaf(current));
2367
+ deliver(parseLeaf(current), isTail, exprStack.length);
1923
2368
  return;
1924
2369
  }
1925
2370
  const head = current.items[0];
1926
- if (head === undefined)
1927
- throw new SmtParseError("invalid expression, unexpected ')'", current.end);
2371
+ if (head === undefined || (head.kind !== "symbol" && head.kind !== "list"))
2372
+ throw new SmtParseError("invalid expression, '(' or symbol expected", head ?? current.end);
1928
2373
  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
- )
2374
+ // push_app_frame: Z3 reads a head that is neither indexed nor qualified as a term.
2375
+ if (isSymbol(head.items[0], "lambda"))
2023
2376
  throw new SmtUnsupportedError("indexed and qualified identifiers");
2377
+ frames.push(
2378
+ isSymbol(head.items[0], "_") || isSymbol(head.items[0], "as")
2379
+ ? {
2380
+ kind: "application",
2381
+ list: current,
2382
+ ...parseQualifiedHead(current, head),
2383
+ isTail,
2384
+ start: exprStack.length,
2385
+ next: 1,
2386
+ }
2387
+ : { kind: "selection", list: current, isTail, start: exprStack.length, next: 0 },
2388
+ );
2389
+ return;
2390
+ }
2391
+ if (head.text === "_" || head.text === "as") {
2392
+ deliver(parseQualifiedName(current), isTail, exprStack.length);
2393
+ return;
2394
+ }
2395
+ if (head.text === "root-obj") {
2396
+ deliver(parseRootObj(current), isTail, exprStack.length);
2397
+ return;
2398
+ }
2399
+ if (head.text === "match") throw new SmtUnsupportedError("the expression match");
2400
+ if (head.text === "let") {
2401
+ const bindings = current.items[1];
2402
+ if (bindings?.kind !== "list")
2403
+ throw new SmtParseError(
2404
+ `invalid let declaration, '(' expected got ${getLastId(bindings) ?? "let"}`,
2405
+ bindings ?? current.end,
2406
+ );
2024
2407
  frames.push({
2025
- head: name,
2026
- indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
2408
+ kind: "let",
2027
2409
  list: current,
2028
- start: results.length,
2029
- next: 1,
2410
+ bindings,
2411
+ names: [],
2412
+ isInDecls: true,
2413
+ isTail,
2414
+ start: exprStack.length,
2415
+ next: 0,
2030
2416
  });
2031
2417
  return;
2032
2418
  }
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
- );
2419
+ if (head.text === "!") {
2420
+ const parent = frames[frames.length - 1];
2421
+ frames.push({
2422
+ kind: "attribute",
2423
+ list: current,
2424
+ quantifier: parent?.kind === "quantifier" ? parent : undefined,
2425
+ lastKeyword: "",
2426
+ isTail,
2427
+ start: exprStack.length,
2428
+ next: 1,
2429
+ });
2050
2430
  return;
2051
2431
  }
2052
- if (head.text === "root-obj") {
2053
- results.push(parseRootObj(current));
2432
+ const quantifierKind = QUANTIFIER_KINDS.get(head.text);
2433
+ if (quantifierKind === undefined) {
2434
+ frames.push({
2435
+ kind: "application",
2436
+ list: current,
2437
+ head,
2438
+ indices: [],
2439
+ isTail,
2440
+ start: exprStack.length,
2441
+ next: 1,
2442
+ });
2054
2443
  return;
2055
2444
  }
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 });
2445
+ // push_quant_frame.
2446
+ const start = exprStack.length;
2447
+ const bound = bindSortedVars(current.items[1], current.end, head.text);
2448
+ if (bound.varSorts.length === 0)
2449
+ throw new SmtParseError(
2450
+ "invalid quantifier, list of sorted variables is empty",
2451
+ current.items[2] ?? current.end,
2452
+ );
2453
+ frames.push({
2454
+ kind: "quantifier",
2455
+ list: current,
2456
+ quantifierKind,
2457
+ names: bound.names,
2458
+ varSorts: bound.varSorts,
2459
+ weight: 1,
2460
+ qid: "",
2461
+ skid: undefined,
2462
+ isTail,
2463
+ start,
2464
+ patternStart: patternStack.length,
2465
+ noPatternStart: noPatternStack.length,
2466
+ next: 2,
2467
+ });
2061
2468
  };
2062
- enter(sexpr);
2469
+ enter(sexpr, isRootTail);
2063
2470
  while (frames.length > 0) {
2064
2471
  const frame = frames[frames.length - 1];
2065
- if (frame.next < frame.list.items.length) {
2066
- enter(frame.list.items[frame.next++]);
2472
+ if (frame.kind === "let") {
2473
+ if (frame.isInDecls) {
2474
+ const declaration = frame.bindings.items[frame.next];
2475
+ if (declaration !== undefined) {
2476
+ // push_let_decl_frame.
2477
+ if (declaration.kind !== "list")
2478
+ throw new SmtParseError(
2479
+ `invalid let declaration, '(' expected got ${getLastId(declaration) ?? getLastIdBefore(frame.bindings.items, frame.next) ?? "let"}`,
2480
+ declaration,
2481
+ );
2482
+ const name = declaration.items[0];
2483
+ if (!isSymbol(name)) throw new SmtParseError(LET_MESSAGE, name ?? declaration.end);
2484
+ frame.names.push(name.text);
2485
+ frame.next++;
2486
+ frames.push({ kind: "let-decl", list: declaration, next: 1 });
2487
+ continue;
2488
+ }
2489
+ // pop_let_frame at the end of the declarations.
2490
+ if (frame.names.length !== exprStack.length - frame.start)
2491
+ throw new SmtParseError("malformed let expression", frame.bindings.end);
2492
+ beginScope();
2493
+ for (const [index, name] of frame.names.entries())
2494
+ insertLocal(name, exprStack[frame.start + index]);
2495
+ frame.isInDecls = false;
2496
+ frame.next = 2;
2497
+ continue;
2498
+ }
2499
+ const body = frame.list.items[frame.next];
2500
+ if (body !== undefined) {
2501
+ frame.next++;
2502
+ enter(body, frame.isTail && frame.next === frame.list.items.length);
2503
+ continue;
2504
+ }
2505
+ frames.pop();
2506
+ // Z3 takes the last expression on its stack, so a let without a body is its last binding.
2507
+ if (frame.isTail && frame.list.items.length > 2) shrinkRefs(exprStack, frame.start);
2508
+ else if (exprStack.length === frame.start)
2509
+ throw new SmtParseError("invalid let expression", frame.list.end);
2510
+ else deliver(exprStack[exprStack.length - 1], frame.isTail, frame.start);
2511
+ endScope();
2512
+ continue;
2513
+ }
2514
+ const items = frame.list.items;
2515
+ if (frame.kind === "attribute") {
2516
+ // consume_attributes.
2517
+ if (exprStack.length === frame.start) {
2518
+ if (frame.next >= items.length)
2519
+ throw new SmtParseError("invalid expression", frame.list.end);
2520
+ enter(items[frame.next++], false);
2521
+ continue;
2522
+ }
2523
+ // process_last_symbol.
2524
+ const last = exprStack[exprStack.length - 1];
2525
+ if (frame.lastKeyword === ":pattern") {
2526
+ const at = items[frame.next] ?? frame.list.end;
2527
+ if (last === -1 && !options.isIgnoringBadPatterns)
2528
+ throw new SmtParseError("invalid empty pattern", at);
2529
+ if (last !== -1)
2530
+ pushRef(
2531
+ patternStack,
2532
+ manager.kinds[last] === KIND_APP && manager.decls[last] === OP_PATTERN
2533
+ ? last
2534
+ : mkPattern([last], at),
2535
+ );
2536
+ shrinkRefs(exprStack, exprStack.length - 1);
2537
+ } else if (frame.lastKeyword === ":no-pattern") {
2538
+ pushRef(noPatternStack, last);
2539
+ shrinkRefs(exprStack, exprStack.length - 1);
2540
+ }
2541
+ frame.lastKeyword = "";
2542
+ if (frame.next >= items.length) {
2543
+ frames.pop();
2544
+ if (frame.isTail) deliver(exprStack[exprStack.length - 1], true, frame.start);
2545
+ continue;
2546
+ }
2547
+ while (frame.next < items.length && frame.lastKeyword === "") {
2548
+ const keyword = items[frame.next];
2549
+ if (keyword.kind !== "keyword")
2550
+ throw new SmtParseError("invalid attributed expression, keyword expected", keyword);
2551
+ const value = items[frame.next + 1] ?? frame.list.end;
2552
+ const annotated = exprStack[exprStack.length - 1];
2553
+ const quantifier = frame.quantifier;
2554
+ if (keyword.text === ":named") {
2555
+ if (!isSymbol(value))
2556
+ throw new SmtParseError("invalid attribute value, symbol expected", value);
2557
+ nameExpr(annotated, value.text, items[frame.next + 2] ?? frame.list.end);
2558
+ frame.next += 2;
2559
+ } else if (keyword.text === ":lblpos" || keyword.text === ":lblneg") {
2560
+ if (!isSymbol(value))
2561
+ throw new SmtParseError("invalid attribute value, symbol expected", value);
2562
+ if (manager.sorts[annotated] !== SORT_BOOL)
2563
+ throw new SmtParseError(
2564
+ "invalid labeled expression, expression must have Bool sort",
2565
+ value,
2566
+ );
2567
+ deliver(
2568
+ manager.mkLabel(keyword.text === ":lblpos", [value.text], annotated),
2569
+ false,
2570
+ exprStack.length - 1,
2571
+ );
2572
+ frame.next += 2;
2573
+ } else if (!QUANTIFIER_ATTRIBUTES.has(keyword.text)) {
2574
+ // Z3 warns of an unknown attribute and skips its value as an s-expression.
2575
+ if (value.kind === ")")
2576
+ throw new SmtParseError("invalid s-expression, unexpected ')'", value);
2577
+ frame.next += 2;
2578
+ } else if (quantifier === undefined)
2579
+ throw new SmtParseError("invalid attribute, not in the scope of a quantifier", keyword);
2580
+ else if (keyword.text === ":weight") {
2581
+ // check_int, and curr_unsigned.
2582
+ if (value.kind !== "numeral")
2583
+ throw new SmtParseError("invalid weight attribute, integer expected", value);
2584
+ if (!isUnsigned(value.text))
2585
+ throw new SmtParseError(
2586
+ "invalid indexed identifier, index is too big to fit in an unsigned machine integer",
2587
+ value,
2588
+ );
2589
+ quantifier.weight = Number(value.text);
2590
+ frame.next += 2;
2591
+ } else if (keyword.text === ":skolemid" || keyword.text === ":qid") {
2592
+ if (!isSymbol(value))
2593
+ throw new SmtParseError("invalid attribute value, symbol expected", value);
2594
+ if (keyword.text === ":qid") quantifier.qid = value.text;
2595
+ else quantifier.skid = value.text;
2596
+ frame.next += 2;
2597
+ } else {
2598
+ frame.lastKeyword = keyword.text;
2599
+ frame.next++;
2600
+ if (keyword.text === ":pattern") enterPattern(value, frame);
2601
+ else if (value.kind === ")")
2602
+ throw new SmtParseError("invalid expression, unexpected input", value);
2603
+ else enter(items[frame.next++], false);
2604
+ }
2605
+ }
2606
+ continue;
2607
+ }
2608
+ if (frame.next < items.length) {
2609
+ enter(items[frame.next++], false);
2067
2610
  continue;
2068
2611
  }
2069
2612
  frames.pop();
2070
- if (frame.list.items.length === 1)
2613
+ if (frame.kind === "let-decl") continue;
2614
+ if (frame.kind === "pattern") {
2615
+ deliver(mkPattern(exprStack.slice(frame.start), frame.list.end), false, frame.start);
2616
+ continue;
2617
+ }
2618
+ if (frame.kind === "quantifier") {
2619
+ // pop_quant_frame.
2620
+ deliver(mkParsedQuantifier(frame), frame.isTail, frame.start);
2621
+ shrinkRefs(patternStack, frame.patternStart);
2622
+ shrinkRefs(noPatternStack, frame.noPatternStart);
2623
+ unbindSortedVars(frame.varSorts.length);
2624
+ continue;
2625
+ }
2626
+ // pop_app_frame.
2627
+ const args = exprStack.slice(frame.start);
2628
+ if (args.length < (frame.kind === "selection" ? 2 : 1))
2071
2629
  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),
2630
+ deliver(
2631
+ frame.kind === "selection"
2632
+ ? args
2633
+ .slice(1)
2634
+ .reduce(
2635
+ (array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], frame.list.end),
2636
+ args[0],
2637
+ )
2638
+ : (frame.build?.(args) ?? parseApp(frame.head, args, frame.list.end, frame.indices)),
2639
+ frame.isTail,
2640
+ frame.start,
2075
2641
  );
2076
2642
  }
2077
- return results[0];
2643
+ };
2644
+
2645
+ const parseTerm = (sexpr: SExpr) => {
2646
+ runTerm(sexpr, true);
2647
+ const expr = parsed.expr;
2648
+ parsed.expr = -1;
2649
+ if (!parsed.isOwned)
2650
+ (sexpr.kind === "list" && sexpr.root !== undefined ? floating : unrooted).push(expr);
2651
+ else if (manager.getRefCount(expr) > 1) manager.decRef(expr);
2652
+ else pending.push(expr);
2653
+ return expr;
2078
2654
  };
2079
2655
 
2080
2656
  const parseDomain = (sexpr: SExpr | undefined, at: SExpr) => {
@@ -2352,14 +2928,15 @@ export const createSmtlibReader = (
2352
2928
  );
2353
2929
  };
2354
2930
 
2355
- // parse_rec_fun_decl: the variables are bound only while the range is parsed.
2931
+ // parse_rec_fun_decl: the variables are bound only while the range is parsed, and Z3 holds them
2932
+ // until the command ends, as the stack does here.
2356
2933
  const declareRecFun = (items: SExpr[], at: SExpr) => {
2357
2934
  const symbol = expectSymbol(
2358
2935
  items[0],
2359
2936
  "invalid function/constant definition, symbol expected",
2360
2937
  at,
2361
2938
  );
2362
- const bound = bindSortedVars(items[1], at);
2939
+ const bound = bindSortedVars(items[1], at, symbol.text);
2363
2940
  const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
2364
2941
  unbindSortedVars(bound.varSorts.length);
2365
2942
  return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
@@ -2367,16 +2944,19 @@ export const createSmtlibReader = (
2367
2944
 
2368
2945
  // parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
2369
2946
  const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
2370
- const bound = bindSortedVars(variables, body);
2371
- const parsed = parseTerm(body);
2947
+ const start = exprStack.length;
2948
+ const bound = bindSortedVars(variables, body, "");
2949
+ runTerm(body, false);
2950
+ const parsedBody = exprStack[exprStack.length - 1];
2372
2951
  unbindSortedVars(bound.varSorts.length);
2373
2952
  const range = manager.funcDecls[decl].range;
2374
- if (manager.sorts[parsed] !== range)
2953
+ if (manager.sorts[parsedBody] !== range)
2375
2954
  throw new SmtParseError(
2376
- `invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[parsed])}`,
2955
+ `invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[parsedBody])}`,
2377
2956
  next,
2378
2957
  );
2379
- setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsed);
2958
+ setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsedBody);
2959
+ shrinkRefs(exprStack, start);
2380
2960
  };
2381
2961
 
2382
2962
  // parse_define and insert_macro: Z3 declares a macro as a recursive function with one case, which
@@ -2402,11 +2982,13 @@ export const createSmtlibReader = (
2402
2982
  };
2403
2983
 
2404
2984
  const declareCommand = (list: SmtList) => {
2985
+ releasePending();
2405
2986
  const name = list.items[0].kind === "list" ? "" : list.items[0].text;
2406
2987
  if (name === "define-fun-rec") {
2407
2988
  const decl = declareRecFun(list.items.slice(1), list.end);
2408
2989
  insertFunc(decl, list.items[4] ?? list.end);
2409
2990
  defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
2991
+ shrinkRefs(exprStack, 0);
2410
2992
  return;
2411
2993
  }
2412
2994
  if (name === "define-funs-rec") {
@@ -2437,6 +3019,7 @@ export const createSmtlibReader = (
2437
3019
  const extra = bodies.items[signatures.length];
2438
3020
  if (extra !== undefined)
2439
3021
  throw new SmtParseError("invalid recursive function definition, ')' expected", extra);
3022
+ shrinkRefs(exprStack, 0);
2440
3023
  return;
2441
3024
  }
2442
3025
  if (name === "declare-datatypes") {
@@ -2483,24 +3066,27 @@ export const createSmtlibReader = (
2483
3066
  }
2484
3067
  if (name === "define-fun" || name === "define-const") {
2485
3068
  const isConst = name === "define-const";
2486
- const bound = isConst ? { names: [], varSorts: [] } : bindSortedVars(list.items[2], list);
3069
+ const bound = isConst
3070
+ ? { names: [], varSorts: [] }
3071
+ : bindSortedVars(list.items[2], list.end, symbol.text);
2487
3072
  const range = parseSort(
2488
3073
  list.items[isConst ? 2 : 3] ?? list.end,
2489
3074
  isConst ? "Invalid constant definition" : "Invalid function definition",
2490
3075
  );
2491
- const body = parseTerm(list.items[isConst ? 3 : 4] ?? list.end);
3076
+ runTerm(list.items[isConst ? 3 : 4] ?? list.end, false);
3077
+ const body = exprStack[exprStack.length - 1];
2492
3078
  if (!isConst) unbindSortedVars(bound.varSorts.length);
2493
- const coerced = coerce(body, range);
2494
- if (manager.sorts[coerced] !== range)
3079
+ if (manager.sorts[body] !== range)
2495
3080
  throw new SmtParseError(
2496
3081
  isConst
2497
3082
  ? "invalid constant definition, sort mismatch"
2498
3083
  : "invalid function/constant definition, sort mismatch",
2499
3084
  list.end,
2500
3085
  );
2501
- manager.incRef(coerced);
2502
- declare(macros, symbol.text, { domain: bound.varSorts, range, body: coerced });
2503
- defineMacroFunc(symbol.text, bound.varSorts, coerced);
3086
+ manager.incRef(body);
3087
+ declare(macros, symbol.text, { domain: bound.varSorts, range, body });
3088
+ defineMacroFunc(symbol.text, bound.varSorts, body);
3089
+ shrinkRefs(exprStack, 0);
2504
3090
  return;
2505
3091
  }
2506
3092
  const domain = name === "declare-fun" ? parseDomain(list.items[2], list) : [];
@@ -2519,14 +3105,7 @@ export const createSmtlibReader = (
2519
3105
  if (macros.has(symbol.text))
2520
3106
  throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
2521
3107
  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
- )
3108
+ if (existing.some((other) => hasSignature(other, domain, range)))
2530
3109
  throw new SmtParseError(
2531
3110
  `invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
2532
3111
  list.end,
@@ -2534,28 +3113,66 @@ export const createSmtlibReader = (
2534
3113
  declare(funcs, symbol.text, [...existing, decl]);
2535
3114
  };
2536
3115
 
3116
+ // The caller takes the reference of the stack.
2537
3117
  const parseFormula = (sexpr: SExpr) => {
2538
- const assertion = parseTerm(sexpr);
3118
+ runTerm(sexpr, false);
3119
+ const assertion = exprStack[exprStack.length - 1];
2539
3120
  if (manager.sorts[assertion] !== SORT_BOOL)
2540
3121
  throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
2541
- manager.incRef(assertion);
3122
+ exprStack.pop();
2542
3123
  return assertion;
2543
3124
  };
2544
3125
 
2545
3126
  // An assertion is named when the last name of its term is its own.
2546
3127
  const parseAssertion = (sexpr: SExpr) => {
3128
+ releasePending();
2547
3129
  lastNamed.expr = -1;
2548
3130
  const formula = parseFormula(sexpr);
2549
3131
  return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
2550
3132
  };
2551
3133
 
2552
- const push = () => scopeStarts.push(undo.length);
3134
+ const push = () => {
3135
+ releasePending();
3136
+ scopeStarts.push(undo.length);
3137
+ };
2553
3138
 
2554
3139
  const pop = () => {
3140
+ releasePending();
2555
3141
  const start = scopeStarts.pop() ?? 0;
2556
3142
  for (const restore of undo.splice(start).reverse()) restore();
2557
3143
  };
2558
3144
 
3145
+ // parser::reset, after an error: Z3 frees its stacks, and with them the terms that only the
3146
+ // command that failed held.
3147
+ const reset = () => {
3148
+ protect(floating);
3149
+ protect(unrooted);
3150
+ releasePending();
3151
+ shrinkRefs(exprStack, 0);
3152
+ if (parsed.expr !== -1) {
3153
+ if (!parsed.isOwned) manager.incRef(parsed.expr);
3154
+ manager.decRef(parsed.expr);
3155
+ parsed.expr = -1;
3156
+ }
3157
+ shrinkRefs(patternStack, 0);
3158
+ shrinkRefs(noPatternStack, 0);
3159
+ locals.clear();
3160
+ shrink(shadowedNames, 0);
3161
+ shrink(shadowedLocals, 0);
3162
+ shrink(localScopes, 0);
3163
+ binders.depth = 0;
3164
+ };
3165
+
3166
+ // cmd_context::set_logic on a manager that is in use: restrict_builtin_sorts takes the sorts the
3167
+ // logic lacks, and the declarations and the operators stay.
3168
+ const restrictSorts = (name: string) => {
3169
+ releasePending();
3170
+ if (logicHasRealsOnly(name)) restricted.isNumeralAsReal = true;
3171
+ if (!ARRAY_EXTENSION_LOGICS.has(name)) restricted.hasSetSort = false;
3172
+ if (INT_FREE_LOGICS.has(name)) sortDecls.delete("Int");
3173
+ restricted.hasFf = FF_LOGICS.has(name);
3174
+ };
3175
+
2559
3176
  const isUsed = (name: string) => funcs.has(name) || BUILTIN_NAMES.has(name);
2560
3177
 
2561
3178
  const isClashing = (decl: number) => {
@@ -2563,12 +3180,7 @@ export const createSmtlibReader = (
2563
3180
  const decls = funcs.get(String(manager.funcDecls[decl].name)) ?? [];
2564
3181
  return (
2565
3182
  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
- )
3183
+ decls.some((other) => other !== decl && hasSignature(other, domain, -1))
2572
3184
  );
2573
3185
  };
2574
3186
 
@@ -2596,6 +3208,8 @@ export const createSmtlibReader = (
2596
3208
  getLogicError: logicChecker.checkExpr,
2597
3209
  push,
2598
3210
  pop,
3211
+ reset,
3212
+ restrictSorts,
2599
3213
  isUsed,
2600
3214
  isClashing,
2601
3215
  getDeclaredFuncs,
@@ -2625,7 +3239,7 @@ export const parseSmtlib = (
2625
3239
  report: (error: SmtParseError) => void,
2626
3240
  ): SmtProblem => {
2627
3241
  const commands = createCommandReader(text);
2628
- const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0 };
3242
+ const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0, isInUse: false };
2629
3243
  const assertions: number[] = [];
2630
3244
  const runCommand = (list: SmtList) => {
2631
3245
  const name = expectSymbol(list.items[0], "invalid command, symbol expected", list).text;
@@ -2639,19 +3253,26 @@ export const parseSmtlib = (
2639
3253
  )
2640
3254
  state.rlimit = Number(value.text);
2641
3255
  if (name === "set-logic") {
3256
+ if (option === undefined)
3257
+ throw new SmtParseError("invalid command, argument(s) missing", list.end);
2642
3258
  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);
3259
+ throw new SmtParseError("invalid command argument, symbol expected", option);
3260
+ if (value !== undefined)
3261
+ throw new SmtParseError("invalid command, too many arguments", value);
3262
+ if (state.logic !== "") throw new SmtParseError("the logic has already been set", option);
2645
3263
  if (assertions.length > 0)
2646
- throw new SmtParseError("logic must be set before initialization", list.end);
3264
+ throw new SmtParseError("logic must be set before initialization", option);
2647
3265
  if (!isSupportedLogic(option.text)) return;
2648
3266
  state.logic = option.text;
2649
- state.reader = createSmtlibReader(manager, option.text);
3267
+ if (state.isInUse) state.reader.restrictSorts(option.text);
3268
+ else state.reader = createSmtlibReader(manager, option.text);
2650
3269
  } else if (DECLARATIONS.has(name)) {
3270
+ state.isInUse = true;
2651
3271
  if (name.startsWith("define-"))
2652
3272
  throw new SmtUnsupportedError(`the command ${name} is not supported`);
2653
3273
  state.reader.declareCommand(list);
2654
3274
  } else if (name === "assert") {
3275
+ state.isInUse = true;
2655
3276
  const assertion = state.reader.parseFormula(list.items[1] ?? list.end);
2656
3277
  const logicError = state.reader.getLogicError(assertion);
2657
3278
  if (logicError !== undefined) {
@@ -2673,6 +3294,7 @@ export const parseSmtlib = (
2673
3294
  } catch (error) {
2674
3295
  if (!(error instanceof SmtParseError)) throw error;
2675
3296
  report(error);
3297
+ state.reader.reset();
2676
3298
  commands.skip(report);
2677
3299
  }
2678
3300
  }