tla-ts 0.0.3 → 0.0.4-dev.1a3acf6

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 (381) hide show
  1. package/README.md +46 -115
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +194 -8
  8. package/dist/index.d.ts +194 -8
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +1377 -18
  23. package/dist/transfer.js +1377 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +26 -30
  29. package/src/builtins.ts +45 -19
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/check.ts +1182 -900
  32. package/src/cli/options.ts +109 -0
  33. package/src/cli/run.ts +63 -0
  34. package/src/cli/shared.ts +106 -0
  35. package/src/cli/tlapm.ts +374 -0
  36. package/src/cli/tlc.ts +941 -0
  37. package/src/cli/xml-exporter.ts +221 -0
  38. package/src/cli.ts +9 -2
  39. package/src/codegen.ts +112 -51
  40. package/src/config.ts +254 -181
  41. package/src/dependencies.ts +5 -7
  42. package/src/environment.ts +579 -184
  43. package/src/errors.ts +287 -4
  44. package/src/evaluate.ts +1095 -365
  45. package/src/exit-codes.ts +22 -43
  46. package/src/fingerprints.ts +49 -14
  47. package/src/index.ts +11 -0
  48. package/src/instances.ts +73 -60
  49. package/src/java-overrides.ts +183 -66
  50. package/src/json.ts +31 -36
  51. package/src/levels.ts +197 -54
  52. package/src/lexer.ts +127 -30
  53. package/src/liveness-checker.ts +894 -0
  54. package/src/liveness.ts +246 -596
  55. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  56. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  57. package/src/obligations/equality.ts +260 -0
  58. package/src/obligations/expression.ts +618 -0
  59. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  60. package/src/obligations/generate.ts +457 -0
  61. package/src/{obligations.ts → obligations/index.ts} +46 -32
  62. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  63. package/src/obligations/module.ts +445 -0
  64. package/src/obligations/normalize.ts +554 -0
  65. package/src/obligations/operators.ts +176 -0
  66. package/src/obligations/pragma.ts +195 -0
  67. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  68. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  69. package/src/obligations/regroup.ts +100 -0
  70. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  71. package/src/{obligation-source.ts → obligations/source.ts} +174 -216
  72. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  73. package/src/obligations/substitution.ts +261 -0
  74. package/src/obligations/temporal.ts +321 -0
  75. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  76. package/src/parallel-worker.ts +184 -235
  77. package/src/parallel.ts +156 -91
  78. package/src/parser.ts +490 -188
  79. package/src/pcal/ast.ts +755 -0
  80. package/src/pcal/parse.ts +1487 -0
  81. package/src/pcal/tokenize.ts +487 -0
  82. package/src/pcal/translate.ts +1151 -0
  83. package/src/pcal/validate.ts +444 -0
  84. package/src/prover/decide-pool.ts +95 -0
  85. package/src/prover/deciders.ts +33 -0
  86. package/src/prover/first-order.ts +175 -0
  87. package/src/prover/isabelle/LICENSE +36 -0
  88. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  89. package/src/prover/isabelle/decide.ts +44 -0
  90. package/src/prover/isabelle/encode.ts +445 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  92. package/src/prover/isabelle/isar/method.ts +367 -0
  93. package/src/prover/isabelle/isar/proof.ts +28 -0
  94. package/src/prover/isabelle/isar/statement.ts +57 -0
  95. package/src/prover/isabelle/isar/theory.ts +192 -0
  96. package/src/prover/isabelle/isar/type-check.ts +278 -0
  97. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  98. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  99. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  100. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  101. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  102. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  103. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  104. package/src/prover/isabelle/provers/classical.ts +389 -0
  105. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  106. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  107. package/src/prover/isabelle/pure/consts.ts +32 -0
  108. package/src/prover/isabelle/pure/conv.ts +79 -0
  109. package/src/prover/isabelle/pure/drule.ts +264 -0
  110. package/src/prover/isabelle/pure/envir.ts +331 -0
  111. package/src/prover/isabelle/pure/goal.ts +53 -0
  112. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  113. package/src/prover/isabelle/pure/list.ts +12 -0
  114. package/src/prover/isabelle/pure/logic.ts +330 -0
  115. package/src/prover/isabelle/pure/name.ts +98 -0
  116. package/src/prover/isabelle/pure/net.ts +215 -0
  117. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  118. package/src/prover/isabelle/pure/pattern.ts +631 -0
  119. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  120. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  121. package/src/prover/isabelle/pure/search.ts +68 -0
  122. package/src/prover/isabelle/pure/seq.ts +133 -0
  123. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  124. package/src/prover/isabelle/pure/table.ts +201 -0
  125. package/src/prover/isabelle/pure/tactic.ts +168 -0
  126. package/src/prover/isabelle/pure/tactical.ts +264 -0
  127. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  128. package/src/prover/isabelle/pure/term.ts +688 -0
  129. package/src/prover/isabelle/pure/thm.ts +783 -0
  130. package/src/prover/isabelle/pure/type.ts +121 -0
  131. package/src/prover/isabelle/pure/unify.ts +753 -0
  132. package/src/prover/isabelle/pure/variable.ts +25 -0
  133. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  134. package/src/prover/isabelle/tla/context.ts +74 -0
  135. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  136. package/src/prover/isabelle/tla/logic.ts +215 -0
  137. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  138. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  139. package/src/prover/ocaml.ts +22 -0
  140. package/src/prover/prep/action.ts +508 -0
  141. package/src/prover/prep/enabled-axioms.ts +189 -0
  142. package/src/prover/prep/fingerprint.ts +388 -0
  143. package/src/prover/prep/level-comparison.ts +529 -0
  144. package/src/prover/prep/md5.ts +60 -0
  145. package/src/prover/prep/methods.ts +221 -0
  146. package/src/prover/prep/normalize.ts +309 -0
  147. package/src/prover/prove-worker.ts +22 -0
  148. package/src/prover/prove.ts +492 -0
  149. package/src/prover/ptl/decide.ts +68 -0
  150. package/src/prover/ptl/encode.ts +244 -0
  151. package/src/prover/ptl/sat.ts +151 -0
  152. package/src/prover/ptl/tableau.ts +276 -0
  153. package/src/prover/smt/axioms.ts +209 -0
  154. package/src/prover/smt/context.ts +108 -0
  155. package/src/prover/smt/data.ts +636 -0
  156. package/src/prover/smt/encode.ts +275 -0
  157. package/src/prover/smt/extensionality.ts +65 -0
  158. package/src/prover/smt/flatten.ts +112 -0
  159. package/src/prover/smt/format.ts +154 -0
  160. package/src/prover/smt/instances.ts +181 -0
  161. package/src/prover/smt/rewrite.ts +766 -0
  162. package/src/prover/smt/solver/act-cache.ts +265 -0
  163. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  164. package/src/prover/smt/solver/array.ts +22 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  166. package/src/prover/smt/solver/ast-lt.ts +157 -0
  167. package/src/prover/smt/solver/ast-util.ts +91 -0
  168. package/src/prover/smt/solver/ast.ts +1315 -0
  169. package/src/prover/smt/solver/auf-solver.ts +572 -0
  170. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  171. package/src/prover/smt/solver/cg-table.ts +175 -0
  172. package/src/prover/smt/solver/clause.ts +276 -0
  173. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  174. package/src/prover/smt/solver/context.ts +1292 -0
  175. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  176. package/src/prover/smt/solver/der.ts +224 -0
  177. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  178. package/src/prover/smt/solver/e-matching.ts +659 -0
  179. package/src/prover/smt/solver/enode.ts +259 -0
  180. package/src/prover/smt/solver/expr-ref.ts +21 -0
  181. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  182. package/src/prover/smt/solver/fingerprints.ts +92 -0
  183. package/src/prover/smt/solver/flat-literals.ts +51 -0
  184. package/src/prover/smt/solver/goal.ts +138 -0
  185. package/src/prover/smt/solver/hash.ts +173 -0
  186. package/src/prover/smt/solver/hashtable.ts +166 -0
  187. package/src/prover/smt/solver/internalizer.ts +1381 -0
  188. package/src/prover/smt/solver/lbool.ts +5 -0
  189. package/src/prover/smt/solver/literal.ts +24 -0
  190. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  191. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  192. package/src/prover/smt/solver/lp/containers.ts +296 -0
  193. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  194. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  195. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  196. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  197. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  198. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  199. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  200. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  201. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  202. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  203. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  204. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  205. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  206. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  207. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  208. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  209. package/src/prover/smt/solver/lp/nex.ts +120 -0
  210. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  211. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  212. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  213. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  214. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  215. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  216. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  217. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  218. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  219. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  220. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  221. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  222. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  223. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  224. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  225. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  226. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  227. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  228. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  229. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  230. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  231. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  232. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  233. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  234. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  235. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  236. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  237. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  238. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  239. package/src/prover/smt/solver/model-checker.ts +347 -0
  240. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  241. package/src/prover/smt/solver/model-finder.ts +155 -0
  242. package/src/prover/smt/solver/model-generator.ts +97 -0
  243. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  244. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  245. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  246. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  247. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  248. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  249. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  252. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  253. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  254. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  255. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  256. package/src/prover/smt/solver/nnf.ts +469 -0
  257. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  258. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  259. package/src/prover/smt/solver/propagate-values.ts +83 -0
  260. package/src/prover/smt/solver/proto-model.ts +551 -0
  261. package/src/prover/smt/solver/pull-quant.ts +139 -0
  262. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  263. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  264. package/src/prover/smt/solver/qe-lite.ts +381 -0
  265. package/src/prover/smt/solver/qi-queue.ts +362 -0
  266. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  267. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  268. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  269. package/src/prover/smt/solver/random-gen.ts +10 -0
  270. package/src/prover/smt/solver/rational.ts +165 -0
  271. package/src/prover/smt/solver/ref-vector.ts +62 -0
  272. package/src/prover/smt/solver/relevancy.ts +247 -0
  273. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  274. package/src/prover/smt/solver/rewriter.ts +843 -0
  275. package/src/prover/smt/solver/rlimit.ts +79 -0
  276. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  277. package/src/prover/smt/solver/solver.ts +71 -0
  278. package/src/prover/smt/solver/sort.ts +35 -0
  279. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  280. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  281. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  282. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  283. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  284. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  285. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  286. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  287. package/src/prover/smt/solver/theory-lra.ts +56 -0
  288. package/src/prover/smt/solver/var-subst.ts +258 -0
  289. package/src/prover/smt/solver/z3-license.txt +10 -0
  290. package/src/prover/smt/table.ts +170 -0
  291. package/src/prover/tlapm/cache.ts +236 -0
  292. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  293. package/src/prover/tlapm/tlapm.ts +96 -0
  294. package/src/prover/tlaps-module.ts +510 -0
  295. package/src/prover/verdict.ts +13 -0
  296. package/src/prover/zenon/LICENSE +32 -0
  297. package/src/prover/zenon/check/check.ts +105 -0
  298. package/src/prover/zenon/check/definitions.ts +144 -0
  299. package/src/prover/zenon/check/equality.ts +182 -0
  300. package/src/prover/zenon/check/functions.ts +62 -0
  301. package/src/prover/zenon/check/keys.ts +125 -0
  302. package/src/prover/zenon/check/propositional.ts +104 -0
  303. package/src/prover/zenon/check/records.ts +188 -0
  304. package/src/prover/zenon/check/relations.ts +121 -0
  305. package/src/prover/zenon/check/rewrites.ts +224 -0
  306. package/src/prover/zenon/check/sets.ts +302 -0
  307. package/src/prover/zenon/check/terms.ts +127 -0
  308. package/src/prover/zenon/check/tla.ts +126 -0
  309. package/src/prover/zenon/decide.ts +107 -0
  310. package/src/prover/zenon/encode.ts +378 -0
  311. package/src/prover/zenon/eqrel.ts +300 -0
  312. package/src/prover/zenon/equality-rules.ts +435 -0
  313. package/src/prover/zenon/expr.ts +551 -0
  314. package/src/prover/zenon/index-table.ts +350 -0
  315. package/src/prover/zenon/isar-case.ts +513 -0
  316. package/src/prover/zenon/isar.ts +1249 -0
  317. package/src/prover/zenon/limits.ts +15 -0
  318. package/src/prover/zenon/llproof.ts +173 -0
  319. package/src/prover/zenon/mltoll.ts +1566 -0
  320. package/src/prover/zenon/node.ts +297 -0
  321. package/src/prover/zenon/ocaml.ts +169 -0
  322. package/src/prover/zenon/parse.ts +247 -0
  323. package/src/prover/zenon/phrase.ts +191 -0
  324. package/src/prover/zenon/proof.ts +198 -0
  325. package/src/prover/zenon/propositional-rules.ts +387 -0
  326. package/src/prover/zenon/rules.ts +94 -0
  327. package/src/prover/zenon/search.ts +288 -0
  328. package/src/prover/zenon/tla/functions.ts +151 -0
  329. package/src/prover/zenon/tla/llproof.ts +480 -0
  330. package/src/prover/zenon/tla/records.ts +225 -0
  331. package/src/prover/zenon/tla/rewrites.ts +447 -0
  332. package/src/prover/zenon/tla/sets.ts +304 -0
  333. package/src/prover/zenon/tla/terms.ts +162 -0
  334. package/src/prover/zenon/tla/tla.ts +506 -0
  335. package/src/randomization.ts +39 -27
  336. package/src/resolve.ts +1474 -426
  337. package/src/runtime.ts +25 -7
  338. package/src/sany/builtins.ts +147 -0
  339. package/src/sany/generator.ts +3111 -0
  340. package/src/sany/levels.ts +1205 -0
  341. package/src/sany/lexer.ts +544 -0
  342. package/src/sany/linter.ts +122 -0
  343. package/src/sany/modules.ts +1398 -0
  344. package/src/sany/nodes.ts +463 -0
  345. package/src/sany/parse-error.ts +2161 -0
  346. package/src/sany/report.ts +355 -0
  347. package/src/sany/selectors.ts +736 -0
  348. package/src/sany/source.ts +247 -0
  349. package/src/sany/xml.ts +1016 -0
  350. package/src/search.ts +969 -0
  351. package/src/spec-description.ts +66 -29
  352. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  353. package/src/standard-modules.ts +215 -164
  354. package/src/state-graph.ts +181 -0
  355. package/src/subexpressions.ts +231 -171
  356. package/src/substitution-levels.ts +40 -19
  357. package/src/successors.ts +253 -125
  358. package/src/symmetry.ts +194 -54
  359. package/src/tableau.ts +60 -32
  360. package/src/tlc/fingerprint.ts +214 -0
  361. package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
  362. package/src/tlc/messages.ts +441 -0
  363. package/src/{tlc-order.ts → tlc/order.ts} +84 -16
  364. package/src/{tlc-random.ts → tlc/random.ts} +30 -189
  365. package/src/tlc/replay.ts +659 -0
  366. package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
  367. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
  368. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
  369. package/src/tlc/version.ts +19 -0
  370. package/src/transfer.ts +44 -32
  371. package/src/values.ts +843 -241
  372. package/src/worker.ts +62 -0
  373. package/dist/parallel.cjs +0 -12
  374. package/dist/parallel.js +0 -12
  375. package/dist/run-cli.cjs +0 -28
  376. package/dist/run-cli.js +0 -28
  377. package/src/canonical.ts +0 -39
  378. package/src/cli-options.ts +0 -58
  379. package/src/obligation-expression.ts +0 -1060
  380. package/src/obligation-module.ts +0 -1042
  381. package/src/run-cli.ts +0 -478
@@ -0,0 +1,843 @@
1
+ // Ported from Z3 (src/ast/rewriter/th_rewriter.cpp, bool_rewriter.cpp, arith_rewriter.cpp), MIT
2
+ // license, see z3-license.txt. Only the rewrites that tlapm's encoding exercises are ported.
3
+ import { ArithRewriter, KERNEL_ARITH_OPTIONS, TACTIC_ARITH_OPTIONS } from "./arith-rewriter";
4
+ import type { ArithRewriterOptions } from "./poly-rewriter";
5
+ import { isAstLess } from "./ast-lt";
6
+ import { Der } from "./der";
7
+ import {
8
+ AstManager,
9
+ FAMILY_ARITH,
10
+ FAMILY_BASIC,
11
+ KIND_APP,
12
+ KIND_QUANTIFIER,
13
+ KIND_VAR,
14
+ OP_ABS,
15
+ OP_ADD,
16
+ OP_AND,
17
+ OP_DISTINCT,
18
+ OP_DIV,
19
+ OP_EQ,
20
+ OP_GE,
21
+ OP_GT,
22
+ OP_IDIV,
23
+ OP_IMPLIES,
24
+ OP_IS_INT,
25
+ OP_ITE,
26
+ OP_LE,
27
+ OP_LT,
28
+ OP_MOD,
29
+ OP_MUL,
30
+ OP_NOT,
31
+ OP_OR,
32
+ OP_SUB,
33
+ OP_TO_INT,
34
+ OP_TO_REAL,
35
+ OP_UMINUS,
36
+ OP_UNINTERPRETED,
37
+ OP_XOR,
38
+ SORT_BOOL,
39
+ isArithSort,
40
+ } from "./ast";
41
+ import { getRewriteDepth, type Rewrite, RewriterTpl } from "./rewriter-tpl";
42
+ import { sortByKey } from "./sort";
43
+ import { UnusedVarsEliminator } from "./var-subst";
44
+
45
+ interface RewriterOptions {
46
+ // Replaces (and a b) with (not (or (not a) (not b))), as Z3's asserted_formulas does after NNF.
47
+ readonly isEliminatingAnd: boolean;
48
+ readonly arith: ArithRewriterOptions;
49
+ // rewrite_patterns: the patterns of a quantifier are rewritten like its body. The kernel's rewriters
50
+ // set it, and the tactics' leave it off.
51
+ readonly isRewritingPatterns: boolean;
52
+ // pull_cheap_ite: a binary predicate or a function of an ite with values distributes over the ite.
53
+ readonly isPullingCheapIte?: boolean;
54
+ }
55
+
56
+ // The parameters that asserted_formulas gives the kernel's rewriters.
57
+ export const KERNEL_REWRITER_OPTIONS: RewriterOptions = {
58
+ isEliminatingAnd: false,
59
+ arith: KERNEL_ARITH_OPTIONS,
60
+ isRewritingPatterns: true,
61
+ };
62
+
63
+ // th_rewriter's defaults, which the tactics and the model use.
64
+ export const TACTIC_REWRITER_OPTIONS: RewriterOptions = {
65
+ isEliminatingAnd: false,
66
+ arith: TACTIC_ARITH_OPTIONS,
67
+ isRewritingPatterns: false,
68
+ };
69
+
70
+ // A term that reduceTo is rewriting: the depth left for its arguments, its next argument, and where
71
+ // its arguments' results start.
72
+ interface ReduceFrame {
73
+ expr: number;
74
+ depth: number;
75
+ childIndex: number;
76
+ spos: number;
77
+ }
78
+
79
+ // rewriter_tpl with th_rewriter_cfg.
80
+ export class Rewriter extends RewriterTpl {
81
+ private arith: ArithRewriter;
82
+ private substitution = new Map<number, number>();
83
+ private unusedVarsEliminator: UnusedVarsEliminator;
84
+ private der: Der;
85
+ // try_ite_value writes the result of reduce_app, which is the m_r of the rewriter that applies
86
+ // this one, as it goes: the first write releases what m_r held.
87
+ releaseResult = () => this.setLastResult(-1);
88
+
89
+ constructor(
90
+ manager: AstManager,
91
+ private options: RewriterOptions,
92
+ private isNestedDer = false,
93
+ ) {
94
+ super(manager);
95
+ this.arith = new ArithRewriter(manager, options.arith);
96
+ this.unusedVarsEliminator = new UnusedVarsEliminator(manager);
97
+ this.der = new Der(manager);
98
+ }
99
+
100
+ // ~imp: the members of th_rewriter_cfg go before the caches of rewriter_tpl.
101
+ release() {
102
+ this.unusedVarsEliminator.release();
103
+ this.der.release();
104
+ super.release();
105
+ }
106
+
107
+ // Rewrites the top depth levels of a term, outside the main loop. Like rewriter_tpl, it keeps its
108
+ // frames on an explicit stack, so a deep term or a long chain of rewrites cannot overflow the call
109
+ // stack.
110
+ private reduceTo(expr: number, depth: number): number {
111
+ const manager = this.manager;
112
+ const frames: ReduceFrame[] = [];
113
+ const results: number[] = [];
114
+ const visit = (term: number, termDepth: number) => {
115
+ if (termDepth === 0 || manager.kinds[term] !== KIND_APP || manager.getNumArgs(term) === 0)
116
+ results.push(term);
117
+ else frames.push({ expr: term, depth: termDepth - 1, childIndex: 0, spos: results.length });
118
+ };
119
+ visit(expr, depth);
120
+ while (frames.length > 0) {
121
+ const frame = frames[frames.length - 1];
122
+ if (frame.childIndex < manager.getNumArgs(frame.expr)) {
123
+ visit(manager.getArg(frame.expr, frame.childIndex++), frame.depth);
124
+ continue;
125
+ }
126
+ frames.pop();
127
+ const decl = manager.decls[frame.expr];
128
+ const newArgs = results.splice(frame.spos);
129
+ const reduced = this.reduceAppTop(decl, newArgs, manager.sorts[frame.expr]);
130
+ if (reduced === -1) results.push(manager.mkApp(decl, newArgs, manager.sorts[frame.expr]));
131
+ else if (typeof reduced === "number") results.push(reduced);
132
+ else visit(reduced.expr, getRewriteDepth(reduced));
133
+ }
134
+ return results[0];
135
+ }
136
+
137
+ // updt_params with elim_and, which asserted_formulas turns on after NNF. The caller resets the
138
+ // rewriter.
139
+ setEliminatingAnd(isEliminatingAnd: boolean) {
140
+ this.options = { ...this.options, isEliminatingAnd };
141
+ }
142
+
143
+ // th_rewriter::set_substitution: rewrites replace each key of the substitution with its value, and
144
+ // the rewriter is reset. The caller may extend the substitution between rewrites without a reset.
145
+ setSubstitution(substitution: Map<number, number>) {
146
+ this.substitution = substitution;
147
+ this.reset();
148
+ }
149
+
150
+ getSubst(expr: number) {
151
+ return this.substitution.size === 0 ? undefined : this.substitution.get(expr);
152
+ }
153
+
154
+ // flat_assoc: th_rewriter flattens and, or and + into an enclosing application of the same
155
+ // operator.
156
+ isFlatAssoc(decl: number) {
157
+ const op = this.manager.funcDecls[decl].op;
158
+ return op === OP_AND || op === OP_OR || op === OP_ADD;
159
+ }
160
+
161
+ isRewritingPatterns() {
162
+ return this.options.isRewritingPatterns;
163
+ }
164
+
165
+ reduceApp(decl: number, args: number[], sort: number) {
166
+ const manager = this.manager;
167
+ // An uninterpreted application only reduces by pull_ite, which needs two arguments.
168
+ if (
169
+ manager.funcDecls[decl].op === OP_UNINTERPRETED &&
170
+ (args.length !== 2 || this.options.isPullingCheapIte !== true)
171
+ )
172
+ return -1;
173
+ const outer = manager.beginTemporaries();
174
+ const result = this.reduceAppTop(decl, args, sort);
175
+ if (result !== -1) manager.incRef(typeof result === "number" ? result : result.expr);
176
+ manager.endTemporaries(outer);
177
+ return result;
178
+ }
179
+
180
+ reduceQuantifier(expr: number, body: number, patterns: number[]) {
181
+ return this.manager.withTemporaries(() => this.reduceQuantifierCore(expr, body, patterns));
182
+ }
183
+
184
+ // th_rewriter_cfg::reduce_quantifier: a bound Boolean variable among the conjuncts of a universal
185
+ // body or the disjuncts of an existential one decides the quantifier. Otherwise it merges a
186
+ // directly nested quantifier of the same kind when neither has patterns, eliminates unused
187
+ // variables, and applies der to pattern-free quantifiers.
188
+ private reduceQuantifierCore(expr: number, body: number, newPatterns: number[]) {
189
+ const manager = this.manager;
190
+ const data = manager.getQuantifier(expr);
191
+ const isNegated = manager.isNot(body);
192
+ const junction = isNegated ? manager.getArg(body, 0) : body;
193
+ if (
194
+ manager.getOp(junction) === (data.isForall !== isNegated ? OP_AND : OP_OR) &&
195
+ manager.someArg(junction, (arg) => {
196
+ const atom = manager.isNot(arg) ? manager.getArg(arg, 0) : arg;
197
+ return manager.kinds[atom] === KIND_VAR && manager.values[atom] < data.sorts.length;
198
+ })
199
+ )
200
+ return data.isForall ? manager.falseExpr : manager.trueExpr;
201
+ const nested =
202
+ manager.kinds[body] === KIND_QUANTIFIER ? manager.getQuantifier(body) : undefined;
203
+ // remove_duplicates.
204
+ const patterns = newPatterns.filter((pattern, index) => newPatterns.indexOf(pattern) === index);
205
+ const merged =
206
+ nested !== undefined &&
207
+ nested.isForall === data.isForall &&
208
+ data.patterns.length === 0 &&
209
+ nested.patterns.length === 0
210
+ ? manager.mkQuantifier({
211
+ ...data,
212
+ sorts: [...data.sorts, ...nested.sorts],
213
+ names: [...data.names, ...nested.names],
214
+ body: nested.body,
215
+ patterns: [],
216
+ weight: Math.min(data.weight, nested.weight),
217
+ })
218
+ : manager.mkQuantifier({ ...data, body, patterns: this.substitutePatterns(patterns) });
219
+ const reduced = this.unusedVarsEliminator.apply(merged);
220
+ manager.releaseLater(reduced);
221
+ if (
222
+ manager.kinds[reduced] !== KIND_QUANTIFIER ||
223
+ manager.getQuantifier(reduced).patterns.length > 0
224
+ )
225
+ return reduced;
226
+ const eliminated = this.der.apply(reduced);
227
+ if (eliminated === reduced || this.isNestedDer) return eliminated;
228
+ const nestedRewriter = new Rewriter(manager, this.options, true);
229
+ const rewritten = nestedRewriter.rewrite(eliminated);
230
+ nestedRewriter.release();
231
+ manager.releaseLater(rewritten);
232
+ return rewritten;
233
+ }
234
+
235
+ // th_rewriter_cfg::apply_subst: the substitution replaces terms in the patterns without rewriting
236
+ // them, like expr_safe_replace.
237
+ private substitutePatterns(patterns: number[]) {
238
+ const manager = this.manager;
239
+ if (this.substitution.size === 0) return patterns;
240
+ const cache = new Map<number, number>();
241
+ const replace = (expr: number): number => {
242
+ const replacement = this.substitution.get(expr);
243
+ if (replacement !== undefined) return replacement;
244
+ if (manager.kinds[expr] !== KIND_APP || manager.getNumArgs(expr) === 0) return expr;
245
+ const cached = cache.get(expr);
246
+ if (cached !== undefined) return cached;
247
+ const result = manager.mkApp(
248
+ manager.decls[expr],
249
+ manager.mapArgs(expr, replace),
250
+ manager.sorts[expr],
251
+ );
252
+ cache.set(expr, result);
253
+ return result;
254
+ };
255
+ return patterns.map((pattern) => manager.mkPattern(manager.mapArgs(pattern, replace)));
256
+ }
257
+
258
+ // th_rewriter::mk_app: one reduction, without rewriting what it returns.
259
+ mkApp(decl: number, args: number[], sort: number) {
260
+ const reduced = this.reduceAppTop(decl, args, sort);
261
+ return reduced === -1
262
+ ? this.manager.mkApp(decl, args, sort)
263
+ : typeof reduced === "number"
264
+ ? reduced
265
+ : reduced.expr;
266
+ }
267
+
268
+ // th_rewriter's mk_app, with the result of a Rewrite rewritten again.
269
+ mkAppCore(decl: number, args: number[], sort: number): number {
270
+ const reduced = this.reduceAppTop(decl, args, sort);
271
+ return reduced === -1
272
+ ? this.manager.mkApp(decl, args, sort)
273
+ : typeof reduced === "number"
274
+ ? reduced
275
+ : this.reduceTo(reduced.expr, getRewriteDepth(reduced));
276
+ }
277
+
278
+ // th_rewriter_cfg::reduce_app: reduce_app_core, then pull_ite with pull_cheap_ite. -1 is BR_FAILED.
279
+ private reduceAppTop(decl: number, args: number[], sort: number) {
280
+ const manager = this.manager;
281
+ const reduced = this.reduceAppCore(decl, args);
282
+ if (typeof reduced !== "number" || this.options.isPullingCheapIte !== true) return reduced;
283
+ if (reduced === -1)
284
+ return (args.length === 2 ? this.pullIte(decl, args[0], args[1], sort) : undefined) ?? -1;
285
+ return manager.kinds[reduced] === KIND_APP && manager.getNumArgs(reduced) === 2
286
+ ? (this.pullIte(
287
+ manager.decls[reduced],
288
+ manager.getArg(reduced, 0),
289
+ manager.getArg(reduced, 1),
290
+ manager.sorts[reduced],
291
+ ) ?? reduced)
292
+ : reduced;
293
+ }
294
+
295
+ // pull_ite: (p (ite c a b) v) is (ite c (p a v) (p b v)) for a value v, and likewise for
296
+ // (p (ite c a b) (ite c a' b')) and a value first, for a p of two arguments.
297
+ private pullIte(decl: number, first: number, second: number, sort: number): Rewrite | undefined {
298
+ const manager = this.manager;
299
+ if (sort === SORT_BOOL && manager.sorts[first] !== SORT_BOOL) {
300
+ if (this.isIte(first)) {
301
+ if (manager.isUniqueValue(second) && manager.getRefCount(first) === 1)
302
+ return this.pullIteCore(decl, first, second, sort, false);
303
+ if (this.isIte(second) && manager.getArg(first, 0) === manager.getArg(second, 0)) {
304
+ const branches = [1, 2].map((index) =>
305
+ manager.mkApp(
306
+ decl,
307
+ [manager.getArg(first, index), manager.getArg(second, index)],
308
+ sort,
309
+ ),
310
+ );
311
+ return {
312
+ expr: manager.mkApp(OP_ITE, [manager.getArg(first, 0), ...branches], SORT_BOOL),
313
+ depth: 2,
314
+ };
315
+ }
316
+ }
317
+ if (this.isIte(second) && manager.isUniqueValue(first) && manager.getRefCount(second) === 1)
318
+ return this.pullIteCore(decl, second, first, sort, true);
319
+ }
320
+ const family = manager.funcDecls[decl].family;
321
+ if (family !== FAMILY_BASIC && family !== FAMILY_ARITH) return undefined;
322
+ if (manager.isUniqueValue(first) && this.isIteValueTree(second))
323
+ return this.pullIteCore(decl, second, first, sort, true);
324
+ if (manager.isUniqueValue(second) && this.isIteValueTree(first))
325
+ return this.pullIteCore(decl, first, second, sort, false);
326
+ return undefined;
327
+ }
328
+
329
+ // pull_ite_core: the value comes first when isSwapped. An equality of a branch and the value is
330
+ // decided when the branch is a value.
331
+ private pullIteCore(
332
+ decl: number,
333
+ ite: number,
334
+ value: number,
335
+ sort: number,
336
+ isSwapped: boolean,
337
+ ): Rewrite {
338
+ const manager = this.manager;
339
+ const branches = [manager.getArg(ite, 1), manager.getArg(ite, 2)].map((branch) =>
340
+ manager.funcDecls[decl].op === OP_EQ
341
+ ? branch === value
342
+ ? manager.trueExpr
343
+ : this.areDistinct(branch, value)
344
+ ? manager.falseExpr
345
+ : manager.mkEq(branch, value)
346
+ : manager.mkApp(decl, isSwapped ? [value, branch] : [branch, value], sort),
347
+ );
348
+ return { expr: manager.mkApp(OP_ITE, [manager.getArg(ite, 0), ...branches], sort), depth: 2 };
349
+ }
350
+
351
+ // is_ite_value_tree: an unshared ite whose leaves are values, through unshared ites.
352
+ private isIteValueTree(expr: number) {
353
+ const manager = this.manager;
354
+ if (!this.isIte(expr) || manager.getRefCount(expr) !== 1) return false;
355
+ const todo = [expr];
356
+ for (let ite = todo.pop(); ite !== undefined; ite = todo.pop()) {
357
+ for (const branch of [manager.getArg(ite, 1), manager.getArg(ite, 2)]) {
358
+ if (this.isIte(branch) && manager.getRefCount(branch) === 1) todo.push(branch);
359
+ else if (!manager.isUniqueValue(branch)) return false;
360
+ }
361
+ }
362
+ return true;
363
+ }
364
+
365
+ // The reductions of the Boolean and arithmetic rewriters, which the model evaluator applies too.
366
+ reduceAppCore(decl: number, args: number[]): number | Rewrite {
367
+ const manager = this.manager;
368
+ const op = manager.funcDecls[decl].op;
369
+ switch (op) {
370
+ case OP_AND:
371
+ return this.mkAndCore(args);
372
+ case OP_OR:
373
+ return this.mkOr(args);
374
+ case OP_NOT:
375
+ return this.mkNot(args[0]);
376
+ case OP_IMPLIES:
377
+ return this.mkOr([this.mkNot(args[0]), args[1]]);
378
+ case OP_XOR:
379
+ return this.mkEq(this.mkNot(args[0]), args[1]);
380
+ case OP_EQ:
381
+ return (
382
+ (isArithSort(manager.sorts[args[0]]) ? this.arith.mkEq(args[0], args[1]) : undefined) ??
383
+ this.mkEqCore(args[0], args[1]) ??
384
+ -1
385
+ );
386
+ case OP_DISTINCT:
387
+ return this.mkDistinct(args);
388
+ case OP_ITE:
389
+ return this.mkIte(args[0], args[1], args[2]);
390
+ case OP_LE:
391
+ return this.arith.mkLe(args[0], args[1]) ?? -1;
392
+ case OP_GE:
393
+ return this.arith.mkGe(args[0], args[1]) ?? -1;
394
+ case OP_LT:
395
+ return this.arith.mkLt(args[0], args[1]);
396
+ case OP_GT:
397
+ return this.arith.mkGt(args[0], args[1]);
398
+ case OP_ADD:
399
+ return this.arith.mkAdd(args) ?? -1;
400
+ case OP_SUB:
401
+ return this.arith.mkSub(args);
402
+ case OP_UMINUS:
403
+ return this.arith.mkUminus(args[0]);
404
+ case OP_MUL:
405
+ return this.arith.mkMul(args) ?? -1;
406
+ case OP_IDIV:
407
+ return this.arith.mkIdiv(args[0], args[1]) ?? -1;
408
+ case OP_MOD:
409
+ return this.arith.mkMod(args[0], args[1]) ?? -1;
410
+ case OP_ABS:
411
+ return this.arith.mkAbs(args[0]);
412
+ case OP_DIV:
413
+ return this.arith.mkDiv(args[0], args[1]) ?? -1;
414
+ case OP_TO_REAL:
415
+ return this.arith.mkToReal(args[0]) ?? -1;
416
+ case OP_TO_INT:
417
+ return this.arith.mkToInt(args[0]) ?? -1;
418
+ case OP_IS_INT:
419
+ return this.arith.mkIsInt(args[0]);
420
+ default:
421
+ return -1;
422
+ }
423
+ }
424
+
425
+ // bool_rewriter::mk_not: (not (= a b)) of Booleans is (= (not a) b).
426
+ mkNot(arg: number): number {
427
+ const manager = this.manager;
428
+ if (manager.isNot(arg)) return manager.getArg(arg, 0);
429
+ if (manager.getOp(arg) === OP_EQ && manager.sorts[manager.getArg(arg, 0)] === SORT_BOOL)
430
+ return this.mkEq(this.mkNot(manager.getArg(arg, 0)), manager.getArg(arg, 1));
431
+ return manager.mkNot(arg);
432
+ }
433
+
434
+ // bool_rewriter::mk_flat_or_core and mk_nflat_or_core: lifts the disjuncts of nested disjunctions
435
+ // one level, drops false and duplicates, and detects true or a complementary pair. With
436
+ // sort_disjunctions, a disjunction that changed or is out of ast_lt's order is stably sorted by id.
437
+ mkOr(args: number[]): number {
438
+ const manager = this.manager;
439
+ const isNested = args.some((arg) => manager.getOp(arg) === OP_OR);
440
+ const flatArgs = isNested ? this.flattenArgs(args, OP_OR) : args;
441
+ const literals = manager.flatLiterals;
442
+ literals.clear();
443
+ for (const arg of flatArgs) {
444
+ if (manager.isTrue(arg)) return manager.trueExpr;
445
+ if (manager.isFalse(arg)) continue;
446
+ if (literals.add(arg)) return manager.trueExpr;
447
+ }
448
+ const result = literals.list;
449
+ const isOutOfOrder = result.some(
450
+ (arg, index) => index > 0 && isAstLess(manager, arg, result[index - 1]),
451
+ );
452
+ // Dropping false or a duplicate disjunct also sets mk_nflat_or_core's s.
453
+ if (isNested || result.length !== flatArgs.length || isOutOfOrder)
454
+ sortByKey(result, (arg) => manager.ids[arg]);
455
+ return manager.mkOr(result);
456
+ }
457
+
458
+ // bool_rewriter::mk_and_core: with elim_and, mk_and_as_or. Otherwise mk_flat_and_core lifts the
459
+ // conjuncts of nested conjunctions one level, and has the result rewritten again.
460
+ private mkAndCore(args: number[]): number | Rewrite {
461
+ const manager = this.manager;
462
+ if (this.options.isEliminatingAnd) return this.mkAndAsOr(args);
463
+ if (!args.some((arg) => manager.getOp(arg) === OP_AND)) return this.mkNflatAnd(args);
464
+ return { expr: this.mkNflatAnd(this.flattenArgs(args, OP_AND)), depth: 1 };
465
+ }
466
+
467
+ // The arguments with those that apply op replaced by their own arguments, one level deep.
468
+ private flattenArgs(args: number[], op: number) {
469
+ const manager = this.manager;
470
+ const flatArgs: number[] = [];
471
+ for (const arg of args)
472
+ if (manager.getOp(arg) === op) manager.pushArgs(arg, flatArgs);
473
+ else flatArgs.push(arg);
474
+ return flatArgs;
475
+ }
476
+
477
+ // bool_rewriter::mk_and, which takes the result of mk_and_core as it is.
478
+ mkAnd(args: number[]): number {
479
+ const result = this.mkAndCore(args);
480
+ return typeof result === "number" ? result : result.expr;
481
+ }
482
+
483
+ // bool_rewriter::mk_nflat_and_core: drops true and duplicates, and detects false or a complementary
484
+ // pair.
485
+ private mkNflatAnd(args: number[]) {
486
+ const manager = this.manager;
487
+ const literals = manager.flatLiterals;
488
+ literals.clear();
489
+ for (const arg of args) {
490
+ if (manager.isTrue(arg)) continue;
491
+ if (manager.isFalse(arg) || literals.add(arg)) return manager.falseExpr;
492
+ }
493
+ const result = literals.list;
494
+ if (result.length === 0) return manager.trueExpr;
495
+ return result.length === 1 ? result[0] : manager.mkAnd(result);
496
+ }
497
+
498
+ // bool_rewriter::mk_and_as_or: the negation of the disjunction of the negated conjuncts. Each
499
+ // negation is built with its own temporaries, and the negations outlive the disjunction.
500
+ private mkAndAsOr(args: number[]) {
501
+ const manager = this.manager;
502
+ const negations = args.map((arg) => manager.withTemporaries(() => this.mkNot(arg)));
503
+ const result = manager.withTemporaries(() => this.mkNot(this.mkOr(negations)));
504
+ for (const negation of negations) manager.decRef(negation);
505
+ manager.releaseLater(result);
506
+ return result;
507
+ }
508
+
509
+ // try_ite_eq: (ite c t e) = t is c when e is a value distinct from t, and likewise for e. The main
510
+ // loop rewrites the result again.
511
+ private tryIteEq(ite: number, other: number): Rewrite | undefined {
512
+ const manager = this.manager;
513
+ if (!this.isIte(ite)) return undefined;
514
+ if (manager.getArg(ite, 1) === other && this.areDistinct(manager.getArg(ite, 2), other))
515
+ return { expr: manager.getArg(ite, 0), depth: 1 };
516
+ if (manager.getArg(ite, 2) === other && this.areDistinct(manager.getArg(ite, 1), other))
517
+ return { expr: manager.mkNot(manager.getArg(ite, 0)), depth: 1 };
518
+ return undefined;
519
+ }
520
+
521
+ private isIte(expr: number) {
522
+ return this.manager.getOp(expr) === OP_ITE;
523
+ }
524
+
525
+ private areDistinct(first: number, second: number) {
526
+ const manager = this.manager;
527
+ return first !== second && manager.isUniqueValue(first) && manager.isUniqueValue(second);
528
+ }
529
+
530
+ // The ite_extra_rules of mk_eq_core: an ite against a value, or two ites of values.
531
+ private mkIteValueEq(left: number, right: number): number | Rewrite | undefined {
532
+ const manager = this.manager;
533
+ if (this.isIte(left) && manager.isUniqueValue(right)) return this.tryIteValue(left, right);
534
+ if (this.isIte(right) && manager.isUniqueValue(left)) return this.tryIteValue(right, left);
535
+ if (
536
+ !this.isIte(left) ||
537
+ !this.isIte(right) ||
538
+ ![
539
+ manager.getArg(left, 1),
540
+ manager.getArg(left, 2),
541
+ manager.getArg(right, 1),
542
+ manager.getArg(right, 2),
543
+ ].every((arg) => manager.isUniqueValue(arg))
544
+ )
545
+ return undefined;
546
+ const mkOr = (args: number[]) => manager.mkApp(OP_OR, args, SORT_BOOL);
547
+ const clauses = [
548
+ mkOr([
549
+ manager.getArg(left, 0),
550
+ manager.getArg(right, 0),
551
+ manager.mkEq(manager.getArg(left, 2), manager.getArg(right, 2)),
552
+ ]),
553
+ ];
554
+ const leftNot = manager.mkNot(manager.getArg(left, 0));
555
+ const rightNot = manager.mkNot(manager.getArg(right, 0));
556
+ clauses.push(
557
+ mkOr([leftNot, rightNot, manager.mkEq(manager.getArg(left, 1), manager.getArg(right, 1))]),
558
+ mkOr([
559
+ leftNot,
560
+ manager.getArg(right, 0),
561
+ manager.mkEq(manager.getArg(left, 1), manager.getArg(right, 2)),
562
+ ]),
563
+ mkOr([
564
+ manager.getArg(left, 0),
565
+ rightNot,
566
+ manager.mkEq(manager.getArg(left, 2), manager.getArg(right, 1)),
567
+ ]),
568
+ );
569
+ return { expr: manager.mkApp(OP_AND, clauses, SORT_BOOL), depth: Infinity };
570
+ }
571
+
572
+ // try_ite_value: (ite c t e) = v for a value v. It builds its results without rewriting them, and
573
+ // the main loop rewrites them again.
574
+ private tryIteValue(ite: number, value: number): number | Rewrite | undefined {
575
+ const manager = this.manager;
576
+ const condition = manager.getArg(ite, 0);
577
+ const thenExpr = manager.getArg(ite, 1);
578
+ const elseExpr = manager.getArg(ite, 2);
579
+ // An equality of a branch is the first write to the result.
580
+ const write = (result: number) => {
581
+ this.releaseResult();
582
+ return result;
583
+ };
584
+ // Z3 rewrites the equality of a branch only below depth 500.
585
+ const mkBranchEq = (branch: number) =>
586
+ write(manager.depths[branch] < 500 ? this.mkEq(branch, value) : manager.mkEq(branch, value));
587
+ // mk_eq_plain.
588
+ const mkPlainEq = (branch: number) =>
589
+ branch === value
590
+ ? manager.trueExpr
591
+ : this.areDistinct(branch, value)
592
+ ? manager.falseExpr
593
+ : manager.mkEq(branch, value);
594
+ const mkAnd = (first: number, second: number) =>
595
+ manager.mkApp(OP_AND, [first, second], SORT_BOOL);
596
+ const mkOr = (first: number, second: number) =>
597
+ manager.mkApp(OP_OR, [first, second], SORT_BOOL);
598
+ if (this.areDistinct(value, elseExpr))
599
+ return { expr: mkAnd(mkBranchEq(thenExpr), condition), depth: 2 };
600
+ if (this.areDistinct(value, thenExpr))
601
+ return { expr: mkAnd(mkBranchEq(elseExpr), manager.mkNot(condition)), depth: 2 };
602
+ if (value === thenExpr)
603
+ return value === elseExpr
604
+ ? manager.trueExpr
605
+ : { expr: mkOr(write(this.mkEq(elseExpr, value)), condition), depth: 2 };
606
+ if (value === elseExpr)
607
+ return { expr: mkOr(write(this.mkEq(thenExpr, value)), manager.mkNot(condition)), depth: 2 };
608
+ const isValueIte = (expr: number) =>
609
+ this.isIte(expr) &&
610
+ manager.isUniqueValue(manager.getArg(expr, 1)) &&
611
+ manager.isUniqueValue(manager.getArg(expr, 2));
612
+ const getExpr = (result: number | Rewrite) =>
613
+ typeof result === "number" ? result : result.expr;
614
+ const thenEq = isValueIte(thenExpr) ? this.tryIteValue(thenExpr, value) : undefined;
615
+ if (thenEq !== undefined) {
616
+ const branches = [getExpr(thenEq), mkPlainEq(elseExpr)];
617
+ return { expr: manager.mkApp(OP_ITE, [condition, ...branches], SORT_BOOL), depth: 2 };
618
+ }
619
+ const elseEq = isValueIte(elseExpr) ? this.tryIteValue(elseExpr, value) : undefined;
620
+ if (elseEq !== undefined) {
621
+ const branches = [mkPlainEq(thenExpr), getExpr(elseEq)];
622
+ return { expr: manager.mkApp(OP_ITE, [condition, ...branches], SORT_BOOL), depth: 2 };
623
+ }
624
+ // simplify_eq_ite's result is written even when it is null.
625
+ this.releaseResult();
626
+ return this.isDisjointFrom(ite, value) ? manager.falseExpr : undefined;
627
+ }
628
+
629
+ // simplify_eq_ite: whether every leaf of a tree of ites is a value distinct from the value.
630
+ private isDisjointFrom(ite: number, value: number) {
631
+ const manager = this.manager;
632
+ const visited = new Set<number>();
633
+ const todo = [ite];
634
+ while (todo.length > 0) {
635
+ const expr = todo.pop() ?? ite;
636
+ if (visited.has(expr)) continue;
637
+ visited.add(expr);
638
+ if (this.areDistinct(expr, value)) continue;
639
+ if (!this.isIte(expr)) return false;
640
+ todo.push(manager.getArg(expr, 1), manager.getArg(expr, 2));
641
+ }
642
+ return true;
643
+ }
644
+
645
+ // bool_rewriter::mk_eq, which does not rewrite the result of mk_eq_core again.
646
+ mkEq(left: number, right: number): number {
647
+ const result = this.mkEqCore(left, right);
648
+ return result === undefined
649
+ ? this.manager.mkEq(left, right)
650
+ : typeof result === "number"
651
+ ? result
652
+ : result.expr;
653
+ }
654
+
655
+ // bool_rewriter::mk_eq_core, after arith_rewriter::mk_eq_core folds numerals.
656
+ private mkEqCore(inputLeft: number, inputRight: number): number | Rewrite | undefined {
657
+ const manager = this.manager;
658
+ if (inputLeft === inputRight) return manager.trueExpr;
659
+ if (manager.isUniqueValue(inputLeft) && manager.isUniqueValue(inputRight))
660
+ return manager.falseExpr;
661
+ const iteEq = this.tryIteEq(inputLeft, inputRight) ?? this.tryIteEq(inputRight, inputLeft);
662
+ if (iteEq !== undefined) return iteEq;
663
+ const iteValueEq = this.mkIteValueEq(inputLeft, inputRight);
664
+ if (iteValueEq !== undefined) return iteValueEq;
665
+ if (manager.sorts[inputLeft] !== SORT_BOOL) return undefined;
666
+ const isUnfolded = manager.isNot(inputLeft) && manager.isNot(inputRight);
667
+ const left = isUnfolded ? manager.getArg(inputLeft, 0) : inputLeft;
668
+ const right = isUnfolded ? manager.getArg(inputRight, 0) : inputRight;
669
+ if (manager.isTrue(left)) return right;
670
+ if (manager.isFalse(left)) return this.mkNot(right);
671
+ if (manager.isTrue(right)) return left;
672
+ if (manager.isFalse(right)) return this.mkNot(left);
673
+ if (manager.isComplement(left, right)) return manager.falseExpr;
674
+ const isSwapped = manager.isNot(right);
675
+ const lhs = isSwapped ? right : left;
676
+ const rhs = isSwapped ? left : right;
677
+ if (manager.isNot(lhs))
678
+ return { expr: manager.mkNot(manager.mkEq(manager.getArg(lhs, 0), rhs)), depth: 2 };
679
+ if (isUnfolded) return { expr: manager.mkEq(lhs, rhs), depth: 1 };
680
+ // (= (= a b) (= a (not b))) is false.
681
+ if (manager.getOp(lhs) === OP_EQ && manager.getOp(rhs) === OP_EQ) {
682
+ const isNegationOf = (expr: number, other: number) =>
683
+ manager.isNot(expr) && manager.getArg(expr, 0) === other;
684
+ if (
685
+ (manager.getArg(lhs, 0) === manager.getArg(rhs, 0) &&
686
+ (isNegationOf(manager.getArg(rhs, 1), manager.getArg(lhs, 1)) ||
687
+ isNegationOf(manager.getArg(lhs, 1), manager.getArg(rhs, 1)))) ||
688
+ (manager.getArg(lhs, 1) === manager.getArg(rhs, 1) &&
689
+ (isNegationOf(manager.getArg(rhs, 0), manager.getArg(lhs, 0)) ||
690
+ isNegationOf(manager.getArg(lhs, 0), manager.getArg(rhs, 0))))
691
+ )
692
+ return manager.falseExpr;
693
+ }
694
+ return undefined;
695
+ }
696
+
697
+ // bool_rewriter::mk_distinct_core: two arguments become a disequality, which the main loop rewrites
698
+ // again, since mk_eq may dispatch to other rewriters. Z3 keeps a longer distinct, which tlapm does
699
+ // not send, and this port expands it into disequalities.
700
+ private mkDistinct(args: number[]): number | Rewrite {
701
+ if (args.length === 2) return { expr: this.mkNot(this.mkEq(args[0], args[1])), depth: 2 };
702
+ const pairs: number[] = [];
703
+ for (let left = 0; left < args.length; left++)
704
+ for (let right = left + 1; right < args.length; right++)
705
+ pairs.push(this.mkNot(this.mkEq(args[left], args[right])));
706
+ return this.mkAnd(pairs);
707
+ }
708
+
709
+ // bool_rewriter::mk_ite_core with elim_ite and ite_extra_rules. It applies the rules that change
710
+ // only the condition or a branch in sequence, and a result that it builds from new terms comes as a
711
+ // Rewrite for the main loop.
712
+ private mkIte(inputCondition: number, inputThen: number, inputElse: number): number | Rewrite {
713
+ const manager = this.manager;
714
+ const isNegated = manager.isNot(inputCondition);
715
+ const condition = isNegated ? manager.getArg(inputCondition, 0) : inputCondition;
716
+ const elseCandidate = isNegated ? inputThen : inputElse;
717
+ const thenCandidate = isNegated ? inputElse : inputThen;
718
+ // (ite c (ite c t1 t2) t3) is (ite c t1 t3).
719
+ const thenExpr =
720
+ this.isIte(thenCandidate) && manager.getArg(thenCandidate, 0) === condition
721
+ ? manager.getArg(thenCandidate, 1)
722
+ : thenCandidate;
723
+ const sort = manager.sorts[thenExpr];
724
+ // (ite c t1 (ite c2 t1 t2)) is (ite (or c c2) t1 t2).
725
+ if (this.isIte(elseCandidate) && manager.getArg(elseCandidate, 1) === thenExpr) {
726
+ const disjunction = manager.mkApp(
727
+ OP_OR,
728
+ [condition, manager.getArg(elseCandidate, 0)],
729
+ SORT_BOOL,
730
+ );
731
+ return {
732
+ expr: manager.mkApp(
733
+ OP_ITE,
734
+ [disjunction, thenExpr, manager.getArg(elseCandidate, 2)],
735
+ sort,
736
+ ),
737
+ depth: 3,
738
+ };
739
+ }
740
+ // (ite c t1 (ite c t2 t3)) is (ite c t1 t3).
741
+ const elseExpr =
742
+ this.isIte(elseCandidate) && manager.getArg(elseCandidate, 0) === condition
743
+ ? manager.getArg(elseCandidate, 2)
744
+ : elseCandidate;
745
+ if (manager.isTrue(condition)) return thenExpr;
746
+ if (manager.isFalse(condition)) return elseExpr;
747
+ if (thenExpr === elseExpr) return thenExpr;
748
+ if (sort === SORT_BOOL) {
749
+ if (manager.isTrue(thenExpr))
750
+ return manager.isFalse(elseExpr) ? condition : this.mkOr([condition, elseExpr]);
751
+ if (manager.isFalse(thenExpr))
752
+ return manager.isTrue(elseExpr)
753
+ ? this.mkNot(condition)
754
+ : { expr: this.mkAnd([this.mkNot(condition), elseExpr]), depth: 1 };
755
+ if (manager.isTrue(elseExpr)) return this.mkOr([this.mkNot(condition), thenExpr]);
756
+ if (manager.isFalse(elseExpr) || elseExpr === condition)
757
+ return { expr: this.mkAnd([condition, thenExpr]), depth: 1 };
758
+ if (thenExpr === condition) return this.mkOr([condition, elseExpr]);
759
+ // is_complement_core: one branch is the negation of the other.
760
+ if (
761
+ (manager.isNot(thenExpr) && manager.getArg(thenExpr, 0) === elseExpr) ||
762
+ (manager.isNot(elseExpr) && manager.getArg(elseExpr, 0) === thenExpr)
763
+ )
764
+ return this.mkEq(condition, thenExpr);
765
+ }
766
+ const isElseIte = this.isIte(elseExpr);
767
+ if (this.isIte(thenExpr)) {
768
+ // (ite c1 (ite c2 t1 t2) t1) is (ite (and c1 (not c2)) t2 t1).
769
+ if (elseExpr === manager.getArg(thenExpr, 1)) {
770
+ const conjunction = this.mkAnd([condition, this.mkNot(manager.getArg(thenExpr, 0))]);
771
+ return {
772
+ expr: manager.mkApp(OP_ITE, [conjunction, manager.getArg(thenExpr, 2), elseExpr], sort),
773
+ depth: 2,
774
+ };
775
+ }
776
+ // (ite c1 (ite c2 t1 t2) t2) is (ite (and c1 c2) t1 t2).
777
+ if (elseExpr === manager.getArg(thenExpr, 2)) {
778
+ const conjunction = this.mkAnd([condition, manager.getArg(thenExpr, 0)]);
779
+ return {
780
+ expr: manager.mkApp(OP_ITE, [conjunction, manager.getArg(thenExpr, 1), elseExpr], sort),
781
+ depth: 2,
782
+ };
783
+ }
784
+ // (ite c1 (ite c2 t1 t2) (ite c3 t1 t2)) is (ite (or (and c1 c2) (and (not c1) c3)) t1 t2),
785
+ // and with (ite c3 t2 t1) the last conjunct is (not c3).
786
+ const isSameBranches =
787
+ isElseIte &&
788
+ manager.getArg(thenExpr, 1) === manager.getArg(elseExpr, 1) &&
789
+ manager.getArg(thenExpr, 2) === manager.getArg(elseExpr, 2);
790
+ const isSwappedBranches =
791
+ isElseIte &&
792
+ manager.getArg(thenExpr, 1) === manager.getArg(elseExpr, 2) &&
793
+ manager.getArg(thenExpr, 2) === manager.getArg(elseExpr, 1);
794
+ if (isSameBranches || isSwappedBranches) {
795
+ const first = this.mkAnd([condition, manager.getArg(thenExpr, 0)]);
796
+ const negation = this.mkNot(condition);
797
+ const second = this.mkAnd([
798
+ negation,
799
+ isSameBranches ? manager.getArg(elseExpr, 0) : this.mkNot(manager.getArg(elseExpr, 0)),
800
+ ]);
801
+ const disjunction = this.mkOr([first, second]);
802
+ return {
803
+ expr: manager.mkApp(
804
+ OP_ITE,
805
+ [disjunction, manager.getArg(thenExpr, 1), manager.getArg(thenExpr, 2)],
806
+ sort,
807
+ ),
808
+ depth: 3,
809
+ };
810
+ }
811
+ }
812
+ if (isElseIte) {
813
+ // (ite c1 t1 (ite c2 t1 t2)) is (ite (or c1 c2) t1 t2).
814
+ if (thenExpr === manager.getArg(elseExpr, 1)) {
815
+ const disjunction = this.mkOr([condition, manager.getArg(elseExpr, 0)]);
816
+ return {
817
+ expr: manager.mkApp(OP_ITE, [disjunction, thenExpr, manager.getArg(elseExpr, 2)], sort),
818
+ depth: 1,
819
+ };
820
+ }
821
+ // (ite c1 t1 (ite c2 t2 t1)) is (ite (or c1 (not c2)) t1 t2).
822
+ if (thenExpr === manager.getArg(elseExpr, 2)) {
823
+ const disjunction = this.mkOr([condition, this.mkNot(manager.getArg(elseExpr, 0))]);
824
+ return {
825
+ expr: manager.mkApp(OP_ITE, [disjunction, thenExpr, manager.getArg(elseExpr, 1)], sort),
826
+ depth: 1,
827
+ };
828
+ }
829
+ }
830
+ return manager.mkApp(OP_ITE, [condition, thenExpr, elseExpr], sort);
831
+ }
832
+
833
+ // poly_rewriter::mk_add and mk_sub with a result: arith_rewriter's sum or difference, which is
834
+ // not rewritten again.
835
+ mkAdd(args: number[]) {
836
+ return this.arith.mkAdd(args) ?? this.arith.mkAddApp(args);
837
+ }
838
+
839
+ mkSub(first: number, second: number) {
840
+ const result = this.arith.mkSub([first, second]);
841
+ return typeof result === "number" ? result : result.expr;
842
+ }
843
+ }