tla-ts 0.0.9 → 0.0.10-dev.28c823e4b

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 (390) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +4 -23
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +40 -78
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +599 -388
  30. package/src/cli/options.ts +11 -6
  31. package/src/cli/run.ts +0 -2
  32. package/src/cli/runtime-invariants.ts +136 -0
  33. package/src/cli/shared.ts +18 -11
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +640 -0
  36. package/src/cli/tlc-usage.ts +361 -0
  37. package/src/cli/tlc.ts +538 -220
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +596 -339
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +4 -19
  54. package/src/json-reader.ts +455 -0
  55. package/src/json.ts +255 -139
  56. package/src/levels.ts +8 -17
  57. package/src/lexer.ts +80 -100
  58. package/src/liveness-checker.ts +82 -119
  59. package/src/liveness.ts +112 -64
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +29 -39
  82. package/src/parallel.ts +53 -44
  83. package/src/parser.ts +565 -282
  84. package/src/pcal/ast.ts +53 -86
  85. package/src/pcal/parse.ts +144 -219
  86. package/src/pcal/tokenize.ts +91 -131
  87. package/src/pcal/translate.ts +83 -130
  88. package/src/pcal/validate.ts +48 -68
  89. package/src/pretty-print.ts +7 -8
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +81 -35
  336. package/src/resolve.ts +12 -112
  337. package/src/runtime.ts +22 -22
  338. package/src/sany/builtins.ts +2 -5
  339. package/src/sany/generator.ts +149 -252
  340. package/src/sany/levels.ts +6 -34
  341. package/src/sany/lexer.ts +41 -61
  342. package/src/sany/linter.ts +1 -9
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +495 -155
  351. package/src/simulate.ts +685 -0
  352. package/src/spec-description.ts +176 -69
  353. package/src/standard-definitions.ts +0 -4
  354. package/src/standard-modules.ts +254 -69
  355. package/src/state-graph.ts +50 -24
  356. package/src/subexpressions.ts +69 -52
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +263 -94
  359. package/src/symmetry.ts +33 -25
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -67
  362. package/src/tlc/jar-data.ts +112 -6
  363. package/src/tlc/messages.ts +110 -44
  364. package/src/tlc/order.ts +37 -60
  365. package/src/tlc/random.ts +33 -45
  366. package/src/tlc/replay.ts +549 -217
  367. package/src/tlc/summary.ts +36 -47
  368. package/src/tlc/tlc-operators.ts +76 -41
  369. package/src/tlc/tlcext-operators.ts +139 -122
  370. package/src/tlc/trace-spec.ts +269 -0
  371. package/src/tlc/value-stream.ts +139 -0
  372. package/src/tlc/version.ts +1 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +780 -337
  390. package/src/worker.ts +7 -8
@@ -1,8 +1,5 @@
1
1
  // Ported from Z3 (src/math/polynomial/algebraic_numbers.cpp, src/util/basic_interval.h,
2
- // src/util/mpbq.cpp), MIT license, see z3-license.txt. Real algebraic numbers: a rational, or the
3
- // root of a square-free integer polynomial in an open isolating interval of binary rationals whose
4
- // ends the polynomial has opposite signs at. Comparing and evaluating refine these intervals in
5
- // place, and may find a number rational, as Z3 does, so later operations see Z3's intervals.
2
+ // src/util/mpbq.cpp, src/util/index_sort_with_mutations.h), MIT license, see z3-license.txt.
6
3
  import { SmtInvariantError } from "../../../../errors";
7
4
  import { Rational } from "../rational";
8
5
  import { getLog2, Mpbq } from "./mpbq";
@@ -10,13 +7,9 @@ import { PolynomialManager, type Polynomial, type ValueOps } from "./polynomial"
10
7
  import { UpolynomialManager, type Upolynomial } from "./upolynomial";
11
8
  import { factorUpolynomial, type FactorParams } from "./upolynomial-factorization";
12
9
 
13
- // algebraic.factor_max_prime, factor_num_primes and factor_search_size.
14
10
  const FACTOR_PARAMS: FactorParams = { maxPrime: 31, primeTrials: 1, maxSearchSize: 5000 };
15
- // -algebraic.min_mag: a refined interval narrower than about 1/2^16 is not kept.
16
11
  const MIN_MAGNITUDE = -16;
17
- // DEFAULT_PRECISION: how far isolate_roots with signs refines each root first.
18
12
  const SIGN_PRECISION = 2;
19
- // The variables of the polynomials the binary operations build, m_x and m_y.
20
13
  const X = 0;
21
14
  const Y = 1;
22
15
 
@@ -28,7 +21,6 @@ class AlgebraicCell {
28
21
  public isMinimal: boolean,
29
22
  public isSignLowerNeg: boolean,
30
23
  public isNotRational: boolean,
31
- // m_i: which root of p the number is, from 1, or 0 when not yet computed.
32
24
  public rootIndex: number,
33
25
  ) {}
34
26
 
@@ -49,7 +41,6 @@ class AlgebraicCell {
49
41
  }
50
42
  }
51
43
 
52
- // anum: a mutable handle, since refining an algebraic number may turn it into a rational.
53
44
  export class Anum {
54
45
  constructor(public value: Rational | AlgebraicCell) {}
55
46
  }
@@ -59,14 +50,11 @@ interface BqInterval {
59
50
  upper: Mpbq;
60
51
  }
61
52
 
62
- // One end of the interval select_small picks from: a binary rational end is closed, a rational one
63
- // open.
64
53
  interface SelectEnd {
65
54
  value: Rational;
66
55
  isOpen: boolean;
67
56
  }
68
57
 
69
- // save_intervals: an interval to restore when refining it made it too narrow to keep.
70
58
  interface SavedInterval {
71
59
  anum: Anum;
72
60
  lower: Mpbq;
@@ -74,7 +62,6 @@ interface SavedInterval {
74
62
  isRestored: boolean;
75
63
  }
76
64
 
77
- // The factor whose Sturm sequence counts the one root in an interval.
78
65
  interface IsolatingFactor {
79
66
  factor: Upolynomial;
80
67
  sequence: Upolynomial[];
@@ -91,10 +78,9 @@ interface SignedRoots {
91
78
  signs: number[];
92
79
  }
93
80
 
94
- const minBq = (first: Mpbq, second: Mpbq) => (second.compare(first) < 0 ? second : first);
95
- const maxBq = (first: Mpbq, second: Mpbq) => (second.compare(first) > 0 ? second : first);
81
+ const getMinBq = (first: Mpbq, second: Mpbq) => (second.compare(first) < 0 ? second : first);
82
+ const getMaxBq = (first: Mpbq, second: Mpbq) => (second.compare(first) > 0 ? second : first);
96
83
 
97
- // mpbqi_manager over open intervals, as t_eval uses it.
98
84
  const INTERVAL_OPS: ValueOps<BqInterval> = {
99
85
  fromInteger: (value) => ({ lower: Mpbq.of(value), upper: Mpbq.of(value) }),
100
86
  add: (first, second) => ({
@@ -108,7 +94,7 @@ const INTERVAL_OPS: ValueOps<BqInterval> = {
108
94
  first.upper.mul(second.lower),
109
95
  first.upper.mul(second.upper),
110
96
  ];
111
- return { lower: products.reduce(minBq), upper: products.reduce(maxBq) };
97
+ return { lower: products.reduce(getMinBq), upper: products.reduce(getMaxBq) };
112
98
  },
113
99
  power: (base, exponent) => getIntervalPower(base, exponent),
114
100
  };
@@ -118,16 +104,14 @@ const getIntervalPower = (base: BqInterval, exponent: number): BqInterval => {
118
104
  const upper = base.upper.power(exponent);
119
105
  if (exponent % 2 === 1 || !base.lower.isNeg) return { lower, upper };
120
106
  if (base.upper.isNeg) return { lower: upper, upper: lower };
121
- return { lower: Mpbq.zero, upper: maxBq(lower, upper) };
107
+ return { lower: Mpbq.zero, upper: getMaxBq(lower, upper) };
122
108
  };
123
109
 
124
110
  const containsZero = (interval: BqInterval) => interval.lower.isNeg && interval.upper.isPos;
125
111
 
126
- // mpz log2 and mlog2: 0 outside the sign they expect.
127
112
  const getPositiveLog2 = (value: bigint) => (value <= 0n ? 0 : getLog2(value));
128
113
  const getNegativeLog2 = (value: bigint) => (value >= 0n ? 0 : getLog2(value));
129
114
 
130
- // magnitude_ub
131
115
  const getMagnitudeUpperBound = (value: Mpbq) =>
132
116
  value.isZero
133
117
  ? 0
@@ -135,14 +119,12 @@ const getMagnitudeUpperBound = (value: Mpbq) =>
135
119
  ? getLog2(value.num) - value.k + 1
136
120
  : getNegativeLog2(value.num) - value.k;
137
121
 
138
- // magnitude: about log2 of the width of (l, u).
139
122
  const getMagnitude = (lower: Mpbq, upper: Mpbq) => {
140
123
  if (lower.k === upper.k) return getMagnitudeUpperBound(lower);
141
124
  const log2 = lower.isNeg ? getNegativeLog2 : getPositiveLog2;
142
125
  return log2(upper.num) - log2(lower.num) - upper.k + lower.k - upper.k;
143
126
  };
144
127
 
145
- // select_integer: the integer select_small takes from scaled ends, preferring a closed end.
146
128
  const selectInteger = (
147
129
  lower: SelectEnd,
148
130
  upper: SelectEnd,
@@ -158,8 +140,6 @@ const selectInteger = (
158
140
  return ceilLower <= floorUpper ? ceilLower : null;
159
141
  };
160
142
 
161
- // select_small_core: the binary rational between two ends with the smallest power of two as its
162
- // denominator.
163
143
  const selectSmall = (lower: SelectEnd, upper: SelectEnd) => {
164
144
  for (let k = 0; ; k++) {
165
145
  const scale = Rational.of(1n << BigInt(k));
@@ -189,9 +169,31 @@ const getExtended = (values: readonly (Anum | undefined)[], variable: number, an
189
169
  return extended;
190
170
  };
191
171
 
192
- const sameCoeffs = (first: Upolynomial, second: Upolynomial) =>
172
+ const hasSameCoeffs = (first: Upolynomial, second: Upolynomial) =>
193
173
  first.length === second.length && first.every((coeff, index) => coeff === second[index]);
194
174
 
175
+ export const mergeSortIndices = (
176
+ count: number,
177
+ isLess: (first: number, second: number) => boolean,
178
+ ) => {
179
+ let source = Array.from({ length: count }, (_unused, index) => index);
180
+ for (let width = 1; width < count; width *= 2) {
181
+ const target: number[] = [];
182
+ for (let low = 0; low < count; low += 2 * width) {
183
+ const middle = Math.min(low + width, count);
184
+ const high = Math.min(low + 2 * width, count);
185
+ let left = low;
186
+ let right = middle;
187
+ while (left < middle && right < high)
188
+ target.push(isLess(source[right], source[left]) ? source[right++] : source[left++]);
189
+ while (left < middle) target.push(source[left++]);
190
+ while (right < high) target.push(source[right++]);
191
+ }
192
+ source = target;
193
+ }
194
+ return source;
195
+ };
196
+
195
197
  export class AlgebraicManager {
196
198
  private um = new UpolynomialManager();
197
199
  private pm = new PolynomialManager();
@@ -202,8 +204,6 @@ export class AlgebraicManager {
202
204
  power: (base, exponent) => this.power(base, exponent),
203
205
  };
204
206
 
205
- // Queries.
206
-
207
207
  isZero(anum: Anum) {
208
208
  return anum.value instanceof Rational && anum.value.isZero();
209
209
  }
@@ -217,7 +217,6 @@ export class AlgebraicManager {
217
217
  return new Anum(anum.value instanceof Rational ? anum.value : anum.value.clone());
218
218
  }
219
219
 
220
- // is_int: refines the interval until it holds at most one integer, then tests it.
221
220
  isInt(anum: Anum): boolean {
222
221
  if (anum.value instanceof Rational) return anum.value.isInt();
223
222
  const cell = anum.value;
@@ -231,8 +230,6 @@ export class AlgebraicManager {
231
230
  return false;
232
231
  }
233
232
 
234
- // is_rational: by the rational root theorem, the only candidate in an interval narrower than
235
- // 1/|a_n| is floor(u*|a_n|)/|a_n|.
236
233
  isRational(anum: Anum) {
237
234
  if (anum.value instanceof Rational) return true;
238
235
  const cell = anum.value;
@@ -250,7 +247,6 @@ export class AlgebraicManager {
250
247
  return isRoot;
251
248
  }
252
249
 
253
- // get_i: which root of its polynomial the number is.
254
250
  getRootIndex(anum: Anum) {
255
251
  if (anum.value instanceof Rational) return this.isZero(anum) ? 0 : 1;
256
252
  const cell = anum.value;
@@ -258,9 +254,6 @@ export class AlgebraicManager {
258
254
  return cell.rootIndex;
259
255
  }
260
256
 
261
- // Cells.
262
-
263
- // mk_algebraic_cell: the coefficients made primitive with a positive leading coefficient.
264
257
  private mkCell(p: Upolynomial, lower: Mpbq, upper: Mpbq, isMinimal: boolean) {
265
258
  const cell = new AlgebraicCell(p, lower, upper, isMinimal, false, isMinimal, 0);
266
259
  this.updateSignLower(cell);
@@ -276,13 +269,11 @@ export class AlgebraicManager {
276
269
  cell.isSignLowerNeg = this.um.evalSignAtBq(cell.p, cell.lower) < 0;
277
270
  }
278
271
 
279
- // set(a, p, l, u, minimal): the root of p in (l, u), a rational when p is linear.
280
272
  private mkAnum(p: Upolynomial, lower: Mpbq, upper: Mpbq, isMinimal: boolean) {
281
273
  if (p.length === 2) return new Anum(Rational.of(p[0]).div(Rational.of(p[1])).neg());
282
274
  return new Anum(this.mkCell(p, lower, upper, isMinimal));
283
275
  }
284
276
 
285
- // normalize: an interval around zero shrunk to the side of zero holding the root.
286
277
  private normalize(anum: Anum) {
287
278
  if (anum.value instanceof Rational) return;
288
279
  const cell = anum.value;
@@ -295,9 +286,6 @@ export class AlgebraicManager {
295
286
  cell.upper = interval.upper;
296
287
  }
297
288
 
298
- // Refinement.
299
-
300
- // refine: halves the interval, or finds the number rational and returns false.
301
289
  private refine(anum: Anum) {
302
290
  if (anum.value instanceof Rational) return false;
303
291
  const cell = anum.value;
@@ -316,7 +304,6 @@ export class AlgebraicManager {
316
304
  return true;
317
305
  }
318
306
 
319
- // refine_until_prec: refines until the interval is narrower than 1/2^precision.
320
307
  private refineUntilPrecision(anum: Anum, precision: number) {
321
308
  if (anum.value instanceof Rational) return true;
322
309
  const cell = anum.value;
@@ -339,7 +326,6 @@ export class AlgebraicManager {
339
326
  return { anum, lower: cell.lower, upper: cell.upper, isRestored: false };
340
327
  }
341
328
 
342
- // restore_if_too_small: swaps the saved interval back in when the current one is too narrow.
343
329
  private restoreIfTooSmall(saved: SavedInterval) {
344
330
  saved.isRestored = true;
345
331
  if (saved.anum.value instanceof Rational) return;
@@ -353,24 +339,20 @@ export class AlgebraicManager {
353
339
  ];
354
340
  }
355
341
 
356
- // ~save_intervals
357
342
  private releaseInterval(saved: SavedInterval) {
358
343
  if (!saved.isRestored) this.restoreIfTooSmall(saved);
359
344
  }
360
345
 
361
- // Root isolation.
362
-
363
346
  private factor(p: Upolynomial) {
364
347
  return factorUpolynomial(this.um, p, FACTOR_PARAMS);
365
348
  }
366
349
 
367
- // isolate_roots(up): the real roots of a univariate polynomial, factor by factor, sorted.
368
- private isolateUnivariateRoots(up: Upolynomial) {
350
+ private isolateUnivariateRoots(coeffs: Upolynomial) {
369
351
  const roots: Anum[] = [];
370
- if (up.length === 0) return roots;
371
- const hasZeroRoot = this.um.hasZeroRoots(up);
352
+ if (coeffs.length === 0) return roots;
353
+ const hasZeroRoot = this.um.hasZeroRoots(coeffs);
372
354
  if (hasZeroRoot) roots.push(new Anum(Rational.zero));
373
- const factored = this.factor(hasZeroRoot ? this.um.removeZeroRoots(up) : up);
355
+ const factored = this.factor(hasZeroRoot ? this.um.removeZeroRoots(coeffs) : coeffs);
374
356
  for (const factor of factored.factors.factors) {
375
357
  const degree = factor.length - 1;
376
358
  if (degree <= 0) continue;
@@ -399,32 +381,13 @@ export class AlgebraicManager {
399
381
  return roots;
400
382
  }
401
383
 
402
- // sort_roots: Z3's stable bottom-up merge sort, since each comparison may refine the roots.
403
384
  private sortRoots(roots: Anum[]) {
404
- const size = roots.length;
405
- if (size < 2) return;
406
- const isLess = (first: number, second: number) => {
407
- const sign = this.compare(roots[first], roots[second]);
408
- return sign !== 0 ? sign < 0 : first < second;
409
- };
410
- let source = roots.map((_root, index) => index);
411
- let target = [...source];
412
- for (let width = 1; width < size; width *= 2) {
413
- for (let low = 0; low < size; low += 2 * width) {
414
- const middle = Math.min(low + width, size);
415
- const high = Math.min(low + 2 * width, size);
416
- let left = low;
417
- let right = middle;
418
- let next = low;
419
- while (left < middle && right < high)
420
- target[next++] = isLess(source[right], source[left]) ? source[right++] : source[left++];
421
- while (left < middle) target[next++] = source[left++];
422
- while (right < high) target[next++] = source[right++];
423
- }
424
- [source, target] = [target, source];
425
- }
426
- const sorted = source.map((index) => roots[index]);
427
- for (let index = 0; index < size; index++) roots[index] = sorted[index];
385
+ if (roots.length < 2) return;
386
+ const sorted = mergeSortIndices(
387
+ roots.length,
388
+ (first, second) => this.compare(roots[first], roots[second]) < 0,
389
+ ).map((index) => roots[index]);
390
+ for (let index = 0; index < sorted.length; index++) roots[index] = sorted[index];
428
391
  }
429
392
 
430
393
  private getSignVariationsAtQ(sequence: Upolynomial[], value: Rational) {
@@ -440,7 +403,6 @@ export class AlgebraicManager {
440
403
  return count;
441
404
  }
442
405
 
443
- // isolate_kth_root: the i-th real root of a square-free p, by bisecting with its Sturm sequence.
444
406
  private isolateKthRoot(p: Upolynomial, sequence: Upolynomial[], rootIndex: number) {
445
407
  if (p.length === 2) return new Anum(Rational.of(p[0]).div(Rational.of(p[1])).neg());
446
408
  const minusInf = this.um.signVariationsAtMinusInf(sequence);
@@ -478,8 +440,6 @@ export class AlgebraicManager {
478
440
  );
479
441
  }
480
442
 
481
- // rational_root_in_interval: the root of p in (l, u) when it is rational, else the interval
482
- // refined below 1/|a_n|.
483
443
  private getRationalRootIn(p: Upolynomial, lower: Mpbq, upper: Mpbq): Rational | BqInterval {
484
444
  const leading = p[p.length - 1];
485
445
  const absLeading = leading < 0n ? -leading : leading;
@@ -491,17 +451,16 @@ export class AlgebraicManager {
491
451
  return { lower: refined.lower, upper: refined.upper };
492
452
  }
493
453
 
494
- // isolate_roots_closest_univariate: the roots next to s, s itself when it is a root.
495
- private isolateUnivariateClosest(
454
+ private isolateRootsClosestUnivariate(
496
455
  pm: PolynomialManager,
497
456
  polynomial: Polynomial,
498
457
  sample: Rational,
499
458
  ): ClosestAnums {
500
459
  const result: ClosestAnums = { roots: [], indices: [] };
501
460
  if (pm.isConst(polynomial)) return result;
502
- const up = pm.toCoeffs(polynomial);
503
- if (up.length === 0) return result;
504
- const p = this.um.squareFree(up);
461
+ const coeffs = pm.toCoeffs(polynomial);
462
+ if (coeffs.length === 0) return result;
463
+ const p = this.um.squareFree(coeffs);
505
464
  if (p.length <= 1) return result;
506
465
  const sequence = this.um.sturmSeq(p);
507
466
  const minusInf = this.um.signVariationsAtMinusInf(sequence);
@@ -522,9 +481,6 @@ export class AlgebraicManager {
522
481
  return result;
523
482
  }
524
483
 
525
- // isolate_roots(p, x2v): the roots of p in its one unassigned variable at the values of the
526
- // others. Resultants eliminate the irrational values, and the roots of the result that are not
527
- // roots of p are filtered out.
528
484
  isolateRoots(
529
485
  pm: PolynomialManager,
530
486
  polynomial: Polynomial,
@@ -549,15 +505,15 @@ export class AlgebraicManager {
549
505
  }
550
506
  if (q.size > 0) {
551
507
  if (pm.isConst(q)) return [];
552
- return this.filterRoots(pm, reduced, values, x, this.isolateUnivariateRoots(pm.toCoeffs(q)));
508
+ return this.isolateUnivariateRoots(pm.toCoeffs(q)).filter(
509
+ (root) => this.evalSignAt(pm, reduced, getExtended(values, x, root)) === 0,
510
+ );
553
511
  }
554
512
  if (isNested)
555
513
  throw new SmtInvariantError("resultant vanished during nested isolate_roots call");
556
514
  return this.isolateVanishedRoots(pm, reduced, values, xs, x);
557
515
  }
558
516
 
559
- // The resultant vanished, perhaps at another root of a value's polynomial: p's leading
560
- // coefficient at the values decides.
561
517
  private isolateVanishedRoots(
562
518
  pm: PolynomialManager,
563
519
  reduced: Polynomial,
@@ -583,7 +539,6 @@ export class AlgebraicManager {
583
539
  if (!this.isZero(leading)) break;
584
540
  }
585
541
  if (power === 0) return [];
586
- // z*x^i + c_{i-1}*x^{i-1} + ... + c_0, with z the value of the leading coefficient.
587
542
  const z = Math.max(...xs) + 1;
588
543
  const q = this.pm.add(
589
544
  this.pm.mul(this.pm.mkVar(z), this.pm.mkVar(x, power)),
@@ -592,7 +547,6 @@ export class AlgebraicManager {
592
547
  return this.isolateRoots(this.pm, q, getExtended(values, z, leading), true);
593
548
  }
594
549
 
595
- // convert: p in the local manager, without its monomials of degree above maxDegree in x.
596
550
  private convert(pm: PolynomialManager, polynomial: Polynomial, x = -1, maxDegree = Infinity) {
597
551
  if (pm === this.pm) return polynomial;
598
552
  const as: bigint[] = [];
@@ -606,7 +560,6 @@ export class AlgebraicManager {
606
560
  return this.pm.mkPolynomial(as, ms);
607
561
  }
608
562
 
609
- // std::stable_sort with var_degree_lt: by the degree of each value, unassigned last.
610
563
  private sortByDegree(xs: number[], values: readonly (Anum | undefined)[]) {
611
564
  const getDegree = (variable: number) => {
612
565
  const value = values[variable];
@@ -615,20 +568,6 @@ export class AlgebraicManager {
615
568
  return [...xs].sort((first, second) => getDegree(first) - getDegree(second));
616
569
  }
617
570
 
618
- // filter_roots: the roots at which p vanishes.
619
- private filterRoots(
620
- pm: PolynomialManager,
621
- polynomial: Polynomial,
622
- values: readonly (Anum | undefined)[],
623
- x: number,
624
- roots: Anum[],
625
- ) {
626
- return roots.filter(
627
- (root) => this.evalSignAt(pm, polynomial, getExtended(values, x, root)) === 0,
628
- );
629
- }
630
-
631
- // isolate_roots_closest: the roots of p next to the rational s, with their indices from 1.
632
571
  isolateRootsClosest(
633
572
  pm: PolynomialManager,
634
573
  polynomial: Polynomial,
@@ -637,12 +576,13 @@ export class AlgebraicManager {
637
576
  ): ClosestAnums {
638
577
  const result: ClosestAnums = { roots: [], indices: [] };
639
578
  if (pm.isConst(polynomial)) return result;
640
- if (pm.isUnivariate(polynomial)) return this.isolateUnivariateClosest(pm, polynomial, sample);
579
+ if (pm.isUnivariate(polynomial))
580
+ return this.isolateRootsClosestUnivariate(pm, polynomial, sample);
641
581
  const reduced = pm.substituteRational(polynomial, getRationalValues(values));
642
582
  if (pm.isConst(reduced)) return result;
643
583
  if (pm.isUnivariate(reduced)) {
644
584
  if (values[pm.maxVar(reduced)] !== undefined) return result;
645
- return this.isolateUnivariateClosest(pm, reduced, sample);
585
+ return this.isolateRootsClosestUnivariate(pm, reduced, sample);
646
586
  }
647
587
  const all = this.isolateRoots(pm, polynomial, values);
648
588
  const sampleAnum = new Anum(sample);
@@ -668,8 +608,6 @@ export class AlgebraicManager {
668
608
  return result;
669
609
  }
670
610
 
671
- // isolate_roots(p, x2v, roots, signs): the roots, and the sign of p below, between and above
672
- // them, at a sample the unassigned variables share.
673
611
  isolateRootsWithSigns(
674
612
  pm: PolynomialManager,
675
613
  polynomial: Polynomial,
@@ -691,11 +629,6 @@ export class AlgebraicManager {
691
629
  return { roots, signs };
692
630
  }
693
631
 
694
- // Signs.
695
-
696
- // eval_sign_at: the sign of p at the values. Rational values are substituted, interval
697
- // arithmetic on the irrational ones decides most signs, and otherwise a lower bound on the
698
- // nonzero roots of the resultant with their polynomials tells zero apart.
699
632
  evalSignAt(pm: PolynomialManager, polynomial: Polynomial, values: readonly (Anum | undefined)[]) {
700
633
  while (true) {
701
634
  const rationalValues = getRationalValues(values);
@@ -733,7 +666,6 @@ export class AlgebraicManager {
733
666
  }
734
667
  }
735
668
 
736
- // The resultant step of eval_sign_at, or null when a value turned rational and it restarts.
737
669
  private evalSignByResultant(
738
670
  pm: PolynomialManager,
739
671
  reduced: Polynomial,
@@ -767,8 +699,6 @@ export class AlgebraicManager {
767
699
  return sign;
768
700
  }
769
701
 
770
- // Arithmetic.
771
-
772
702
  add(first: Anum, second: Anum): Anum {
773
703
  if (this.isZero(first)) return this.copy(second);
774
704
  if (this.isZero(second)) return this.copy(first);
@@ -780,7 +710,6 @@ export class AlgebraicManager {
780
710
  return this.mkBinary(first, second, true);
781
711
  }
782
712
 
783
- // add(cell, basic): p(x - b), with the interval shifted by b.
784
713
  private addRational(cell: AlgebraicCell, value: Rational) {
785
714
  const p = this.um.translateQ(cell.p, value.neg());
786
715
  const shift = Mpbq.fromRational(value);
@@ -806,7 +735,6 @@ export class AlgebraicManager {
806
735
  return this.mkBinary(first, second, false);
807
736
  }
808
737
 
809
- // mul(cell, basic): b^n * p(x/b), with the interval scaled by b.
810
738
  private mulRational(cell: AlgebraicCell, value: Rational) {
811
739
  const p = this.um.composePQX(cell.p, Rational.one.div(value));
812
740
  const scale = Mpbq.fromRational(value);
@@ -830,7 +758,6 @@ export class AlgebraicManager {
830
758
  return result;
831
759
  }
832
760
 
833
- // neg: p(-x) with the interval mirrored, in place.
834
761
  neg(anum: Anum) {
835
762
  if (anum.value instanceof Rational) {
836
763
  anum.value = anum.value.neg();
@@ -843,7 +770,6 @@ export class AlgebraicManager {
843
770
  this.updateSignLower(cell);
844
771
  }
845
772
 
846
- // refine_nz_bound: moves an interval end off zero, halving it until its sign is right.
847
773
  private refineNonzeroBound(anum: Anum) {
848
774
  if (anum.value instanceof Rational) return;
849
775
  const cell = anum.value;
@@ -864,7 +790,6 @@ export class AlgebraicManager {
864
790
  }
865
791
  }
866
792
 
867
- // inv: x^n * p(1/x), with the interval (1/u, 1/l), in place.
868
793
  inv(anum: Anum) {
869
794
  if (this.isZero(anum)) throw new SmtInvariantError("division by zero");
870
795
  this.refineNonzeroBound(anum);
@@ -902,20 +827,16 @@ export class AlgebraicManager {
902
827
  return this.mkPower(anum, exponent);
903
828
  }
904
829
 
905
- // mk_add_polynomial: Res_y(pa(x - y), pb(y)), which has a + b as a root.
906
830
  private getSumPolynomial(first: AlgebraicCell, second: AlgebraicCell) {
907
- const pa = this.pm.composeXMinusY(this.pm.fromCoeffs(first.p, X), Y);
908
- return this.pm.toCoeffs(this.pm.resultant(pa, this.pm.fromCoeffs(second.p, Y), Y));
831
+ const composed = this.pm.composeXMinusY(this.pm.fromCoeffs(first.p, X), Y);
832
+ return this.pm.toCoeffs(this.pm.resultant(composed, this.pm.fromCoeffs(second.p, Y), Y));
909
833
  }
910
834
 
911
- // mk_mul_polynomial: Res_y(y^n * pa(x/y), pb(y)), which has a*b as a root.
912
835
  private getProductPolynomial(first: AlgebraicCell, second: AlgebraicCell) {
913
- const pa = this.pm.composeXDivY(this.pm.fromCoeffs(first.p, X), Y);
914
- return this.pm.toCoeffs(this.pm.resultant(pa, this.pm.fromCoeffs(second.p, Y), Y));
836
+ const composed = this.pm.composeXDivY(this.pm.fromCoeffs(first.p, X), Y);
837
+ return this.pm.toCoeffs(this.pm.resultant(composed, this.pm.fromCoeffs(second.p, Y), Y));
915
838
  }
916
839
 
917
- // The factors of p whose Sturm sequence counts exactly one root in an interval, until only one
918
- // factor is left.
919
840
  private findIsolatingFactor(
920
841
  factors: bigint[][],
921
842
  sequences: (Upolynomial[] | null)[],
@@ -945,8 +866,6 @@ export class AlgebraicManager {
945
866
  : null;
946
867
  }
947
868
 
948
- // mk_binary: a + b or a*b for irrational a and b, refining both until the interval of the result
949
- // isolates a root of one factor of the resultant.
950
869
  private mkBinary(first: Anum, second: Anum, isAdd: boolean) {
951
870
  const cellA = getCell(first);
952
871
  const cellB = getCell(second);
@@ -976,13 +895,11 @@ export class AlgebraicManager {
976
895
  }
977
896
  }
978
897
 
979
- // mk_power_polynomial: Res_y(x - y^k, pa(y)), which has a^k as a root.
980
898
  private getPowerPolynomial(cell: AlgebraicCell, exponent: number) {
981
899
  const x = this.pm.sub(this.pm.mkVar(X), this.pm.mkVar(Y, exponent));
982
900
  return this.pm.toCoeffs(this.pm.resultant(x, this.pm.fromCoeffs(cell.p, Y), Y));
983
901
  }
984
902
 
985
- // mk_unary with mk_power_polynomial: a^k for an irrational a.
986
903
  private mkPower(anum: Anum, exponent: number): Anum {
987
904
  const cell = getCell(anum);
988
905
  const factored = this.factor(this.getPowerPolynomial(cell, exponent));
@@ -1003,7 +920,6 @@ export class AlgebraicManager {
1003
920
  }
1004
921
  }
1005
922
 
1006
- // set_core: the root of p in an isolating interval that may contain zero.
1007
923
  private setCore(found: IsolatingFactor, interval: BqInterval, isMinimal: boolean) {
1008
924
  const p = found.factor;
1009
925
  let lower = interval.lower;
@@ -1019,9 +935,6 @@ export class AlgebraicManager {
1019
935
  return this.mkAnum(nonzero, refined.lower, refined.upper, isMinimal);
1020
936
  }
1021
937
 
1022
- // Comparison.
1023
-
1024
- // compare(cell, b): by the interval, or by the sign of p at b.
1025
938
  private compareRational(cell: AlgebraicCell, value: Rational) {
1026
939
  if (cell.upper.compareRational(value) <= 0) return -1;
1027
940
  if (cell.lower.compareRational(value) >= 0) return 1;
@@ -1039,8 +952,6 @@ export class AlgebraicManager {
1039
952
  return this.compareCore(first, second);
1040
953
  }
1041
954
 
1042
- // compare_core: refines both intervals to a common magnitude, then tries a wider separation, and
1043
- // last the sign of pb at a by a Sturm-Tarski sequence.
1044
955
  private compareCore(first: Anum, second: Anum): number {
1045
956
  const cellA = getCell(first);
1046
957
  const cellB = getCell(second);
@@ -1048,7 +959,7 @@ export class AlgebraicManager {
1048
959
  cellA.upper.compare(cellB.lower) <= 0 ? -1 : cellA.lower.compare(cellB.upper) >= 0 ? 1 : 0;
1049
960
  let sign = compareIntervals();
1050
961
  if (sign !== 0) return sign;
1051
- if (sameCoeffs(cellA.p, cellB.p)) return 0;
962
+ if (hasSameCoeffs(cellA.p, cellB.p)) return 0;
1052
963
  if (cellA.isMinimal && cellB.isMinimal)
1053
964
  while (true) {
1054
965
  this.refine(first);
@@ -1074,7 +985,6 @@ export class AlgebraicManager {
1074
985
  sign = compareIntervals();
1075
986
  if (sign !== 0) return sign;
1076
987
  }
1077
- // get_interval at precision 10: copies of the intervals refined below 1/2^40.
1078
988
  const intervalA = this.um.refineToPrecision(cellA.p, cellA.lower, cellA.upper, 40);
1079
989
  const intervalB = this.um.refineToPrecision(cellB.p, cellB.lower, cellB.upper, 40);
1080
990
  if (intervalA.isInterval && intervalB.isInterval) {
@@ -1093,9 +1003,6 @@ export class AlgebraicManager {
1093
1003
  return variations < 0 === cellB.signLower < 0 ? -1 : 1;
1094
1004
  }
1095
1005
 
1096
- // Sample points.
1097
-
1098
- // int_lt: an integer below a.
1099
1006
  intLt(anum: Anum) {
1100
1007
  this.refineUntilPrecision(anum, 1);
1101
1008
  return new Anum(
@@ -1105,7 +1012,6 @@ export class AlgebraicManager {
1105
1012
  );
1106
1013
  }
1107
1014
 
1108
- // int_gt: an integer above a.
1109
1015
  intGt(anum: Anum) {
1110
1016
  this.refineUntilPrecision(anum, 1);
1111
1017
  return new Anum(
@@ -1115,7 +1021,6 @@ export class AlgebraicManager {
1115
1021
  );
1116
1022
  }
1117
1023
 
1118
- // separate: refines until the intervals of prev and curr do not touch.
1119
1024
  private separate(previous: Anum, current: Anum) {
1120
1025
  if (previous.value instanceof Rational) {
1121
1026
  const value = previous.value;
@@ -1145,14 +1050,13 @@ export class AlgebraicManager {
1145
1050
  }
1146
1051
  }
1147
1052
 
1148
- // select: a binary rational between prev < curr with the smallest denominator.
1149
1053
  select(previous: Anum, current: Anum) {
1150
1054
  this.separate(previous, current);
1151
- const lower: SelectEnd =
1055
+ const lower =
1152
1056
  previous.value instanceof Rational
1153
1057
  ? { value: previous.value, isOpen: true }
1154
1058
  : { value: previous.value.upper.toRational(), isOpen: false };
1155
- const upper: SelectEnd =
1059
+ const upper =
1156
1060
  current.value instanceof Rational
1157
1061
  ? { value: current.value, isOpen: true }
1158
1062
  : { value: current.value.lower.toRational(), isOpen: false };