tla-ts 0.0.9 → 0.0.10-dev.06b481ee0

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 (631) hide show
  1. package/README.md +30 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +48 -44
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +122 -12
  8. package/dist/index.d.ts +122 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2746 -410
  15. package/dist/prove.js +2745 -409
  16. package/dist/run.cjs +144 -31
  17. package/dist/run.js +144 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +134 -104
  21. package/dist/transfer.js +134 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +56 -60
  26. package/src/bags.ts +128 -110
  27. package/src/builtins.ts +31 -77
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +118 -0
  30. package/src/check-trace.ts +320 -0
  31. package/src/check.ts +1156 -888
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +100 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +433 -82
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +701 -0
  39. package/src/cli/tlc-usage.ts +360 -0
  40. package/src/cli/tlc.ts +330 -659
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +217 -82
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +1019 -0
  47. package/src/dependencies.ts +101 -66
  48. package/src/dfid.ts +683 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +263 -370
  51. package/src/errors.ts +107 -57
  52. package/src/evaluate.ts +898 -369
  53. package/src/exit-codes.ts +63 -13
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +137 -22
  57. package/src/java-hash.ts +21 -0
  58. package/src/java-overrides.ts +6 -21
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +231 -154
  62. package/src/lexer.ts +83 -101
  63. package/src/liveness-checker.ts +743 -322
  64. package/src/liveness.ts +230 -133
  65. package/src/obligations/action.ts +17 -44
  66. package/src/obligations/anonymize.ts +120 -95
  67. package/src/obligations/enabled-axioms.ts +218 -0
  68. package/src/obligations/equality.ts +1 -3
  69. package/src/obligations/expression.ts +37 -26
  70. package/src/obligations/format.ts +0 -10
  71. package/src/obligations/generate.ts +66 -64
  72. package/src/obligations/index.ts +39 -20
  73. package/src/obligations/levels.ts +27 -18
  74. package/src/obligations/module.ts +28 -55
  75. package/src/obligations/normalize.ts +31 -41
  76. package/src/obligations/operators.ts +0 -3
  77. package/src/obligations/pragma.ts +52 -24
  78. package/src/obligations/printer.ts +94 -63
  79. package/src/obligations/proof.ts +3 -6
  80. package/src/obligations/regroup.ts +0 -5
  81. package/src/obligations/simplify.ts +57 -63
  82. package/src/obligations/source.ts +121 -95
  83. package/src/obligations/subexpression.ts +49 -28
  84. package/src/obligations/substitution.ts +1 -5
  85. package/src/obligations/temporal.ts +12 -20
  86. package/src/obligations/tuples.ts +2 -10
  87. package/src/parallel-worker.ts +36 -60
  88. package/src/parallel.ts +64 -73
  89. package/src/parser.ts +1184 -531
  90. package/src/pcal/ast.ts +53 -86
  91. package/src/pcal/parse.ts +144 -219
  92. package/src/pcal/tokenize.ts +91 -131
  93. package/src/pcal/translate.ts +83 -130
  94. package/src/pcal/validate.ts +48 -68
  95. package/src/pretty-print.ts +7 -8
  96. package/src/prover/decide-pool.ts +8 -13
  97. package/src/prover/deciders.ts +12 -13
  98. package/src/prover/first-order.ts +0 -11
  99. package/src/prover/isabelle/decide.ts +3 -31
  100. package/src/prover/isabelle/encode.ts +82 -64
  101. package/src/prover/isabelle/isar/attrib.ts +250 -0
  102. package/src/prover/isabelle/isar/context.ts +335 -0
  103. package/src/prover/isabelle/isar/induct.ts +382 -0
  104. package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
  105. package/src/prover/isabelle/isar/method.ts +510 -226
  106. package/src/prover/isabelle/isar/proof.ts +570 -23
  107. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  108. package/src/prover/isabelle/isar/theory.ts +488 -88
  109. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  110. package/src/prover/isabelle/isar/type-check.ts +99 -38
  111. package/src/prover/isabelle/provers/blast/blast.ts +16 -105
  112. package/src/prover/isabelle/provers/blast/branch.ts +0 -33
  113. package/src/prover/isabelle/provers/blast/prove.ts +0 -36
  114. package/src/prover/isabelle/provers/blast/rules.ts +5 -45
  115. package/src/prover/isabelle/provers/blast/state.ts +1 -29
  116. package/src/prover/isabelle/provers/blast/term.ts +8 -37
  117. package/src/prover/isabelle/provers/clasimp.ts +1 -15
  118. package/src/prover/isabelle/provers/classical.ts +58 -61
  119. package/src/prover/isabelle/provers/hypsubst.ts +29 -54
  120. package/src/prover/isabelle/pure/bicompose.ts +24 -39
  121. package/src/prover/isabelle/pure/consts.ts +0 -8
  122. package/src/prover/isabelle/pure/conv.ts +2 -18
  123. package/src/prover/isabelle/pure/drule.ts +95 -45
  124. package/src/prover/isabelle/pure/envir.ts +2 -53
  125. package/src/prover/isabelle/pure/goal.ts +1 -9
  126. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  127. package/src/prover/isabelle/pure/list.ts +0 -3
  128. package/src/prover/isabelle/pure/logic.ts +1 -16
  129. package/src/prover/isabelle/pure/name.ts +1 -10
  130. package/src/prover/isabelle/pure/net.ts +2 -60
  131. package/src/prover/isabelle/pure/object-logic.ts +15 -16
  132. package/src/prover/isabelle/pure/pattern.ts +1 -20
  133. package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
  134. package/src/prover/isabelle/pure/rewriter.ts +34 -77
  135. package/src/prover/isabelle/pure/search.ts +2 -11
  136. package/src/prover/isabelle/pure/seq.ts +0 -11
  137. package/src/prover/isabelle/pure/simplifier.ts +27 -16
  138. package/src/prover/isabelle/pure/table.ts +2 -33
  139. package/src/prover/isabelle/pure/tactic.ts +11 -23
  140. package/src/prover/isabelle/pure/tactical.ts +47 -48
  141. package/src/prover/isabelle/pure/term-ord.ts +1 -7
  142. package/src/prover/isabelle/pure/term.ts +4 -47
  143. package/src/prover/isabelle/pure/thm.ts +26 -48
  144. package/src/prover/isabelle/pure/type.ts +1 -16
  145. package/src/prover/isabelle/pure/unify.ts +19 -31
  146. package/src/prover/isabelle/pure/variable.ts +2 -8
  147. package/src/prover/isabelle/tla/classical-setup.ts +17 -25
  148. package/src/prover/isabelle/tla/context.ts +65 -26
  149. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  150. package/src/prover/isabelle/tla/logic.ts +53 -32
  151. package/src/prover/isabelle/tla/simpdata.ts +45 -44
  152. package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
  153. package/src/prover/ocaml.ts +4 -7
  154. package/src/prover/prep/action.ts +33 -66
  155. package/src/prover/prep/enabled-axioms.ts +22 -20
  156. package/src/prover/prep/fingerprint.ts +2 -21
  157. package/src/prover/prep/level-comparison.ts +8 -12
  158. package/src/prover/prep/md5.ts +26 -31
  159. package/src/prover/prep/methods.ts +189 -86
  160. package/src/prover/prep/normalize.ts +42 -37
  161. package/src/prover/prove-worker.ts +0 -2
  162. package/src/prover/prove.ts +398 -133
  163. package/src/prover/ptl/decide.ts +96 -56
  164. package/src/prover/ptl/encode.ts +15 -38
  165. package/src/prover/ptl/sat.ts +24 -32
  166. package/src/prover/ptl/tableau.ts +40 -28
  167. package/src/prover/smt/arithmetic.ts +310 -0
  168. package/src/prover/smt/axioms.ts +12 -15
  169. package/src/prover/smt/context.ts +60 -32
  170. package/src/prover/smt/data.ts +517 -401
  171. package/src/prover/smt/encode.ts +155 -85
  172. package/src/prover/smt/extensionality.ts +5 -13
  173. package/src/prover/smt/flatten.ts +7 -28
  174. package/src/prover/smt/format.ts +33 -14
  175. package/src/prover/smt/instances.ts +7 -11
  176. package/src/prover/smt/layout.ts +91 -0
  177. package/src/prover/smt/rewrite.ts +1021 -658
  178. package/src/prover/smt/simplify.ts +441 -0
  179. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  180. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  181. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  182. package/src/prover/smt/solver/act-cache.ts +0 -16
  183. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  184. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  185. package/src/prover/smt/solver/aig.ts +889 -0
  186. package/src/prover/smt/solver/arith-rewriter.ts +626 -56
  187. package/src/prover/smt/solver/arith-terms.ts +121 -0
  188. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  189. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  190. package/src/prover/smt/solver/array.ts +1 -3
  191. package/src/prover/smt/solver/asserted-formulas.ts +241 -99
  192. package/src/prover/smt/solver/ast-lt.ts +165 -21
  193. package/src/prover/smt/solver/ast-util.ts +160 -7
  194. package/src/prover/smt/solver/ast.ts +1480 -184
  195. package/src/prover/smt/solver/auf-solver.ts +30 -56
  196. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  197. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  198. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  199. package/src/prover/smt/solver/bound-manager.ts +196 -0
  200. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  201. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  202. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  203. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  204. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  205. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  206. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  207. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  208. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  209. package/src/prover/smt/solver/card2bv.ts +127 -0
  210. package/src/prover/smt/solver/case-split-queue.ts +0 -10
  211. package/src/prover/smt/solver/cg-table.ts +39 -42
  212. package/src/prover/smt/solver/check-logic.ts +330 -0
  213. package/src/prover/smt/solver/clause.ts +0 -27
  214. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  215. package/src/prover/smt/solver/conflict-resolution.ts +78 -11
  216. package/src/prover/smt/solver/context.ts +600 -187
  217. package/src/prover/smt/solver/ctx-simplify.ts +34 -52
  218. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  219. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  220. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  221. package/src/prover/smt/solver/demodulator.ts +786 -0
  222. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  223. package/src/prover/smt/solver/der.ts +39 -30
  224. package/src/prover/smt/solver/diff-neq.ts +205 -0
  225. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  226. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  227. package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
  228. package/src/prover/smt/solver/dyn-ack.ts +0 -11
  229. package/src/prover/smt/solver/e-matching.ts +9 -41
  230. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  231. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  232. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  233. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  234. package/src/prover/smt/solver/enode.ts +100 -23
  235. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  236. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  237. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  238. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  239. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  240. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  241. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  242. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  243. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  244. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  245. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  246. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  247. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  248. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  249. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  250. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  251. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  252. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  253. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  254. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  255. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  256. package/src/prover/smt/solver/expr-ref.ts +0 -5
  257. package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
  258. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  259. package/src/prover/smt/solver/factor.ts +163 -0
  260. package/src/prover/smt/solver/fd-solver.ts +734 -0
  261. package/src/prover/smt/solver/fingerprints.ts +15 -26
  262. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  263. package/src/prover/smt/solver/flat-literals.ts +0 -9
  264. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  265. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  266. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  267. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  268. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  269. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  270. package/src/prover/smt/solver/goal.ts +179 -28
  271. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  272. package/src/prover/smt/solver/guard-set.ts +219 -0
  273. package/src/prover/smt/solver/hash.ts +0 -9
  274. package/src/prover/smt/solver/hashtable.ts +30 -23
  275. package/src/prover/smt/solver/inf-eps.ts +63 -0
  276. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  277. package/src/prover/smt/solver/internalizer.ts +113 -133
  278. package/src/prover/smt/solver/lackr.ts +381 -0
  279. package/src/prover/smt/solver/lbool.ts +0 -2
  280. package/src/prover/smt/solver/lia2card.ts +268 -0
  281. package/src/prover/smt/solver/lia2pb.ts +154 -0
  282. package/src/prover/smt/solver/literal.ts +0 -4
  283. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  284. package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
  285. package/src/prover/smt/solver/lp/constraints.ts +1 -8
  286. package/src/prover/smt/solver/lp/containers.ts +18 -31
  287. package/src/prover/smt/solver/lp/core-solver.ts +35 -37
  288. package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
  289. package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
  290. package/src/prover/smt/solver/lp/dependency.ts +0 -5
  291. package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
  292. package/src/prover/smt/solver/lp/explanation.ts +0 -6
  293. package/src/prover/smt/solver/lp/gomory.ts +8 -22
  294. package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
  295. package/src/prover/smt/solver/lp/hnf.ts +10 -28
  296. package/src/prover/smt/solver/lp/int-cube.ts +17 -39
  297. package/src/prover/smt/solver/lp/int-solver.ts +3 -35
  298. package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
  299. package/src/prover/smt/solver/lp/lar-term.ts +0 -5
  300. package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
  301. package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
  302. package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
  303. package/src/prover/smt/solver/lp/nex.ts +2 -7
  304. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
  305. package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
  306. package/src/prover/smt/solver/lp/nla-core.ts +92 -136
  307. package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
  308. package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
  309. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
  310. package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
  311. package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
  312. package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
  313. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
  314. package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
  315. package/src/prover/smt/solver/lp/nla-order.ts +0 -13
  316. package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
  317. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  318. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
  319. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
  320. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  321. package/src/prover/smt/solver/lp/nla-types.ts +0 -12
  322. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
  323. package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
  324. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
  325. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
  326. package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
  327. package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
  328. package/src/prover/smt/solver/lp/pdd.ts +730 -358
  329. package/src/prover/smt/solver/lp/random-updater.ts +0 -9
  330. package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
  331. package/src/prover/smt/solver/lp/union-find.ts +5 -5
  332. package/src/prover/smt/solver/macro-finder.ts +530 -0
  333. package/src/prover/smt/solver/mam-compiler.ts +129 -139
  334. package/src/prover/smt/solver/mam-interpreter.ts +0 -21
  335. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  336. package/src/prover/smt/solver/max-cliques.ts +105 -0
  337. package/src/prover/smt/solver/maxcore.ts +310 -0
  338. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
  339. package/src/prover/smt/solver/maxlex.ts +115 -0
  340. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  341. package/src/prover/smt/solver/maxsmt.ts +92 -0
  342. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  343. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  344. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  345. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  346. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  347. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  348. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  349. package/src/prover/smt/solver/model-checker.ts +20 -63
  350. package/src/prover/smt/solver/model-evaluator.ts +192 -40
  351. package/src/prover/smt/solver/model-finder.ts +14 -32
  352. package/src/prover/smt/solver/model-generator.ts +104 -46
  353. package/src/prover/smt/solver/model-macro-solver.ts +60 -114
  354. package/src/prover/smt/solver/model-printer.ts +214 -0
  355. package/src/prover/smt/solver/mpf.ts +709 -0
  356. package/src/prover/smt/solver/mus.ts +50 -0
  357. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  358. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  359. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  360. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  361. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  362. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  363. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  364. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  365. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  366. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  367. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  368. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  369. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  370. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  371. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  372. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  373. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  374. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  375. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  376. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  377. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  378. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  379. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  380. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  381. package/src/prover/smt/solver/nlqsat.ts +484 -0
  382. package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
  383. package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
  384. package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
  385. package/src/prover/smt/solver/nlsat/explain.ts +429 -275
  386. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
  387. package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
  388. package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
  389. package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
  390. package/src/prover/smt/solver/nlsat/solver.ts +297 -156
  391. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  392. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  393. package/src/prover/smt/solver/nlsat/types.ts +0 -9
  394. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
  395. package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
  396. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  397. package/src/prover/smt/solver/nnf.ts +112 -61
  398. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  399. package/src/prover/smt/solver/occf.ts +97 -0
  400. package/src/prover/smt/solver/opt-context.ts +801 -0
  401. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  402. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  403. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  404. package/src/prover/smt/solver/opt-solver.ts +312 -0
  405. package/src/prover/smt/solver/opt-value.ts +55 -0
  406. package/src/prover/smt/solver/optsmt.ts +692 -0
  407. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  408. package/src/prover/smt/solver/pattern-inference.ts +21 -26
  409. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  410. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  411. package/src/prover/smt/solver/poly-rewriter.ts +261 -79
  412. package/src/prover/smt/solver/probes.ts +577 -0
  413. package/src/prover/smt/solver/propagate-values.ts +37 -30
  414. package/src/prover/smt/solver/proto-model.ts +650 -66
  415. package/src/prover/smt/solver/pull-quant.ts +28 -23
  416. package/src/prover/smt/solver/purify-arith.ts +632 -0
  417. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  418. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  419. package/src/prover/smt/solver/qe-lite-der.ts +2 -31
  420. package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
  421. package/src/prover/smt/solver/qe-lite.ts +41 -51
  422. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  423. package/src/prover/smt/solver/qe.ts +1499 -0
  424. package/src/prover/smt/solver/qel.ts +25 -0
  425. package/src/prover/smt/solver/qi-queue.ts +0 -16
  426. package/src/prover/smt/solver/qsat.ts +829 -0
  427. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  428. package/src/prover/smt/solver/quant-tactics.ts +17 -74
  429. package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
  430. package/src/prover/smt/solver/quantifier-manager.ts +22 -32
  431. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  432. package/src/prover/smt/solver/random-gen.ts +0 -2
  433. package/src/prover/smt/solver/rational.ts +45 -8
  434. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  435. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  436. package/src/prover/smt/solver/reduce-args.ts +225 -0
  437. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  438. package/src/prover/smt/solver/ref-vector.ts +0 -6
  439. package/src/prover/smt/solver/relevancy.ts +2 -16
  440. package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
  441. package/src/prover/smt/solver/rewriter.ts +507 -144
  442. package/src/prover/smt/solver/rlimit.ts +46 -24
  443. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  444. package/src/prover/smt/solver/sat/big.ts +177 -0
  445. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  446. package/src/prover/smt/solver/sat/clause.ts +203 -0
  447. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  448. package/src/prover/smt/solver/sat/config.ts +122 -0
  449. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  450. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  451. package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
  452. package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
  453. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  454. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  455. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  456. package/src/prover/smt/solver/sat/probing.ts +170 -0
  457. package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
  458. package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
  459. package/src/prover/smt/solver/sat/scc.ts +142 -0
  460. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  461. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  462. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  463. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  464. package/src/prover/smt/solver/search-tree.ts +284 -0
  465. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  466. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  467. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  468. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  469. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  470. package/src/prover/smt/solver/seq-factory.ts +89 -0
  471. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  472. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  473. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  474. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  475. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  476. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  477. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  478. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  479. package/src/prover/smt/solver/seq-subset.ts +165 -0
  480. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  481. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  482. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  483. package/src/prover/smt/solver/smt-logics.ts +66 -0
  484. package/src/prover/smt/solver/smt-setup.ts +589 -0
  485. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  486. package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
  487. package/src/prover/smt/solver/smtlib-script.ts +2134 -0
  488. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  489. package/src/prover/smt/solver/solver.ts +135 -40
  490. package/src/prover/smt/solver/sort.ts +1 -5
  491. package/src/prover/smt/solver/static-features.ts +314 -0
  492. package/src/prover/smt/solver/sticky-generations.ts +0 -6
  493. package/src/prover/smt/solver/tactic.ts +2141 -0
  494. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  495. package/src/prover/smt/solver/theory-array.ts +1240 -0
  496. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  497. package/src/prover/smt/solver/theory-char.ts +355 -0
  498. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  499. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  500. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  501. package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
  502. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
  503. package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
  504. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
  505. package/src/prover/smt/solver/theory-lra-model.ts +23 -53
  506. package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
  507. package/src/prover/smt/solver/theory-lra-state.ts +7 -28
  508. package/src/prover/smt/solver/theory-lra.ts +189 -9
  509. package/src/prover/smt/solver/theory-pb.ts +951 -0
  510. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  511. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  512. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  513. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  514. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  515. package/src/prover/smt/solver/theory-seq.ts +961 -0
  516. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  517. package/src/prover/smt/solver/theory.ts +189 -0
  518. package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
  519. package/src/prover/smt/solver/var-subst.ts +37 -39
  520. package/src/prover/smt/table.ts +3 -10
  521. package/src/prover/smt/types.ts +146 -0
  522. package/src/prover/tlapm/cache.ts +74 -48
  523. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  524. package/src/prover/tlapm/tlapm.ts +21 -20
  525. package/src/prover/tlapm-library.ts +3208 -0
  526. package/src/prover/verdict.ts +9 -2
  527. package/src/prover/zenon/check/check.ts +1 -11
  528. package/src/prover/zenon/check/definitions.ts +5 -15
  529. package/src/prover/zenon/check/equality.ts +0 -8
  530. package/src/prover/zenon/check/functions.ts +0 -4
  531. package/src/prover/zenon/check/keys.ts +0 -7
  532. package/src/prover/zenon/check/propositional.ts +0 -3
  533. package/src/prover/zenon/check/records.ts +1 -6
  534. package/src/prover/zenon/check/relations.ts +2 -14
  535. package/src/prover/zenon/check/rewrites.ts +2 -21
  536. package/src/prover/zenon/check/sets.ts +40 -61
  537. package/src/prover/zenon/check/terms.ts +1 -19
  538. package/src/prover/zenon/check/tla.ts +0 -6
  539. package/src/prover/zenon/decide.ts +10 -19
  540. package/src/prover/zenon/encode.ts +0 -9
  541. package/src/prover/zenon/eqrel.ts +2 -15
  542. package/src/prover/zenon/equality-rules.ts +24 -6
  543. package/src/prover/zenon/expr.ts +29 -28
  544. package/src/prover/zenon/index-table.ts +33 -61
  545. package/src/prover/zenon/isar-case.ts +9 -21
  546. package/src/prover/zenon/isar.ts +37 -67
  547. package/src/prover/zenon/limits.ts +0 -4
  548. package/src/prover/zenon/llproof.ts +2 -22
  549. package/src/prover/zenon/mltoll.ts +66 -106
  550. package/src/prover/zenon/node.ts +20 -15
  551. package/src/prover/zenon/ocaml.ts +1 -17
  552. package/src/prover/zenon/parse.ts +9 -13
  553. package/src/prover/zenon/phrase.ts +2 -14
  554. package/src/prover/zenon/proof.ts +0 -11
  555. package/src/prover/zenon/propositional-rules.ts +0 -7
  556. package/src/prover/zenon/rules.ts +3 -8
  557. package/src/prover/zenon/search.ts +11 -35
  558. package/src/prover/zenon/tla/functions.ts +59 -33
  559. package/src/prover/zenon/tla/llproof.ts +67 -78
  560. package/src/prover/zenon/tla/records.ts +57 -35
  561. package/src/prover/zenon/tla/rewrites.ts +12 -21
  562. package/src/prover/zenon/tla/sets.ts +88 -59
  563. package/src/prover/zenon/tla/terms.ts +0 -8
  564. package/src/prover/zenon/tla/tla.ts +66 -66
  565. package/src/randomization.ts +81 -35
  566. package/src/resolve.ts +1132 -430
  567. package/src/runtime.ts +33 -23
  568. package/src/sany/builtins.ts +11 -14
  569. package/src/sany/generation.ts +383 -0
  570. package/src/sany/generator-def-entries.ts +210 -0
  571. package/src/sany/generator-definitions.ts +688 -0
  572. package/src/sany/generator-expressions.ts +1108 -0
  573. package/src/sany/generator-proofs.ts +665 -0
  574. package/src/sany/generator.ts +192 -2764
  575. package/src/sany/levels.ts +5 -35
  576. package/src/sany/lexer.ts +61 -80
  577. package/src/sany/linter.ts +0 -10
  578. package/src/sany/modules.ts +5 -7
  579. package/src/sany/nodes.ts +6 -44
  580. package/src/sany/parse-error.ts +39 -117
  581. package/src/sany/report.ts +32 -69
  582. package/src/sany/selectors.ts +60 -82
  583. package/src/sany/source.ts +1 -17
  584. package/src/sany/xml.ts +37 -120
  585. package/src/search.ts +913 -227
  586. package/src/simulate.ts +765 -0
  587. package/src/spec-description.ts +198 -104
  588. package/src/standard-definitions.ts +4 -4
  589. package/src/standard-modules.ts +302 -99
  590. package/src/state-graph.ts +52 -33
  591. package/src/subexpressions.ts +578 -166
  592. package/src/substitution-levels.ts +7 -7
  593. package/src/successors.ts +299 -108
  594. package/src/symmetry.ts +37 -28
  595. package/src/tableau.ts +29 -26
  596. package/src/tlc/fingerprint.ts +267 -79
  597. package/src/tlc/jar-data.ts +122 -6
  598. package/src/tlc/messages.ts +127 -56
  599. package/src/tlc/order.ts +53 -72
  600. package/src/tlc/random.ts +38 -49
  601. package/src/tlc/replay.ts +579 -230
  602. package/src/tlc/summary.ts +64 -60
  603. package/src/tlc/tlc-operators.ts +83 -47
  604. package/src/tlc/tlcext-operators.ts +205 -127
  605. package/src/tlc/trace-spec.ts +235 -0
  606. package/src/tlc/value-stream.ts +139 -0
  607. package/src/tlc/version.ts +1 -4
  608. package/src/trace-liveness.ts +529 -0
  609. package/src/transfer.ts +22 -25
  610. package/src/typed-tier.ts +6556 -0
  611. package/src/typescript/actions.ts +479 -0
  612. package/src/typescript/collections.ts +614 -0
  613. package/src/typescript/compile.ts +63 -0
  614. package/src/typescript/context.ts +94 -0
  615. package/src/typescript/emit.ts +121 -0
  616. package/src/typescript/expressions.ts +496 -0
  617. package/src/typescript/formula.ts +154 -0
  618. package/src/typescript/functions.ts +284 -0
  619. package/src/typescript/model.ts +162 -0
  620. package/src/typescript/names.ts +114 -0
  621. package/src/typescript/program.ts +48 -0
  622. package/src/typescript/properties.ts +139 -0
  623. package/src/typescript/scope.ts +112 -0
  624. package/src/typescript/steps.ts +167 -0
  625. package/src/typescript/types.ts +171 -0
  626. package/src/values.ts +945 -526
  627. package/src/worker.ts +7 -8
  628. package/src/prover/isabelle/isar/statement.ts +0 -57
  629. package/src/prover/smt/solver/z3-license.txt +0 -10
  630. package/src/prover/tlaps-module.ts +0 -510
  631. package/src/prover/zenon/LICENSE +0 -32
@@ -1,12 +1,3 @@
1
- // Ported from Z3 (src/math/dd/dd_pdd.h, src/math/dd/dd_pdd.cpp, src/math/dd/pdd_eval.h), MIT
2
- // license, see z3-license.txt. Polynomial decision diagrams over the rationals, which nla's Grobner
3
- // solver works on: a node is x*hi + lo for the variable x at its level, lo has no x, and the leaves
4
- // are values. Only the free semantics is ported, the one nla and dd::solver use: not mod2, mod2N or
5
- // zero_one_vars, nor what only those or polysat use (the boolean operations, substitution of
6
- // values, resolve, quot_rem, and division without the inverse). Nodes are never freed, so there is
7
- // no garbage collection: node indices match Z3's until its first collection, and the node limit
8
- // counts every node made. The op cache keys on both operands, where Z3's eq_entry compares the
9
- // first operand of one entry with the second of the other.
10
1
  import { PddMemoryOutError } from "../../../../errors";
11
2
  import { getGcd, Rational } from "../rational";
12
3
  import { shrink } from "../array";
@@ -18,9 +9,8 @@ const SUB_OP = 3;
18
9
  const MINUS_OP = 4;
19
10
  const MUL_OP = 5;
20
11
  const REDUCE_OP = 6;
21
- // Nodes below this index stand for the operations in the op cache, besides 0 and 1.
22
12
  const NO_OP = 10;
23
- const INITIAL_FREE_NODES = 1024;
13
+ const MAX_RC = (1 << 10) - 1;
24
14
 
25
15
  interface PddMonomial {
26
16
  coeff: Rational;
@@ -37,9 +27,9 @@ interface PddPower {
37
27
  degree: number;
38
28
  }
39
29
 
40
- interface PddFactor {
41
- lc: Pdd;
42
- rest: Pdd;
30
+ interface FactorEntry {
31
+ lc: number;
32
+ rest: number;
43
33
  }
44
34
 
45
35
  interface PddVarFactors {
@@ -59,81 +49,99 @@ interface CommonFactors {
59
49
  secondCoeff: Rational;
60
50
  }
61
51
 
52
+ const getNodeKey = (level: number, lo: number, hi: number) => `${level},${lo},${hi}`;
53
+
62
54
  export class PddManager {
63
55
  private levels: number[] = [];
64
56
  private los: number[] = [];
65
57
  private his: number[] = [];
58
+ private refcounts: number[] = [];
66
59
  private values: Rational[] = [];
60
+ private opCache = new Map<number, number>();
61
+ private factorCache = new Map<string, FactorEntry>();
67
62
  private nodeTable = new Map<string, number>();
68
63
  private valueTable = new Map<string, number>();
69
- private opCache = new Map<string, number>();
70
- private factorCache = new Map<string, PddFactor>();
71
- private degrees: number[] = [];
72
- private numAllocated = 0;
73
- private maxNumNodes = 1 << 24;
74
- private isApplying = false;
75
- var2pdd: number[] = [];
64
+ private pddStack: number[] = [];
65
+ private pddStackSize = 0;
66
+ private var2pdd: number[] = [];
76
67
  var2level: number[] = [];
77
68
  level2var: number[] = [];
69
+ private freeNodes: number[] = [];
70
+ private dmarks: number[] = [];
71
+ private dmarkLevel = 0;
72
+ private degrees: number[] = [];
73
+ private degreeTodo: number[] = [];
74
+ private maxNumNodes = 1 << 24;
75
+ private freeValues: number[] = [];
76
+ private freezeValue = Rational.zero;
78
77
 
79
78
  constructor(numVars: number) {
80
- this.initNodes(Array.from({ length: numVars }, (_, index) => index));
79
+ this.initNodes(Array.from({ length: numVars }, (_value, index) => index));
81
80
  }
82
81
 
83
82
  reset(level2var: number[]) {
83
+ this.opCache.clear();
84
+ this.factorCache.clear();
85
+ this.nodeTable.clear();
84
86
  this.levels = [];
85
87
  this.los = [];
86
88
  this.his = [];
89
+ this.refcounts = [];
90
+ this.dmarks = [];
91
+ this.degrees = [];
92
+ this.freeNodes = [];
93
+ this.pddStackSize = 0;
87
94
  this.values = [];
88
- this.nodeTable.clear();
95
+ this.freeValues = [];
89
96
  this.valueTable.clear();
90
- this.opCache.clear();
91
- this.factorCache.clear();
92
- this.degrees = [];
93
97
  this.initNodes(level2var);
94
98
  }
95
99
 
100
+ setMaxNumNodes(limit: number) {
101
+ this.maxNumNodes = limit + this.level2var.length;
102
+ }
103
+
104
+ numNodes() {
105
+ return this.levels.length - this.freeNodes.length;
106
+ }
107
+
96
108
  private initNodes(level2var: number[]) {
97
109
  for (let index = 0; index < NO_OP; index++) {
98
110
  this.levels.push(0);
99
111
  this.los.push(0);
100
112
  this.his.push(0);
113
+ this.refcounts.push(MAX_RC);
114
+ this.dmarks.push(0);
115
+ this.degrees.push(0);
101
116
  }
102
117
  this.los[ONE_PDD] = 1;
103
118
  this.values.push(Rational.zero, Rational.one);
104
- this.numAllocated = NO_OP + INITIAL_FREE_NODES + level2var.length;
105
- this.var2pdd = [];
106
- this.var2level = [];
107
- this.level2var = [];
108
- for (let level = 0; level < level2var.length; level++) {
119
+ this.allocFreeNodes(1024 + level2var.length);
120
+ this.initVars(level2var);
121
+ }
122
+
123
+ private initVars(level2var: number[]) {
124
+ const count = level2var.length;
125
+ this.level2var = Array.from({ length: count }, () => 0);
126
+ this.var2level = Array.from({ length: count }, () => 0);
127
+ this.var2pdd = Array.from({ length: count }, () => 0);
128
+ for (let level = 0; level < count; level++) {
109
129
  const variable = level2var[level];
110
130
  this.var2pdd[variable] = this.makeNode(level, ZERO_PDD, ONE_PDD);
131
+ this.refcounts[this.var2pdd[variable]] = MAX_RC;
111
132
  this.var2level[variable] = level;
112
133
  this.level2var[level] = variable;
113
134
  }
114
135
  }
115
136
 
116
- setMaxNumNodes(limit: number) {
117
- this.maxNumNodes = limit + this.level2var.length;
118
- }
119
-
120
- numNodes() {
121
- return this.levels.length;
122
- }
123
-
124
- numVars() {
125
- return this.var2pdd.length;
126
- }
127
-
128
137
  isVal(node: number) {
129
138
  return this.his[node] === 0;
130
139
  }
131
140
 
132
- level(node: number) {
141
+ private level(node: number) {
133
142
  return this.levels[node];
134
143
  }
135
144
 
136
- // A value node is at level 0, so its var is the lowest variable, as in Z3.
137
145
  var(node: number) {
138
146
  return this.level2var[this.levels[node]];
139
147
  }
@@ -150,19 +158,26 @@ export class PddManager {
150
158
  return this.values[this.los[node]];
151
159
  }
152
160
 
153
- offset(node: number) {
154
- let current = node;
155
- while (!this.isVal(current)) current = this.lo(current);
156
- return this.val(current);
161
+ incRef(node: number) {
162
+ if (this.refcounts[node] !== MAX_RC) this.refcounts[node]++;
157
163
  }
158
164
 
159
- mkVar(variable: number) {
165
+ decRef(node: number) {
166
+ if (this.refcounts[node] !== MAX_RC) this.refcounts[node]--;
167
+ }
168
+
169
+ private reserveVar(variable: number) {
160
170
  while (this.var2level.length <= variable) {
161
171
  const next = this.var2level.length;
162
172
  this.var2pdd.push(this.makeNode(next, ZERO_PDD, ONE_PDD));
173
+ this.refcounts[this.var2pdd[next]] = MAX_RC;
163
174
  this.var2level.push(next);
164
175
  this.level2var.push(next);
165
176
  }
177
+ }
178
+
179
+ mkVar(variable: number) {
180
+ this.reserveVar(variable);
166
181
  return new Pdd(this, this.var2pdd[variable]);
167
182
  }
168
183
 
@@ -174,7 +189,7 @@ export class PddManager {
174
189
  return new Pdd(this, ZERO_PDD);
175
190
  }
176
191
 
177
- one() {
192
+ private one() {
178
193
  return new Pdd(this, ONE_PDD);
179
194
  }
180
195
 
@@ -194,165 +209,230 @@ export class PddManager {
194
209
  return new Pdd(this, this.apply(first.root, second.root, REDUCE_OP));
195
210
  }
196
211
 
212
+ mulValue(value: Rational, poly: Pdd) {
213
+ const constant = this.mkVal(value);
214
+ const result = new Pdd(this, this.apply(constant.root, poly.root, MUL_OP));
215
+ constant.release();
216
+ return result;
217
+ }
218
+
219
+ addValue(value: Rational, poly: Pdd) {
220
+ const constant = this.mkVal(value);
221
+ const result = new Pdd(this, this.apply(constant.root, poly.root, ADD_OP));
222
+ constant.release();
223
+ return result;
224
+ }
225
+
197
226
  minus(poly: Pdd) {
198
- return new Pdd(
199
- this,
200
- this.whileApplying(() => this.minusRec(poly.root)),
201
- );
227
+ const size = this.pddStackSize;
228
+ try {
229
+ for (let count = 0; ; count++) {
230
+ try {
231
+ return new Pdd(this, this.minusRec(poly.root));
232
+ } catch (error) {
233
+ if (!(error instanceof PddMemoryOutError)) throw error;
234
+ this.tryGc();
235
+ if (count > 0) this.maxNumNodes *= 2;
236
+ }
237
+ }
238
+ } finally {
239
+ this.pddStackSize = size;
240
+ }
202
241
  }
203
242
 
204
- pow(poly: Pdd, exponent: number): Pdd {
205
- if (exponent === 0) return this.one();
206
- if (exponent === 1 || poly.isZero() || poly.isOne()) return poly;
207
- if (poly.isVal()) return this.mkVal(poly.val().pow(exponent));
208
- // j even: pow(p,2*j') = pow(p*p,j'); j odd: pow(p,2*j'+1) = p*pow(p*p,j')
209
- const half = this.pow(this.mul(poly, poly), Math.floor(exponent / 2));
210
- return exponent % 2 === 1 ? this.mul(half, poly) : half;
243
+ pow(poly: Pdd, exponent: number) {
244
+ return new Pdd(this, this.powNode(poly.root, exponent));
211
245
  }
212
246
 
213
- // apply: operations grow the node limit where Z3 catches mem_out, collects garbage, retries and
214
- // then doubles the limit. Without garbage to collect, only the doubling matters.
215
- private apply(first: number, second: number, op: number) {
216
- return this.whileApplying(() => this.applyRec(first, second, op));
247
+ private powNode(node: number, exponent: number) {
248
+ if (exponent === 0) return ONE_PDD;
249
+ if (exponent === 1) return node;
250
+ if (node === ZERO_PDD) return ZERO_PDD;
251
+ if (node === ONE_PDD) return ONE_PDD;
252
+ if (this.isVal(node)) return this.imkVal(this.val(node).pow(exponent));
253
+ return this.powRec(node, exponent);
217
254
  }
218
255
 
219
- private whileApplying(compute: () => number) {
220
- this.isApplying = true;
256
+ private powRec(node: number, exponent: number): number {
257
+ if (exponent === 1) return node;
258
+ const half = this.powRec(this.apply(node, node, MUL_OP), Math.floor(exponent / 2));
259
+ return exponent % 2 === 1 ? this.apply(half, node, MUL_OP) : half;
260
+ }
261
+
262
+ private apply(first: number, second: number, op: number) {
263
+ const size = this.pddStackSize;
221
264
  try {
222
- return compute();
265
+ for (let count = 0; ; count++) {
266
+ try {
267
+ return this.applyRec(first, second, op);
268
+ } catch (error) {
269
+ if (!(error instanceof PddMemoryOutError)) throw error;
270
+ this.tryGc();
271
+ if (count > 0) this.maxNumNodes *= 2;
272
+ }
273
+ }
223
274
  } finally {
224
- this.isApplying = false;
275
+ this.pddStackSize = size;
225
276
  }
226
277
  }
227
278
 
228
279
  private applyRec(first: number, second: number, op: number): number {
280
+ let p = first;
281
+ let q = second;
229
282
  switch (op) {
230
283
  case SUB_OP:
231
- if (second === ZERO_PDD) return first;
232
- if (this.isVal(first) && this.isVal(second)) {
233
- return this.imkVal(this.val(first).sub(this.val(second)));
234
- }
284
+ if (q === ZERO_PDD) return p;
285
+ if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).sub(this.val(q)));
235
286
  break;
236
287
  case ADD_OP:
237
- if (first === ZERO_PDD) return second;
238
- if (second === ZERO_PDD) return first;
239
- if (this.isVal(first) && this.isVal(second)) {
240
- return this.imkVal(this.val(first).add(this.val(second)));
241
- }
242
- if (this.isVal(first) || (!this.isVal(second) && this.level(first) < this.level(second))) {
243
- return this.applyRec(second, first, op);
288
+ if (p === ZERO_PDD) return q;
289
+ if (q === ZERO_PDD) return p;
290
+ if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).add(this.val(q)));
291
+ if (this.isVal(p) || (!this.isVal(q) && this.level(p) < this.level(q))) {
292
+ p = second;
293
+ q = first;
244
294
  }
245
295
  break;
246
296
  case MUL_OP:
247
- if (first === ZERO_PDD || second === ZERO_PDD) return ZERO_PDD;
248
- if (first === ONE_PDD) return second;
249
- if (second === ONE_PDD) return first;
250
- if (this.isVal(first) && this.isVal(second)) {
251
- return this.imkVal(this.val(first).mul(this.val(second)));
252
- }
253
- if (this.isVal(first) || (!this.isVal(second) && this.level(first) < this.level(second))) {
254
- return this.applyRec(second, first, op);
297
+ if (p === ZERO_PDD || q === ZERO_PDD) return ZERO_PDD;
298
+ if (p === ONE_PDD) return q;
299
+ if (q === ONE_PDD) return p;
300
+ if (this.isVal(p) && this.isVal(q)) return this.imkVal(this.val(p).mul(this.val(q)));
301
+ if (this.isVal(p) || (!this.isVal(q) && this.level(p) < this.level(q))) {
302
+ p = second;
303
+ q = first;
255
304
  }
256
305
  break;
257
- case REDUCE_OP:
258
- if (second === ZERO_PDD || this.isVal(first)) return first;
259
- if (this.degree(first) < this.degree(second)) return first;
260
- if (this.level(this.firstLeading(second)) > this.level(first)) return first;
306
+ default:
307
+ if (q === ZERO_PDD || this.isVal(p)) return p;
308
+ if (this.degree(p) < this.degree(q)) return p;
309
+ if (this.level(this.firstLeading(q)) > this.level(p)) return p;
261
310
  break;
262
311
  }
263
- const key = `${op},${first},${second}`;
264
- const cached = this.opCache.get(key);
265
- if (cached !== undefined) return cached;
266
- const result = this.computeApply(first, second, op);
267
- this.opCache.set(key, result);
268
- return result;
269
- }
270
-
271
- private computeApply(first: number, second: number, op: number) {
272
- const firstLevel = this.level(first);
273
- const secondLevel = this.level(second);
274
- const firstLo = this.lo(first);
275
- const firstHi = this.hi(first);
312
+ // Z3's op_entry equality compares the cached first operand with the new second one, so only equal operands hit.
313
+ // Deviation from Z3: on a hash collision Z3 returns that result for unequal operands too.
314
+ const isCached = p === q;
315
+ if (isCached) {
316
+ const cached = this.opCache.get(q * NO_OP + op);
317
+ if (cached !== undefined) return cached;
318
+ }
319
+ let result: number;
320
+ const levelP = this.level(p);
321
+ const levelQ = this.level(q);
322
+ let npop = 2;
276
323
  switch (op) {
277
- case ADD_OP: {
278
- if (this.isVal(second) || firstLevel !== secondLevel) {
279
- return this.makeNode(firstLevel, this.applyRec(firstLo, second, op), firstHi);
280
- }
281
- const lo = this.applyRec(firstLo, this.lo(second), op);
282
- return this.makeNode(firstLevel, lo, this.applyRec(firstHi, this.hi(second), op));
283
- }
284
- case SUB_OP: {
285
- if (this.isVal(first) || (!this.isVal(second) && firstLevel < secondLevel)) {
286
- // p - (ax + b) = -ax + (p - b)
287
- const lo = this.applyRec(first, this.lo(second), op);
288
- return this.makeNode(secondLevel, lo, this.minusRec(this.hi(second)));
289
- }
290
- if (this.isVal(second) || firstLevel > secondLevel) {
291
- // (ax + b) - k = ax + (b - k)
292
- return this.makeNode(firstLevel, this.applyRec(firstLo, second, op), firstHi);
293
- }
294
- // (ax + b) - (cx + d) = (a - c)x + (b - d)
295
- const lo = this.applyRec(firstLo, this.lo(second), op);
296
- return this.makeNode(firstLevel, lo, this.applyRec(firstHi, this.hi(second), op));
297
- }
298
- case MUL_OP: {
299
- if (this.isVal(second) || firstLevel !== secondLevel) {
300
- // (x*hi(p)+lo(p))*b = x*hi(p)*b + lo(p)*b
301
- const lo = this.applyRec(firstLo, second, op);
302
- return this.makeNode(firstLevel, lo, this.applyRec(firstHi, second, op));
324
+ case ADD_OP:
325
+ if (this.isVal(q)) {
326
+ this.push(this.applyRec(this.lo(p), q, op));
327
+ result = this.makeNode(levelP, this.read(1), this.hi(p));
328
+ npop = 1;
329
+ } else if (levelP === levelQ) {
330
+ this.push(this.applyRec(this.lo(p), this.lo(q), op));
331
+ this.push(this.applyRec(this.hi(p), this.hi(q), op));
332
+ result = this.makeNode(levelP, this.read(2), this.read(1));
333
+ } else {
334
+ this.push(this.applyRec(this.lo(p), q, op));
335
+ result = this.makeNode(levelP, this.read(1), this.hi(p));
336
+ npop = 1;
303
337
  }
304
- // (xa + b)(xc + d) = x(x*ac + ad + bc) + bd, where ad + bc may be x*e + f, so that the
305
- // hi child is x*(ac + e) + f.
306
- const ac = this.applyRec(firstHi, this.hi(second), op);
307
- const ad = this.applyRec(firstHi, this.lo(second), op);
308
- const bc = this.applyRec(firstLo, this.hi(second), op);
309
- const bd = this.applyRec(firstLo, this.lo(second), op);
310
- const sum = this.applyRec(ad, bc, ADD_OP);
311
- if (!this.isVal(sum) && this.level(sum) === firstLevel) {
312
- const hi = this.applyRec(ac, this.hi(sum), ADD_OP);
313
- return this.makeNode(firstLevel, bd, this.makeNode(firstLevel, this.lo(sum), hi));
338
+ break;
339
+ case SUB_OP:
340
+ if (this.isVal(p) || (!this.isVal(q) && levelP < levelQ)) {
341
+ this.push(this.applyRec(p, this.lo(q), op));
342
+ this.push(this.minusRec(this.hi(q)));
343
+ result = this.makeNode(levelQ, this.read(2), this.read(1));
344
+ } else if (this.isVal(q) || levelP > levelQ) {
345
+ this.push(this.applyRec(this.lo(p), q, op));
346
+ result = this.makeNode(levelP, this.read(1), this.hi(p));
347
+ npop = 1;
348
+ } else {
349
+ this.push(this.applyRec(this.lo(p), this.lo(q), op));
350
+ this.push(this.applyRec(this.hi(p), this.hi(q), op));
351
+ result = this.makeNode(levelP, this.read(2), this.read(1));
314
352
  }
315
- return this.makeNode(firstLevel, bd, this.makeNode(firstLevel, sum, ac));
316
- }
317
- default: {
318
- if (this.level(this.firstLeading(second)) >= firstLevel) {
319
- return this.reduceOnMatch(first, second);
353
+ break;
354
+ case MUL_OP:
355
+ if (this.isVal(q) || levelP !== levelQ) {
356
+ this.push(this.applyRec(this.lo(p), q, op));
357
+ this.push(this.applyRec(this.hi(p), q, op));
358
+ result = this.makeNode(levelP, this.read(2), this.read(1));
359
+ } else {
360
+ this.push(this.applyRec(this.hi(p), this.hi(q), op));
361
+ this.push(this.applyRec(this.hi(p), this.lo(q), op));
362
+ this.push(this.applyRec(this.lo(p), this.hi(q), op));
363
+ this.push(this.applyRec(this.lo(p), this.lo(q), op));
364
+ const ac = this.read(4);
365
+ const ad = this.read(3);
366
+ const bc = this.read(2);
367
+ const bd = this.read(1);
368
+ this.push(this.applyRec(ad, bc, ADD_OP));
369
+ const sum = this.read(1);
370
+ if (!this.isVal(sum) && this.level(sum) === levelP) {
371
+ this.push(this.applyRec(ac, this.hi(sum), ADD_OP));
372
+ this.push(this.makeNode(levelP, this.lo(sum), this.read(1)));
373
+ result = this.makeNode(levelP, bd, this.read(1));
374
+ npop = 7;
375
+ } else {
376
+ this.push(this.makeNode(levelP, sum, ac));
377
+ result = this.makeNode(levelP, bd, this.read(1));
378
+ npop = 6;
379
+ }
320
380
  }
321
- const lo = this.applyRec(firstLo, second, op);
322
- const hi = this.applyRec(firstHi, second, op);
323
- if (lo === firstLo && hi === firstHi) return first;
324
- if (this.level(lo) < firstLevel && this.level(hi) <= firstLevel) {
325
- return this.makeNode(firstLevel, lo, hi);
381
+ break;
382
+ default:
383
+ if (this.level(this.firstLeading(q)) < levelP) {
384
+ this.push(this.applyRec(this.lo(p), q, op));
385
+ this.push(this.applyRec(this.hi(p), q, op));
386
+ const lo = this.read(2);
387
+ const hi = this.read(1);
388
+ if (lo === this.lo(p) && hi === this.hi(p)) {
389
+ result = p;
390
+ } else if (this.level(lo) < levelP && this.level(hi) <= levelP) {
391
+ result = this.makeNode(levelP, lo, hi);
392
+ } else {
393
+ this.push(this.applyRec(hi, this.var2pdd[this.var(p)], MUL_OP));
394
+ this.push(this.applyRec(this.read(1), lo, ADD_OP));
395
+ result = this.read(1);
396
+ npop = 4;
397
+ }
398
+ } else {
399
+ result = this.reduceOnMatch(p, q);
400
+ npop = 0;
326
401
  }
327
- const product = this.applyRec(hi, this.var2pdd[this.var(first)], MUL_OP);
328
- return this.applyRec(product, lo, ADD_OP);
329
- }
330
402
  }
403
+ this.pop(npop);
404
+ if (isCached) this.opCache.set(q * NO_OP + op, result);
405
+ return result;
331
406
  }
332
407
 
333
408
  private minusRec(node: number): number {
334
409
  if (node === ZERO_PDD) return ZERO_PDD;
335
410
  if (this.isVal(node)) return this.imkVal(this.val(node).neg());
336
- const key = `${MINUS_OP},${node},${node}`;
337
- const cached = this.opCache.get(key);
411
+ const cached = this.opCache.get(node * NO_OP + MINUS_OP);
338
412
  if (cached !== undefined) return cached;
339
- const lo = this.minusRec(this.lo(node));
340
- const result = this.makeNode(this.level(node), lo, this.minusRec(this.hi(node)));
341
- this.opCache.set(key, result);
413
+ this.push(this.minusRec(this.lo(node)));
414
+ this.push(this.minusRec(this.hi(node)));
415
+ const result = this.makeNode(this.level(node), this.read(2), this.read(1));
416
+ this.pop(2);
417
+ this.opCache.set(node * NO_OP + MINUS_OP, result);
342
418
  return result;
343
419
  }
344
420
 
345
- // reduce_on_match: the monomials of a that lm(b) divides become (b - lt(b))/lm(b).
346
421
  private reduceOnMatch(first: number, second: number) {
347
422
  let current = first;
423
+ this.push(current);
348
424
  while (this.lmOccurs(second, current)) {
349
- const product = this.applyRec(this.ltQuotient(second, current), second, MUL_OP);
350
- current = this.applyRec(current, product, ADD_OP);
425
+ this.push(this.ltQuotient(second, current));
426
+ this.push(this.applyRec(this.read(1), second, MUL_OP));
427
+ this.push(this.applyRec(current, this.read(1), ADD_OP));
428
+ current = this.read(1);
429
+ this.pop(4);
430
+ this.push(current);
351
431
  }
432
+ this.pop(1);
352
433
  return current;
353
434
  }
354
435
 
355
- // lm_occurs: whether the leading monomial of p divides a monomial of q.
356
436
  private lmOccurs(first: number, second: number): boolean {
357
437
  let divisor = this.firstLeading(first);
358
438
  let target = second;
@@ -371,7 +451,6 @@ export class PddManager {
371
451
  }
372
452
  }
373
453
 
374
- // lt_quotient: minus the r such that lt(p)*r is a monomial of q, given lm_occurs(p, q).
375
454
  private ltQuotient(first: number, second: number): number {
376
455
  let divisor = this.firstLeading(first);
377
456
  let target = second;
@@ -390,24 +469,45 @@ export class PddManager {
390
469
  }
391
470
 
392
471
  private ltQuotientHi(first: number, second: number) {
393
- const quotient = this.ltQuotient(first, this.hi(second));
394
- return this.applyRec(this.var2pdd[this.var(second)], quotient, MUL_OP);
472
+ this.push(this.ltQuotient(first, this.hi(second)));
473
+ const result = this.applyRec(this.var2pdd[this.var(second)], this.read(1), MUL_OP);
474
+ this.pop(1);
475
+ return result;
395
476
  }
396
477
 
397
- // try_spoly: a*q*qc - b*p*pc, where p = lcm(lm(a),lm(b))/lm(a), q = lcm(lm(a),lm(b))/lm(b) and pc
398
- // and qc are the leading coefficients of a and b, when the leading monomials share a variable.
399
- trySpoly(first: Pdd, second: Pdd) {
478
+ trySpoly(first: Pdd, second: Pdd, result: Pdd) {
400
479
  const factors = this.commonFactors(first, second);
401
- if (factors === null) return null;
402
- let firstMultiplier = this.mkVal(factors.secondCoeff);
403
- for (let index = factors.second.length; index-- > 0;) {
404
- firstMultiplier = firstMultiplier.mul(this.mkVar(factors.second[index]));
405
- }
406
- let secondMultiplier = this.mkVal(factors.firstCoeff.neg());
407
- for (let index = factors.first.length; index-- > 0;) {
408
- secondMultiplier = secondMultiplier.mul(this.mkVar(factors.first[index]));
480
+ if (factors === null) return false;
481
+ const spoly = this.spoly(first, second, factors);
482
+ result.assign(spoly);
483
+ spoly.release();
484
+ return true;
485
+ }
486
+
487
+ private spoly(first: Pdd, second: Pdd, factors: CommonFactors) {
488
+ const firstMultiplier = this.mkVal(factors.secondCoeff);
489
+ try {
490
+ for (let index = factors.second.length; index-- > 0;) {
491
+ const variable = this.mkVar(factors.second[index]);
492
+ firstMultiplier.mulAssign(variable);
493
+ variable.release();
494
+ }
495
+ const secondMultiplier = this.mkVal(factors.firstCoeff.neg());
496
+ for (let index = factors.first.length; index-- > 0;) {
497
+ const variable = this.mkVar(factors.first[index]);
498
+ secondMultiplier.mulAssign(variable);
499
+ variable.release();
500
+ }
501
+ const firstProduct = firstMultiplier.mul(first);
502
+ const secondProduct = secondMultiplier.mul(second);
503
+ const result = firstProduct.add(secondProduct);
504
+ secondProduct.release();
505
+ firstProduct.release();
506
+ secondMultiplier.release();
507
+ return result;
508
+ } finally {
509
+ firstMultiplier.release();
409
510
  }
410
- return firstMultiplier.mul(first).add(secondMultiplier.mul(second));
411
511
  }
412
512
 
413
513
  private commonFactors(first: Pdd, second: Pdd): CommonFactors | null {
@@ -454,7 +554,6 @@ export class PddManager {
454
554
  }
455
555
  }
456
556
 
457
- // lm_lt: compares the leading monomials, then the monomials in degree-lex order.
458
557
  lmLt(first: Pdd, second: Pdd) {
459
558
  let firstNode = this.firstLeading(first.root);
460
559
  let secondNode = this.firstLeading(second.root);
@@ -497,8 +596,6 @@ export class PddManager {
497
596
  }
498
597
  }
499
598
 
500
- // first_leading: the first node with a term of the leading monomial, the monomial of highest
501
- // degree and then highest variables.
502
599
  private firstLeading(node: number) {
503
600
  let current = node;
504
601
  while (
@@ -514,60 +611,111 @@ export class PddManager {
514
611
  return this.firstLeading(this.hi(node));
515
612
  }
516
613
 
517
- degree(node: number): number {
614
+ degree(node: number) {
518
615
  if (node === ZERO_PDD || node === ONE_PDD) return 0;
519
- const cached = this.degrees[node];
520
- if (cached !== undefined) return cached;
521
- const degree = this.isVal(node)
522
- ? 0
523
- : Math.max(this.degree(this.lo(node)), this.degree(this.hi(node)) + 1);
524
- this.degrees[node] = degree;
525
- return degree;
616
+ const dmarkLevel = this.dmarkLevel;
617
+ if (this.dmarks[node] === dmarkLevel) return this.degrees[node];
618
+ const todo = this.degreeTodo;
619
+ todo.push(node);
620
+ while (todo.length > 0) {
621
+ const current = todo[todo.length - 1];
622
+ if (this.dmarks[current] === dmarkLevel) {
623
+ todo.pop();
624
+ } else if (this.isVal(current)) {
625
+ this.degrees[current] = 0;
626
+ this.dmarks[current] = dmarkLevel;
627
+ } else {
628
+ const lo = this.lo(current);
629
+ const hi = this.hi(current);
630
+ if (this.dmarks[lo] !== dmarkLevel || this.dmarks[hi] !== dmarkLevel) {
631
+ todo.push(lo, hi);
632
+ } else {
633
+ this.degrees[current] = Math.max(this.degrees[lo], this.degrees[hi] + 1);
634
+ this.dmarks[current] = dmarkLevel;
635
+ }
636
+ }
637
+ }
638
+ return this.degrees[node];
526
639
  }
527
640
 
528
- // factor: p = lc*v^degree + rest, where the degree of v in rest is below degree.
529
- factor(poly: Pdd, variable: number, degree: number): PddFactor {
641
+ factor(poly: Pdd, variable: number, degree: number, lc: Pdd, rest: Pdd) {
530
642
  const variableLevel = this.var2level[variable];
531
643
  if (degree === 0 || this.level(poly.root) < variableLevel) {
532
- return { lc: this.zero(), rest: poly };
644
+ const zero = this.zero();
645
+ lc.assign(zero);
646
+ zero.release();
647
+ rest.assign(poly);
648
+ return;
533
649
  }
534
650
  const key = `${poly.root},${variable},${degree}`;
535
651
  const cached = this.factorCache.get(key);
536
- if (cached !== undefined) return cached;
537
- const result = this.computeFactor(poly, variable, degree);
538
- this.factorCache.set(key, result);
539
- return result;
540
- }
541
-
542
- private computeFactor(poly: Pdd, variable: number, degree: number): PddFactor {
543
- const variableLevel = this.var2level[variable];
652
+ if (cached !== undefined) {
653
+ const cachedLc = new Pdd(this, cached.lc);
654
+ lc.assign(cachedLc);
655
+ cachedLc.release();
656
+ const cachedRest = new Pdd(this, cached.rest);
657
+ rest.assign(cachedRest);
658
+ cachedRest.release();
659
+ return;
660
+ }
544
661
  if (this.level(poly.root) > variableLevel) {
662
+ const lc1 = this.zero();
663
+ const rest1 = this.zero();
545
664
  const node = this.mkVar(poly.var());
546
- const hiFactor = this.factor(poly.hi(), variable, degree);
547
- const loFactor = this.factor(poly.lo(), variable, degree);
548
- const lc = hiFactor.lc.mul(node);
549
- const rest = hiFactor.rest.mul(node);
550
- return { lc: lc.add(loFactor.lc), rest: rest.add(loFactor.rest) };
551
- }
552
- let found = 0;
553
- let lc = poly;
554
- while (found < degree && !lc.isVal() && this.level(lc.root) === variableLevel) {
555
- found++;
556
- lc = lc.hi();
557
- }
558
- if (found < degree) return { lc: this.zero(), rest: poly };
559
- let rest = this.zero();
560
- let power = this.one();
561
- let current = poly;
562
- for (let index = 0; index < degree; index++) {
563
- rest = rest.add(power.mul(current.lo()));
564
- current = current.hi();
565
- power = power.mul(this.mkVar(variable));
566
- }
567
- return { lc, rest };
568
- }
569
-
570
- // is_binary: v1, x*v1 + v2 or x*v1 + y*v2 + v3, for values v1, v2 and v3.
665
+ const hi = poly.hi();
666
+ this.factor(hi, variable, degree, lc, rest);
667
+ hi.release();
668
+ const lo = poly.lo();
669
+ this.factor(lo, variable, degree, lc1, rest1);
670
+ lo.release();
671
+ lc.mulAssign(node);
672
+ rest.mulAssign(node);
673
+ lc.addAssign(lc1);
674
+ rest.addAssign(rest1);
675
+ node.release();
676
+ rest1.release();
677
+ lc1.release();
678
+ } else {
679
+ let found = 0;
680
+ const current = poly.copy();
681
+ while (found < degree && !current.isVal() && this.level(current.root) === variableLevel) {
682
+ found++;
683
+ const hi = current.hi();
684
+ current.assign(hi);
685
+ hi.release();
686
+ }
687
+ if (found === degree) {
688
+ lc.assign(current);
689
+ current.assign(poly);
690
+ const zero = this.zero();
691
+ rest.assign(zero);
692
+ zero.release();
693
+ const power = this.one();
694
+ for (let index = 0; index < degree; index++) {
695
+ const lo = current.lo();
696
+ const term = power.mul(lo);
697
+ rest.addAssign(term);
698
+ term.release();
699
+ lo.release();
700
+ const hi = current.hi();
701
+ current.assign(hi);
702
+ const variablePdd = this.mkVar(variable);
703
+ power.mulAssign(variablePdd);
704
+ variablePdd.release();
705
+ hi.release();
706
+ }
707
+ power.release();
708
+ } else {
709
+ const zero = this.zero();
710
+ lc.assign(zero);
711
+ zero.release();
712
+ rest.assign(poly);
713
+ }
714
+ current.release();
715
+ }
716
+ this.factorCache.set(key, { lc: lc.root, rest: rest.root });
717
+ }
718
+
571
719
  isBinary(node: number) {
572
720
  const lo = this.lo(node);
573
721
  return (
@@ -577,8 +725,6 @@ export class PddManager {
577
725
  );
578
726
  }
579
727
 
580
- // get_powers: the variables with a power above 1. The var of a value node is the lowest
581
- // variable, so Z3 counts a value under that variable as one more power of it.
582
728
  getPowers(poly: Pdd) {
583
729
  const powers: PddPower[] = [];
584
730
  const marked = new Set<number>();
@@ -589,6 +735,7 @@ export class PddManager {
589
735
  const variable = this.var(node);
590
736
  let current = node;
591
737
  let degree = 1;
738
+ // Like Z3, a value under the lowest variable counts as one more power of it.
592
739
  while (!this.isVal(current) && this.var(this.hi(current)) === variable) {
593
740
  degree++;
594
741
  todo.push(this.lo(current));
@@ -600,7 +747,6 @@ export class PddManager {
600
747
  return powers;
601
748
  }
602
749
 
603
- // var_is_leaf: whether every node of v has values as children.
604
750
  varIsLeaf(poly: Pdd, variable: number) {
605
751
  const marked = new Set<number>();
606
752
  const todo = [poly.root];
@@ -645,14 +791,36 @@ export class PddManager {
645
791
  return vars;
646
792
  }
647
793
 
794
+ private push(node: number) {
795
+ this.pddStack[this.pddStackSize++] = node;
796
+ }
797
+
798
+ private pop(count: number) {
799
+ this.pddStackSize -= count;
800
+ }
801
+
802
+ private read(index: number) {
803
+ return this.pddStack[this.pddStackSize - index];
804
+ }
805
+
648
806
  private imkVal(value: Rational) {
649
807
  if (value.isZero()) return ZERO_PDD;
650
808
  if (value.equals(Rational.one)) return ONE_PDD;
651
809
  const key = value.toString();
652
- const existing = this.valueTable.get(key);
653
- if (existing !== undefined) return existing;
654
- const node = this.insertNode(0, this.values.length, 0);
655
- this.values.push(value);
810
+ return this.valueTable.get(key) ?? this.initValue(value, key);
811
+ }
812
+
813
+ private initValue(value: Rational, key: string) {
814
+ let valueIndex = this.values.length;
815
+ if (this.freeValues.length === 0) {
816
+ this.values.push(value);
817
+ } else {
818
+ valueIndex = this.freeValues[this.freeValues.length - 1];
819
+ this.freeValues.pop();
820
+ this.values[valueIndex] = value;
821
+ }
822
+ this.freezeValue = value;
823
+ const node = this.insertNode(0, valueIndex, 0);
656
824
  this.valueTable.set(key, node);
657
825
  return node;
658
826
  }
@@ -661,31 +829,159 @@ export class PddManager {
661
829
  return hi === ZERO_PDD ? lo : this.insertNode(level, lo, hi);
662
830
  }
663
831
 
664
- // insert_node: Z3 adds half as many free nodes again when they run out, and is out of memory
665
- // when the nodes already number more than the limit.
666
832
  private insertNode(level: number, lo: number, hi: number) {
667
- const key = `${level},${lo},${hi}`;
833
+ const key = getNodeKey(level, lo, hi);
668
834
  const existing = this.nodeTable.get(key);
669
835
  if (existing !== undefined) return existing;
670
- if (this.levels.length === this.numAllocated) {
671
- if (this.numAllocated > this.maxNumNodes && !this.isApplying) throw new PddMemoryOutError();
672
- while (this.numAllocated > this.maxNumNodes) this.maxNumNodes *= 2;
673
- this.numAllocated += Math.floor(this.numAllocated / 2);
674
- }
675
- const node = this.levels.length;
676
- this.levels.push(level);
677
- this.los.push(lo);
678
- this.his.push(hi);
836
+ if (this.freeNodes.length === 0) {
837
+ this.gc();
838
+ if (this.levels.length > this.maxNumNodes) throw new PddMemoryOutError();
839
+ this.allocFreeNodes(Math.floor(this.levels.length / 2));
840
+ }
841
+ const node = this.freeNodes[this.freeNodes.length - 1];
842
+ this.freeNodes.pop();
843
+ this.levels[node] = level;
844
+ this.los[node] = lo;
845
+ this.his[node] = hi;
846
+ this.refcounts[node] = 0;
679
847
  this.nodeTable.set(key, node);
680
848
  return node;
681
849
  }
850
+
851
+ private tryGc() {
852
+ this.gc();
853
+ this.opCache.clear();
854
+ }
855
+
856
+ private allocFreeNodes(count: number) {
857
+ for (let index = 0; index < count; index++) {
858
+ this.freeNodes.push(this.levels.length);
859
+ this.levels.push(0);
860
+ this.los.push(0);
861
+ this.his.push(0);
862
+ this.refcounts.push(0);
863
+ this.dmarks.push(0);
864
+ this.degrees.push(0);
865
+ }
866
+ this.freeNodes.sort((first, second) => second - first);
867
+ this.initDmark();
868
+ }
869
+
870
+ private computeReachable(reachable: Uint8Array) {
871
+ const todo: number[] = [];
872
+ for (let index = this.pddStackSize; index-- > 0;) {
873
+ reachable[this.pddStack[index]] = 1;
874
+ todo.push(this.pddStack[index]);
875
+ }
876
+ for (let node = NO_OP; node-- > 0;) reachable[node] = 1;
877
+ for (let node = this.levels.length; node-- > NO_OP;) {
878
+ if (this.refcounts[node] > 0) {
879
+ reachable[node] = 1;
880
+ todo.push(node);
881
+ }
882
+ }
883
+ for (let node = todo.pop(); node !== undefined; node = todo.pop()) {
884
+ if (this.isVal(node)) continue;
885
+ const lo = this.lo(node);
886
+ const hi = this.hi(node);
887
+ if (reachable[lo] === 0) {
888
+ reachable[lo] = 1;
889
+ todo.push(lo);
890
+ }
891
+ if (reachable[hi] === 0) {
892
+ reachable[hi] = 1;
893
+ todo.push(hi);
894
+ }
895
+ }
896
+ }
897
+
898
+ private gc() {
899
+ this.initDmark();
900
+ this.freeNodes = [];
901
+ const size = this.levels.length;
902
+ const reachable = new Uint8Array(size);
903
+ this.computeReachable(reachable);
904
+ for (let node = size; node-- > NO_OP;) {
905
+ if (reachable[node] === 1) continue;
906
+ if (this.his[node] === 0 && this.los[node] !== 0) {
907
+ const value = this.values[this.los[node]];
908
+ if (this.freezeValue.equals(value)) continue;
909
+ this.freeValues.push(this.los[node]);
910
+ this.valueTable.delete(value.toString());
911
+ }
912
+ this.los[node] = 0;
913
+ this.his[node] = 0;
914
+ this.freeNodes.push(node);
915
+ }
916
+ this.opCache.clear();
917
+ this.factorCache.clear();
918
+ this.nodeTable.clear();
919
+ for (let node = size; node-- > 2;) {
920
+ if (reachable[node] === 0) continue;
921
+ this.nodeTable.set(getNodeKey(this.levels[node], this.los[node], this.his[node]), node);
922
+ }
923
+ }
924
+
925
+ private initDmark() {
926
+ this.dmarkLevel++;
927
+ }
682
928
  }
683
929
 
930
+ const getMonomials = (poly: Pdd): PddMonomial[] => {
931
+ if (poly.isVal()) return poly.val().isZero() ? [] : [{ coeff: poly.val(), vars: [] }];
932
+ const hi = poly.hi();
933
+ const monomials = getMonomials(hi);
934
+ hi.release();
935
+ for (const monomial of monomials) monomial.vars.push(poly.var());
936
+ const lo = poly.lo();
937
+ monomials.push(...getMonomials(lo));
938
+ lo.release();
939
+ return monomials;
940
+ };
941
+
684
942
  export class Pdd {
685
943
  constructor(
686
- readonly manager: PddManager,
687
- readonly root: number,
688
- ) {}
944
+ private readonly manager: PddManager,
945
+ public root: number,
946
+ ) {
947
+ manager.incRef(root);
948
+ }
949
+
950
+ copy() {
951
+ const result = new Pdd(this.manager, this.root);
952
+ // Like Z3, whose copy constructor delegates to a counting constructor and then counts again.
953
+ this.manager.incRef(this.root);
954
+ return result;
955
+ }
956
+
957
+ release() {
958
+ this.manager.decRef(this.root);
959
+ }
960
+
961
+ assign(other: Pdd) {
962
+ const previous = this.root;
963
+ this.root = other.root;
964
+ this.manager.incRef(this.root);
965
+ this.manager.decRef(previous);
966
+ }
967
+
968
+ addAssign(other: Pdd) {
969
+ const sum = this.add(other);
970
+ this.assign(sum);
971
+ sum.release();
972
+ }
973
+
974
+ subAssign(value: Rational) {
975
+ const difference = this.sub(value);
976
+ this.assign(difference);
977
+ difference.release();
978
+ }
979
+
980
+ mulAssign(other: Pdd | Rational) {
981
+ const product = this.mul(other);
982
+ this.assign(product);
983
+ product.release();
984
+ }
689
985
 
690
986
  lo() {
691
987
  return new Pdd(this.manager, this.manager.lo(this.root));
@@ -703,10 +999,6 @@ export class Pdd {
703
999
  return this.manager.val(this.root);
704
1000
  }
705
1001
 
706
- offset() {
707
- return this.manager.offset(this.root);
708
- }
709
-
710
1002
  isVal() {
711
1003
  return this.manager.isVal(this.root);
712
1004
  }
@@ -723,18 +1015,30 @@ export class Pdd {
723
1015
  return this.manager.degree(this.root) === 1;
724
1016
  }
725
1017
 
726
- isVar() {
727
- return !this.isVal() && this.lo().isZero() && this.hi().isOne();
728
- }
729
-
730
- // a*x for a value a.
731
1018
  isUnary() {
732
- return !this.isVal() && this.lo().isZero() && this.hi().isVal();
1019
+ if (this.isVal()) return false;
1020
+ const lo = this.lo();
1021
+ let isUnary = lo.isZero();
1022
+ if (isUnary) {
1023
+ const hi = this.hi();
1024
+ isUnary = hi.isVal();
1025
+ hi.release();
1026
+ }
1027
+ lo.release();
1028
+ return isUnary;
733
1029
  }
734
1030
 
735
- // x + b for a value b.
736
1031
  isOffset() {
737
- return !this.isVal() && this.lo().isVal() && this.hi().isOne();
1032
+ if (this.isVal()) return false;
1033
+ const lo = this.lo();
1034
+ let isOffset = lo.isVal();
1035
+ if (isOffset) {
1036
+ const hi = this.hi();
1037
+ isOffset = hi.isOne();
1038
+ hi.release();
1039
+ }
1040
+ lo.release();
1041
+ return isOffset;
738
1042
  }
739
1043
 
740
1044
  isBinary() {
@@ -751,25 +1055,22 @@ export class Pdd {
751
1055
 
752
1056
  add(other: Pdd | Rational) {
753
1057
  return other instanceof Rational
754
- ? this.manager.add(this.manager.mkVal(other), this)
1058
+ ? this.manager.addValue(other, this)
755
1059
  : this.manager.add(this, other);
756
1060
  }
757
1061
 
758
1062
  sub(other: Pdd | Rational) {
759
- return other instanceof Rational ? this.add(other.neg()) : this.manager.sub(this, other);
1063
+ return other instanceof Rational
1064
+ ? this.manager.addValue(other.neg(), this)
1065
+ : this.manager.sub(this, other);
760
1066
  }
761
1067
 
762
1068
  mul(other: Pdd | Rational) {
763
1069
  return other instanceof Rational
764
- ? this.manager.mul(this.manager.mkVal(other), this)
1070
+ ? this.manager.mulValue(other, this)
765
1071
  : this.manager.mul(this, other);
766
1072
  }
767
1073
 
768
- // div: in the free semantics, multiplication by the inverse, which shares the op cache.
769
- div(divisor: Rational) {
770
- return this.mul(Rational.one.div(divisor));
771
- }
772
-
773
1074
  pow(exponent: number) {
774
1075
  return this.manager.pow(this, exponent);
775
1076
  }
@@ -778,8 +1079,8 @@ export class Pdd {
778
1079
  return this.manager.reduce(this, other);
779
1080
  }
780
1081
 
781
- factor(variable: number, degree: number) {
782
- return this.manager.factor(this, variable, degree);
1082
+ factor(variable: number, degree: number, lc: Pdd, rest: Pdd) {
1083
+ this.manager.factor(this, variable, degree, lc, rest);
783
1084
  }
784
1085
 
785
1086
  differentLeadingTerm(other: Pdd) {
@@ -806,22 +1107,36 @@ export class Pdd {
806
1107
  return this.manager.getPowers(this);
807
1108
  }
808
1109
 
809
- // var_factors: the variables that divide every monomial, with their product divided out.
810
1110
  varFactors(): PddVarFactors {
811
- if (this.isVal()) return { vars: [], poly: this };
1111
+ if (this.isVal()) return { vars: [], poly: this.copy() };
812
1112
  const manager = this.manager;
813
1113
  const variable = this.var();
814
- if (this.lo().isVal()) {
815
- if (!this.lo().isZero()) return { vars: [], poly: this };
816
- const factors = this.hi().varFactors();
1114
+ const firstLo = this.lo();
1115
+ const isLoVal = firstLo.isVal();
1116
+ firstLo.release();
1117
+ if (isLoVal) {
1118
+ const secondLo = this.lo();
1119
+ const isLoZero = secondLo.isZero();
1120
+ secondLo.release();
1121
+ if (!isLoZero) return { vars: [], poly: this.copy() };
1122
+ const hi = this.hi();
1123
+ const factors = hi.varFactors();
1124
+ hi.release();
817
1125
  factors.vars.push(variable);
818
- return factors;
1126
+ const result = { vars: factors.vars, poly: factors.poly.copy() };
1127
+ factors.poly.release();
1128
+ return result;
819
1129
  }
820
- const loFactors = this.lo().varFactors();
1130
+ const lo = this.lo();
1131
+ const loFactors = lo.varFactors();
1132
+ lo.release();
821
1133
  const loVars = loFactors.vars;
822
- if (loVars.length === 0) return { vars: [], poly: this };
1134
+ if (loVars.length === 0) {
1135
+ const result = { vars: [], poly: this.copy() };
1136
+ loFactors.poly.release();
1137
+ return result;
1138
+ }
823
1139
  const loAndHi: number[] = [];
824
- // Moves the variables in both lists to loAndHi and keeps the rest in place, by level.
825
1140
  const merge = (hiVars: number[]) => {
826
1141
  let loKept = 0;
827
1142
  let hiKept = 0;
@@ -845,107 +1160,161 @@ export class Pdd {
845
1160
  shrink(loVars, loKept);
846
1161
  shrink(hiVars, hiKept);
847
1162
  };
848
- const multiply = (vars: number[], poly: Pdd) =>
849
- vars.reduce((product, innerVar) => product.mul(manager.mkVar(innerVar)), poly);
850
- const hiFactors = this.hi().varFactors();
1163
+ const multiply = (vars: number[], poly: Pdd) => {
1164
+ const product = poly.copy();
1165
+ for (const innerVar of vars) {
1166
+ const variablePdd = manager.mkVar(innerVar);
1167
+ product.mulAssign(variablePdd);
1168
+ variablePdd.release();
1169
+ }
1170
+ return product;
1171
+ };
1172
+ const hi = this.hi();
1173
+ const hiFactors = hi.varFactors();
1174
+ hi.release();
851
1175
  const hiVars = hiFactors.vars;
852
1176
  if (loVars[loVars.length - 1] === variable) {
853
1177
  loVars.pop();
854
1178
  merge(hiVars);
855
1179
  loAndHi.push(variable);
856
- return {
857
- vars: loAndHi,
858
- poly: multiply(loVars, loFactors.poly).add(multiply(hiVars, hiFactors.poly)),
859
- };
860
- }
861
- if (hiVars.length === 0) return { vars: [], poly: this };
862
- merge(hiVars);
863
- hiVars.push(variable);
864
- if (loAndHi.length === 0) return { vars: [], poly: this };
865
- return {
866
- vars: loAndHi,
867
- poly: multiply(loVars, loFactors.poly).add(multiply(hiVars, hiFactors.poly)),
868
- };
1180
+ } else if (hiVars.length > 0) {
1181
+ merge(hiVars);
1182
+ hiVars.push(variable);
1183
+ }
1184
+ let result: PddVarFactors;
1185
+ if (loAndHi.length === 0) {
1186
+ result = { vars: [], poly: this.copy() };
1187
+ } else {
1188
+ const loProduct = multiply(loVars, loFactors.poly);
1189
+ const hiProduct = multiply(hiVars, hiFactors.poly);
1190
+ result = { vars: loAndHi, poly: loProduct.add(hiProduct) };
1191
+ hiProduct.release();
1192
+ loProduct.release();
1193
+ }
1194
+ hiFactors.poly.release();
1195
+ loFactors.poly.release();
1196
+ return result;
869
1197
  }
870
1198
 
871
- // subst_pdd: replaces the variable by the polynomial, without the op cache.
872
1199
  substPdd(variable: number, replacement: Pdd): Pdd {
873
1200
  const manager = this.manager;
874
- if (this.isVal() || manager.var2level[this.var()] < manager.var2level[variable]) return this;
875
- const lo = this.lo().substPdd(variable, replacement);
876
- const hi = this.hi().substPdd(variable, replacement);
877
- if (this.var() === variable) return replacement.mul(hi).add(lo);
878
- if (lo.equals(this.lo()) && hi.equals(this.hi())) return this;
879
- return manager.mkVar(this.var()).mul(hi).add(lo);
1201
+ if (this.isVal() || manager.var2level[this.var()] < manager.var2level[variable]) {
1202
+ return this.copy();
1203
+ }
1204
+ const lo = this.lo();
1205
+ const substitutedLo = lo.substPdd(variable, replacement);
1206
+ lo.release();
1207
+ const hi = this.hi();
1208
+ const substitutedHi = hi.substPdd(variable, replacement);
1209
+ hi.release();
1210
+ let result: Pdd;
1211
+ if (this.var() === variable) {
1212
+ const product = replacement.mul(substitutedHi);
1213
+ result = product.add(substitutedLo);
1214
+ product.release();
1215
+ } else {
1216
+ const thisLo = this.lo();
1217
+ let isUnchanged = substitutedLo.equals(thisLo);
1218
+ if (isUnchanged) {
1219
+ const thisHi = this.hi();
1220
+ isUnchanged = substitutedHi.equals(thisHi);
1221
+ thisHi.release();
1222
+ }
1223
+ thisLo.release();
1224
+ if (isUnchanged) {
1225
+ result = this.copy();
1226
+ } else {
1227
+ const variablePdd = manager.mkVar(this.var());
1228
+ const product = variablePdd.mul(substitutedHi);
1229
+ result = product.add(substitutedLo);
1230
+ product.release();
1231
+ variablePdd.release();
1232
+ }
1233
+ }
1234
+ substitutedHi.release();
1235
+ substitutedLo.release();
1236
+ return result;
880
1237
  }
881
1238
 
882
- // The monomials, hi before lo, each with its variables from the highest level down.
883
1239
  *[Symbol.iterator](): Generator<PddMonomial> {
884
- const manager = this.manager;
885
- const nodes: IteratorNode[] = [];
886
- const vars: number[] = [];
887
- let node = this.root;
888
- while (!manager.isVal(node)) {
889
- nodes.push({ isFirst: true, node });
890
- vars.push(manager.var(node));
891
- node = manager.hi(node);
892
- }
893
- if (nodes.length === 0) {
894
- if (!manager.val(node).isZero()) yield { coeff: manager.val(node), vars: [] };
895
- return;
896
- }
897
- yield { coeff: manager.val(node), vars: [...vars] };
898
- while (nodes.length > 0) {
899
- const top = nodes[nodes.length - 1];
900
- if (!top.isFirst) {
901
- nodes.pop();
902
- continue;
1240
+ const begin = this.copy();
1241
+ const end = this.copy();
1242
+ try {
1243
+ const manager = this.manager;
1244
+ const nodes: IteratorNode[] = [];
1245
+ const vars: number[] = [];
1246
+ let node = begin.root;
1247
+ while (!manager.isVal(node)) {
1248
+ nodes.push({ isFirst: true, node });
1249
+ vars.push(manager.var(node));
1250
+ node = manager.hi(node);
903
1251
  }
904
- top.isFirst = false;
905
- vars.pop();
906
- let next = manager.lo(top.node);
907
- if (next === ZERO_PDD) {
908
- nodes.pop();
909
- continue;
1252
+ if (nodes.length === 0) {
1253
+ if (!manager.val(node).isZero()) yield { coeff: manager.val(node), vars: [] };
1254
+ return;
910
1255
  }
911
- while (!manager.isVal(next)) {
912
- nodes.push({ isFirst: true, node: next });
913
- vars.push(manager.var(next));
914
- next = manager.hi(next);
1256
+ yield { coeff: manager.val(node), vars: [...vars] };
1257
+ while (nodes.length > 0) {
1258
+ const top = nodes[nodes.length - 1];
1259
+ if (!top.isFirst) {
1260
+ nodes.pop();
1261
+ continue;
1262
+ }
1263
+ top.isFirst = false;
1264
+ vars.pop();
1265
+ let next = manager.lo(top.node);
1266
+ if (next === ZERO_PDD) {
1267
+ nodes.pop();
1268
+ continue;
1269
+ }
1270
+ while (!manager.isVal(next)) {
1271
+ nodes.push({ isFirst: true, node: next });
1272
+ vars.push(manager.var(next));
1273
+ next = manager.hi(next);
1274
+ }
1275
+ yield { coeff: manager.val(next), vars: [...vars] };
915
1276
  }
916
- yield { coeff: manager.val(next), vars: [...vars] };
1277
+ } finally {
1278
+ end.release();
1279
+ begin.release();
917
1280
  }
918
1281
  }
919
1282
 
920
- // The coefficients, each marked as the constant term or not. Zero yields one constant 0.
921
1283
  *coefficients(): Generator<PddCoefficient> {
922
- const manager = this.manager;
923
- const nodes: number[] = [];
924
- let node = this.root;
925
- while (!manager.isVal(node)) {
926
- nodes.push(node);
927
- node = manager.hi(node);
928
- }
929
- yield { coeff: manager.val(node), isConstant: nodes.length === 0 };
930
- for (let top = nodes.pop(); top !== undefined; top = nodes.pop()) {
931
- let next = manager.lo(top);
932
- if (next === ZERO_PDD) continue;
933
- while (!manager.isVal(next)) {
934
- nodes.push(next);
935
- next = manager.hi(next);
1284
+ const begin = this.copy();
1285
+ const end = this.copy();
1286
+ try {
1287
+ const manager = this.manager;
1288
+ const nodes: number[] = [];
1289
+ let node = begin.root;
1290
+ while (!manager.isVal(node)) {
1291
+ nodes.push(node);
1292
+ node = manager.hi(node);
936
1293
  }
937
- yield { coeff: manager.val(next), isConstant: nodes.length === 0 };
1294
+ yield { coeff: manager.val(node), isConstant: nodes.length === 0 };
1295
+ for (let top = nodes.pop(); top !== undefined; top = nodes.pop()) {
1296
+ let next = manager.lo(top);
1297
+ if (next === ZERO_PDD) continue;
1298
+ while (!manager.isVal(next)) {
1299
+ nodes.push(next);
1300
+ next = manager.hi(next);
1301
+ }
1302
+ yield { coeff: manager.val(next), isConstant: nodes.length === 0 };
1303
+ }
1304
+ } finally {
1305
+ end.release();
1306
+ begin.release();
938
1307
  }
939
1308
  }
940
1309
 
941
1310
  toString() {
942
1311
  let text = "";
943
- for (const monomial of this) {
1312
+ for (const monomial of getMonomials(this)) {
944
1313
  if (text !== "") text += " ";
945
1314
  if (monomial.coeff.isNegative()) text += "- ";
946
1315
  else if (text !== "") text += "+ ";
947
1316
  const coeff = monomial.coeff.abs();
948
- const vars = monomial.vars;
1317
+ const vars = monomial.vars.reverse();
949
1318
  if (!coeff.equals(Rational.one) || vars.length === 0) {
950
1319
  text += vars.length === 0 ? `${coeff}` : `${coeff}*`;
951
1320
  }
@@ -962,10 +1331,13 @@ export class Pdd {
962
1331
  }
963
1332
  }
964
1333
 
965
- // pdd_eval: the value of the polynomial under the values of its variables.
966
- export const evaluatePdd = (poly: Pdd, getValue: (variable: number) => Rational): Rational =>
967
- poly.isVal()
968
- ? poly.val()
969
- : evaluatePdd(poly.hi(), getValue)
970
- .mul(getValue(poly.var()))
971
- .add(evaluatePdd(poly.lo(), getValue));
1334
+ export const evaluatePdd = (poly: Pdd, getValue: (variable: number) => Rational): Rational => {
1335
+ if (poly.isVal()) return poly.val();
1336
+ const hi = poly.hi();
1337
+ const product = evaluatePdd(hi, getValue).mul(getValue(poly.var()));
1338
+ const lo = poly.lo();
1339
+ const result = product.add(evaluatePdd(lo, getValue));
1340
+ lo.release();
1341
+ hi.release();
1342
+ return result;
1343
+ };