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,184 @@
1
+ // Ported from Z3 (src/math/grobner/pdd_simplifier.h, src/math/grobner/pdd_simplifier.cpp), MIT
2
+ // license, see z3-license.txt. The passes that dd::solver::simplify runs before saturation: solve
3
+ // linear equations for their top variable, retire equations whose top variable occurs nowhere
4
+ // else, subtract equations that share a lo part, and eliminate variables that occur as leaves.
5
+ // The extended linear pass works only modulo 2 and the dual elimination is disabled in Z3, so
6
+ // neither is ported. No pass makes a value outside an operation, so none can run out of nodes.
7
+ import { mkJoin } from "./dependency";
8
+ import { Equation, PddSolver, SetUpdate, SOLVED, TO_SIMPLIFY } from "./pdd-solver";
9
+ import { shrink } from "../array";
10
+
11
+ export class PddSimplifier {
12
+ constructor(private solver: PddSolver) {}
13
+
14
+ run() {
15
+ while (
16
+ !this.solver.isDone() &&
17
+ (this.simplifyLinearStep(true) ||
18
+ this.simplifyElimPureStep() ||
19
+ this.simplifyCcStep() ||
20
+ this.simplifyLeafStep() ||
21
+ this.simplifyLinearStep(false))
22
+ );
23
+ }
24
+
25
+ private simplifyLinearStep(isBinary: boolean) {
26
+ const linear = this.solver.toSimplify.filter((equation) =>
27
+ isBinary ? equation.poly.isBinary() : equation.poly.isLinear(),
28
+ );
29
+ if (linear.length === 0) return false;
30
+ return this.simplifyLinear(linear);
31
+ }
32
+
33
+ // simplify_linear_step: solves each linear equation for its top variable, which it eliminates
34
+ // from the others, and moves it to the solved equations.
35
+ private simplifyLinear(linear: Equation[]) {
36
+ const solver = this.solver;
37
+ const useList = this.getUseList();
38
+ linear.sort((first, second) => first.poly.var() - second.poly.var());
39
+ const trivial: Equation[] = [];
40
+ let kept = 0;
41
+ let hasConflict = false;
42
+ for (const source of linear) {
43
+ if (hasConflict) break;
44
+ if (solver.isTrivial(source)) continue;
45
+ const variable = source.poly.var();
46
+ const uses = useList[variable];
47
+ let isAllReduced = true;
48
+ // Equations added to the uses of the variable during the walk are not walked.
49
+ for (let index = 0, length = uses.length; index < length; index++) {
50
+ const target = uses[index];
51
+ if (source === target || solver.isTrivial(target)) continue;
52
+ if (!source.poly.isBinary() && !target.poly.isLinear()) {
53
+ isAllReduced = false;
54
+ continue;
55
+ }
56
+ this.removeFromUse(target, useList, variable);
57
+ const isLeadingTermChanged = solver.simplifyUsing(target, source);
58
+ if (solver.isTrivial(target)) {
59
+ trivial.push(target);
60
+ } else if (solver.isConflict(target)) {
61
+ solver.popEquation(target);
62
+ solver.setConflict(target);
63
+ hasConflict = true;
64
+ } else if (isLeadingTermChanged) {
65
+ solver.popEquation(target);
66
+ solver.pushEquation(TO_SIMPLIFY, target);
67
+ }
68
+ this.addToUse(target, useList);
69
+ }
70
+ if (isAllReduced) linear[kept++] = source;
71
+ }
72
+ if (!hasConflict) {
73
+ shrink(linear, kept);
74
+ for (const source of linear) {
75
+ solver.popEquation(source);
76
+ solver.pushEquation(SOLVED, source);
77
+ }
78
+ }
79
+ for (const equation of trivial) solver.popEquation(equation);
80
+ return kept > 0 || hasConflict;
81
+ }
82
+
83
+ // simplify_cc_step: replaces p*x + q and r*y + q by p*x + q and p*x - r*y, when p or r is a value.
84
+ private simplifyCcStep() {
85
+ const solver = this.solver;
86
+ const los = new Map<number, Equation>();
87
+ let isReduced = false;
88
+ const update = new SetUpdate(solver.toSimplify);
89
+ for (; update.i < update.size; update.i++) {
90
+ const first = update.get();
91
+ const poly = first.poly;
92
+ const second = los.get(poly.lo().root) ?? first;
93
+ if (second === first) los.set(poly.lo().root, first);
94
+ if (
95
+ second !== first &&
96
+ (poly.hi().isVal() || second.poly.hi().isVal()) &&
97
+ !poly.lo().isVal()
98
+ ) {
99
+ first.poly = poly.sub(second.poly);
100
+ first.dep = mkJoin(first.dep, second.dep);
101
+ isReduced = true;
102
+ if (solver.isTrivial(first) || solver.checkConflict(first)) continue;
103
+ }
104
+ update.nextj();
105
+ }
106
+ update.finish();
107
+ return isReduced;
108
+ }
109
+
110
+ // simplify_leaf_step: removes a*x + b from the equations where x occurs as a leaf, for a value a.
111
+ private simplifyLeafStep() {
112
+ const solver = this.solver;
113
+ const useList = this.getUseList();
114
+ for (let index = 0; index < solver.toSimplify.length; index++) {
115
+ const source = solver.toSimplify[index];
116
+ const poly = source.poly;
117
+ if (poly.isVal() || !poly.hi().isVal()) continue;
118
+ const leaves = useList[poly.var()].filter(
119
+ (target) => target !== source && target.poly.varIsLeaf(poly.var()),
120
+ );
121
+ for (const target of leaves) {
122
+ this.removeFromUse(target, useList);
123
+ const isLeadingTermChanged = solver.simplifyUsing(target, source);
124
+ this.addToUse(target, useList);
125
+ if (solver.isTrivial(target)) {
126
+ solver.popEquation(target);
127
+ } else if (target.poly.isVal()) {
128
+ solver.popEquation(target);
129
+ solver.setConflict(target);
130
+ return true;
131
+ } else if (isLeadingTermChanged) {
132
+ solver.popEquation(target);
133
+ solver.pushEquation(TO_SIMPLIFY, target);
134
+ }
135
+ }
136
+ }
137
+ return false;
138
+ }
139
+
140
+ // simplify_elim_pure_step: an equation linear in its top variable, which occurs nowhere else, is
141
+ // solved.
142
+ private simplifyElimPureStep() {
143
+ const solver = this.solver;
144
+ const useList = this.getUseList();
145
+ const update = new SetUpdate(solver.toSimplify);
146
+ let hasSolved = false;
147
+ for (; update.i < update.size; update.i++) {
148
+ const equation = update.get();
149
+ const poly = equation.poly;
150
+ if (!poly.isVal() && poly.hi().isVal() && useList[poly.var()].length === 1) {
151
+ solver.pushEquation(SOLVED, equation);
152
+ hasSolved = true;
153
+ } else {
154
+ update.nextj();
155
+ }
156
+ }
157
+ update.finish();
158
+ return hasSolved;
159
+ }
160
+
161
+ private addToUse(equation: Equation, useList: Equation[][]) {
162
+ for (const variable of equation.poly.freeVars()) {
163
+ while (useList.length <= variable) useList.push([]);
164
+ useList[variable].push(equation);
165
+ }
166
+ }
167
+
168
+ private removeFromUse(equation: Equation, useList: Equation[][], exceptVar = -1) {
169
+ for (const variable of equation.poly.freeVars()) {
170
+ if (variable === exceptVar) continue;
171
+ while (useList.length <= variable) useList.push([]);
172
+ const uses = useList[variable];
173
+ const index = uses.indexOf(equation);
174
+ if (index !== -1) uses.splice(index, 1);
175
+ }
176
+ }
177
+
178
+ private getUseList() {
179
+ const useList: Equation[][] = [];
180
+ for (const equation of this.solver.toSimplify) this.addToUse(equation, useList);
181
+ for (const equation of this.solver.processed) this.addToUse(equation, useList);
182
+ return useList;
183
+ }
184
+ }
@@ -0,0 +1,408 @@
1
+ // Ported from Z3 (src/math/grobner/pdd_solver.h, src/math/grobner/pdd_solver.cpp), MIT license,
2
+ // see z3-license.txt. dd::solver, the Grobner basis completion that nla runs on polynomials as
3
+ // pdds. Each step picks the simplest equation whose leading variable is highest, simplifies it by
4
+ // the processed equations and them by it, and adds its S-polynomials with them to be simplified.
5
+ // Equations move between the solved, processed and to-simplify sets, each in an array where an
6
+ // equation knows its index. Z3's solver::simplify runs the simplifier, which here is PddSimplifier
7
+ // in pdd-simplifier, run by its caller.
8
+ import { PddMemoryOutError } from "../../../../errors";
9
+ import { Dependency, mkJoin } from "./dependency";
10
+ import { Pdd, PddManager } from "./pdd";
11
+ import { shrink } from "../array";
12
+
13
+ export const SOLVED = 0;
14
+ const PROCESSED = 1;
15
+ export const TO_SIMPLIFY = 2;
16
+
17
+ const UINT_MAX = 0xffffffff;
18
+
19
+ interface PddSolverConfig {
20
+ eqsThreshold: number;
21
+ exprSizeLimit: number;
22
+ exprDegreeLimit: number;
23
+ maxSteps: number;
24
+ maxSimplified: number;
25
+ eqsGrowth: number;
26
+ exprSizeGrowth: number;
27
+ exprDegreeGrowth: number;
28
+ numberOfConflictsToReport: number;
29
+ }
30
+
31
+ export const getDefaultPddSolverConfig = (): PddSolverConfig => ({
32
+ eqsThreshold: UINT_MAX,
33
+ exprSizeLimit: UINT_MAX,
34
+ exprDegreeLimit: UINT_MAX,
35
+ maxSteps: UINT_MAX,
36
+ maxSimplified: UINT_MAX,
37
+ eqsGrowth: 10,
38
+ exprSizeGrowth: 10,
39
+ exprDegreeGrowth: 5,
40
+ numberOfConflictsToReport: 1,
41
+ });
42
+
43
+ interface Subst {
44
+ variable: number;
45
+ poly: Pdd;
46
+ dep: Dependency;
47
+ }
48
+
49
+ class PddSolverStats {
50
+ simplified = 0;
51
+ maxExprSize = 0;
52
+ maxExprDegree = 0;
53
+ superposed = 0;
54
+ computeSteps = 0;
55
+ }
56
+
57
+ export class Equation {
58
+ state = TO_SIMPLIFY;
59
+ idx = 0;
60
+
61
+ constructor(
62
+ public poly: Pdd,
63
+ public dep: Dependency,
64
+ ) {}
65
+ }
66
+
67
+ // scoped_update: walks a set with i and keeps the equations that nextj moves to j. finish keeps
68
+ // those not walked and drops the rest, as Z3's destructor does.
69
+ export class SetUpdate {
70
+ i = 0;
71
+ private j = 0;
72
+ readonly size: number;
73
+
74
+ constructor(private set: Equation[]) {
75
+ this.size = set.length;
76
+ }
77
+
78
+ get() {
79
+ return this.set[this.i];
80
+ }
81
+
82
+ nextj() {
83
+ this.set[this.j] = this.set[this.i];
84
+ this.set[this.i].idx = this.j++;
85
+ }
86
+
87
+ finish() {
88
+ for (; this.i < this.size; this.i++) this.nextj();
89
+ shrink(this.set, this.j);
90
+ }
91
+ }
92
+
93
+ export class PddSolver {
94
+ stats = new PddSolverStats();
95
+ config = getDefaultPddSolverConfig();
96
+ solved: Equation[] = [];
97
+ processed: Equation[] = [];
98
+ toSimplify: Equation[] = [];
99
+ private substs: Subst[] = [];
100
+ conflict: Equation | null = null;
101
+ private isTooComplexFound = false;
102
+ private levelp1 = 0;
103
+ private level2var: number[] = [];
104
+ private var2level: number[] = [];
105
+
106
+ constructor(
107
+ readonly manager: PddManager,
108
+ private isCanceled: () => boolean,
109
+ ) {}
110
+
111
+ adjustConfig() {
112
+ const config = this.config;
113
+ const count = this.toSimplify.length;
114
+ config.eqsThreshold = Math.trunc(config.eqsGrowth * Math.ceil(Math.log(1 + count)) * count);
115
+ config.exprSizeLimit = 0;
116
+ config.exprDegreeLimit = 0;
117
+ for (const equation of this.toSimplify) {
118
+ config.exprSizeLimit = Math.max(config.exprSizeLimit, equation.poly.treeSize());
119
+ config.exprDegreeLimit = Math.max(config.exprDegreeLimit, equation.poly.degree());
120
+ }
121
+ config.exprSizeLimit *= config.exprSizeGrowth;
122
+ config.exprDegreeLimit *= config.exprDegreeGrowth;
123
+ }
124
+
125
+ reset() {
126
+ this.substs = [];
127
+ this.solved = [];
128
+ this.processed = [];
129
+ this.toSimplify = [];
130
+ this.stats = new PddSolverStats();
131
+ this.level2var = [];
132
+ this.var2level = [];
133
+ this.conflict = null;
134
+ }
135
+
136
+ add(poly: Pdd, dep: Dependency = null) {
137
+ if (poly.isZero()) return;
138
+ const equation = new Equation(poly, dep);
139
+ if (this.checkConflict(equation)) return;
140
+ this.pushEquation(TO_SIMPLIFY, equation);
141
+ if (this.var2level.length > 0) {
142
+ this.levelp1 = Math.max(this.var2level[poly.var()] + 1, this.levelp1);
143
+ }
144
+ this.updateStats(equation);
145
+ }
146
+
147
+ // simplify: applies the substitutions to p, and returns it with its dependency.
148
+ simplify(poly: Pdd, dep: Dependency) {
149
+ let result = poly;
150
+ let resultDep = dep;
151
+ for (const subst of this.substs) {
152
+ const substituted = result.substPdd(subst.variable, subst.poly);
153
+ if (substituted.equals(result)) continue;
154
+ result = substituted;
155
+ resultDep = mkJoin(resultDep, subst.dep);
156
+ }
157
+ return { poly: result, dep: resultDep };
158
+ }
159
+
160
+ addSubst(variable: number, poly: Pdd, dep: Dependency) {
161
+ this.substs.push({ variable, poly, dep });
162
+ if (this.var2level.length > 0) {
163
+ this.levelp1 = Math.max(
164
+ this.var2level[variable] + 1,
165
+ Math.max(this.var2level[poly.var()] + 1, this.levelp1),
166
+ );
167
+ }
168
+ const simplifier = (target: Equation) => {
169
+ const substituted = target.poly.substPdd(variable, poly);
170
+ if (substituted.equals(target.poly)) return null;
171
+ if (this.isTooComplex(substituted)) {
172
+ this.isTooComplexFound = true;
173
+ return null;
174
+ }
175
+ const isLeadingTermChanged = substituted.differentLeadingTerm(target.poly);
176
+ target.poly = substituted;
177
+ target.dep = mkJoin(target.dep, dep);
178
+ this.updateStats(target);
179
+ return isLeadingTermChanged;
180
+ };
181
+ if (!this.isDone()) this.simplifySetUsing(this.processed, simplifier);
182
+ if (!this.isDone()) this.simplifySetUsing(this.toSimplify, simplifier);
183
+ if (!this.isDone()) this.simplifySetUsing(this.solved, simplifier);
184
+ }
185
+
186
+ saturate() {
187
+ if (this.isDone()) return;
188
+ this.initSaturate();
189
+ try {
190
+ while (!this.isDone() && this.step());
191
+ } catch (error) {
192
+ if (!(error instanceof PddMemoryOutError)) throw error;
193
+ }
194
+ }
195
+
196
+ equations() {
197
+ return [...this.solved, ...this.toSimplify, ...this.processed];
198
+ }
199
+
200
+ private step() {
201
+ this.stats.computeSteps++;
202
+ const equation = this.pickNext();
203
+ if (equation === null) return false;
204
+ // scoped_process: the equation goes back to processed unless the step settles it.
205
+ let pending: Equation | null = equation;
206
+ try {
207
+ this.simplifyUsingAll(equation, this.processed);
208
+ if (this.isTrivial(equation)) {
209
+ pending = null;
210
+ return true;
211
+ }
212
+ if (this.checkConflict(equation)) {
213
+ pending = null;
214
+ return false;
215
+ }
216
+ this.isTooComplexFound = false;
217
+ this.simplifySetUsingEquation(this.processed, equation);
218
+ if (this.isDone()) return false;
219
+ for (const target of this.processed) this.superpose(equation, target);
220
+ this.simplifySetUsingEquation(this.toSimplify, equation);
221
+ if (this.isDone()) return false;
222
+ if (!this.isTooComplexFound) {
223
+ pending = null;
224
+ this.pushEquation(equation.poly.degree() === 1 ? SOLVED : PROCESSED, equation);
225
+ }
226
+ return true;
227
+ } finally {
228
+ if (pending !== null) this.pushEquation(PROCESSED, pending);
229
+ }
230
+ }
231
+
232
+ private initSaturate() {
233
+ const level2var = this.manager.level2var;
234
+ this.level2var = [...level2var];
235
+ this.var2level = [];
236
+ for (let level = 0; level < level2var.length; level++) this.var2level[level2var[level]] = level;
237
+ this.levelp1 = level2var.length;
238
+ }
239
+
240
+ private pickNext() {
241
+ while (this.levelp1 > 0) {
242
+ const variable = this.level2var[this.levelp1 - 1];
243
+ let picked: Equation | null = null;
244
+ for (const current of this.toSimplify) {
245
+ if (current.state !== TO_SIMPLIFY || current.poly.var() !== variable) continue;
246
+ if (picked === null || this.isSimpler(current, picked)) picked = current;
247
+ }
248
+ if (picked !== null) {
249
+ this.popEquation(picked);
250
+ return picked;
251
+ }
252
+ this.levelp1--;
253
+ }
254
+ return null;
255
+ }
256
+
257
+ private superpose(first: Equation, second: Equation) {
258
+ const poly = this.manager.trySpoly(first.poly, second.poly);
259
+ if (poly === null || poly.isZero()) return;
260
+ if (this.isTooComplex(poly)) {
261
+ this.isTooComplexFound = true;
262
+ return;
263
+ }
264
+ this.stats.superposed++;
265
+ this.add(poly, mkJoin(first.dep, second.dep));
266
+ }
267
+
268
+ // simplify_using(eq, eqs): reduces eq by the set until no reduction applies.
269
+ private simplifyUsingAll(equation: Equation, set: Equation[]) {
270
+ let isSimplified = false;
271
+ do {
272
+ isSimplified = false;
273
+ for (const source of set) {
274
+ if (this.trySimplifyUsing(equation, source) !== null) isSimplified = true;
275
+ if (this.isCanceled() || equation.poly.isVal()) break;
276
+ }
277
+ } while (isSimplified && !equation.poly.isVal());
278
+ if (equation.poly.isUnary() && equation.poly.hi().val().isNegative()) {
279
+ equation.poly = equation.poly.neg();
280
+ }
281
+ }
282
+
283
+ private simplifySetUsingEquation(set: Equation[], source: Equation) {
284
+ this.simplifySetUsing(set, (target) => this.trySimplifyUsing(target, source));
285
+ }
286
+
287
+ // simplify_using(set, simplifier): the simplifier returns null when it leaves the target, and
288
+ // otherwise whether the leading term changed.
289
+ private simplifySetUsing(set: Equation[], simplifier: (target: Equation) => boolean | null) {
290
+ const update = new SetUpdate(set);
291
+ for (; update.i < update.size; update.i++) {
292
+ const target = set[update.i];
293
+ const isLeadingTermChanged = this.isDone() ? null : simplifier(target);
294
+ if (isLeadingTermChanged !== null && this.isTrivial(target)) continue;
295
+ if (isLeadingTermChanged !== null && this.checkConflict(target)) continue;
296
+ if (isLeadingTermChanged === true) {
297
+ if (set === this.toSimplify) update.nextj();
298
+ else this.pushEquation(TO_SIMPLIFY, target);
299
+ if (this.var2level.length > 0) {
300
+ this.levelp1 = Math.max(this.var2level[target.poly.var()] + 1, this.levelp1);
301
+ }
302
+ continue;
303
+ }
304
+ update.nextj();
305
+ }
306
+ update.finish();
307
+ }
308
+
309
+ // try_simplify_using: null when the target stays, and otherwise whether its leading term changed
310
+ // while it was processed.
311
+ private trySimplifyUsing(target: Equation, source: Equation) {
312
+ if (source === target) return null;
313
+ this.stats.simplified++;
314
+ const reduced = target.poly.reduce(source.poly);
315
+ if (reduced.equals(target.poly)) return null;
316
+ if (this.isTooComplex(reduced)) {
317
+ this.isTooComplexFound = true;
318
+ return null;
319
+ }
320
+ const isLeadingTermChanged =
321
+ target.state === PROCESSED && reduced.differentLeadingTerm(target.poly);
322
+ target.poly = reduced;
323
+ target.dep = mkJoin(target.dep, source.dep);
324
+ this.updateStats(target);
325
+ return isLeadingTermChanged;
326
+ }
327
+
328
+ // simplify_using(dst, src): reduces dst by src whatever the result, and returns whether its
329
+ // leading term changed while it was processed.
330
+ simplifyUsing(target: Equation, source: Equation) {
331
+ if (source === target) return false;
332
+ this.stats.simplified++;
333
+ const reduced = target.poly.reduce(source.poly);
334
+ const isLeadingTermChanged =
335
+ target.state === PROCESSED && reduced.differentLeadingTerm(target.poly);
336
+ if (reduced.equals(target.poly)) return isLeadingTermChanged;
337
+ target.poly = reduced;
338
+ target.dep = mkJoin(target.dep, source.dep);
339
+ this.updateStats(target);
340
+ return isLeadingTermChanged;
341
+ }
342
+
343
+ isDone() {
344
+ return (
345
+ this.toSimplify.length + this.processed.length >= this.config.eqsThreshold ||
346
+ this.stats.simplified >= this.config.maxSimplified ||
347
+ this.isCanceled() ||
348
+ this.stats.computeSteps > this.config.maxSteps ||
349
+ this.conflict !== null
350
+ );
351
+ }
352
+
353
+ isTrivial(equation: Equation) {
354
+ return equation.poly.isZero();
355
+ }
356
+
357
+ isConflict(equation: Equation) {
358
+ return equation.poly.isVal() && !this.isTrivial(equation);
359
+ }
360
+
361
+ checkConflict(equation: Equation) {
362
+ if (!this.isConflict(equation)) return false;
363
+ this.setConflict(equation);
364
+ return true;
365
+ }
366
+
367
+ setConflict(equation: Equation) {
368
+ this.conflict = equation;
369
+ this.pushEquation(SOLVED, equation);
370
+ }
371
+
372
+ private isSimpler(first: Equation, second: Equation) {
373
+ return this.manager.lmLt(first.poly, second.poly);
374
+ }
375
+
376
+ private isTooComplex(poly: Pdd) {
377
+ return (
378
+ poly.treeSize() > this.config.exprSizeLimit || poly.degree() > this.config.exprDegreeLimit
379
+ );
380
+ }
381
+
382
+ private getQueue(state: number) {
383
+ if (state === PROCESSED) return this.processed;
384
+ return state === TO_SIMPLIFY ? this.toSimplify : this.solved;
385
+ }
386
+
387
+ popEquation(equation: Equation) {
388
+ const set = this.getQueue(equation.state);
389
+ const last = set[set.length - 1];
390
+ if (equation.idx !== set.length - 1) {
391
+ last.idx = equation.idx;
392
+ set[equation.idx] = last;
393
+ }
394
+ set.pop();
395
+ }
396
+
397
+ pushEquation(state: number, equation: Equation) {
398
+ equation.state = state;
399
+ const set = this.getQueue(state);
400
+ equation.idx = set.length;
401
+ set.push(equation);
402
+ }
403
+
404
+ private updateStats(equation: Equation) {
405
+ this.stats.maxExprSize = Math.max(this.stats.maxExprSize, equation.poly.treeSize());
406
+ this.stats.maxExprDegree = Math.max(this.stats.maxExprDegree, equation.poly.degree());
407
+ }
408
+ }