tla-ts 0.0.4 → 0.0.5-dev.cc59f31

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 (378) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +46 -12
  8. package/dist/index.d.ts +46 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +361 -181
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +207 -141
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +39 -23
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +166 -111
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,43 @@
1
+ // Ported from Z3 (src/nlsat/nlsat_types.h, src/nlsat/nlsat_clause.h), MIT license, see
2
+ // z3-license.txt. The atoms and clauses of nlsat. A literal is 2 * boolVar + sign, where sign 1
3
+ // negates the atom.
4
+ import type { Dependency } from "../lp/dependency";
5
+ import type { Polynomial } from "./polynomial";
6
+
7
+ export type IneqKind = "EQ" | "LT" | "GT";
8
+ export type RootKind = "ROOT_EQ" | "ROOT_LT" | "ROOT_GT" | "ROOT_LE" | "ROOT_GE";
9
+
10
+ // p1 * ... * pn kind 0, where isEven[i] marks a factor of even degree, which only its zeros
11
+ // matter for. maxVar is the largest maximal variable of the factors.
12
+ export interface IneqAtom {
13
+ kind: IneqKind;
14
+ boolVar: number;
15
+ maxVar: number;
16
+ polynomials: Polynomial[];
17
+ isEven: boolean[];
18
+ }
19
+
20
+ // x kind root[index](p): the index-th real root of p, from 1, as a polynomial in x at the values of
21
+ // the variables below x. maxVar is x.
22
+ export interface RootAtom {
23
+ kind: RootKind;
24
+ boolVar: number;
25
+ maxVar: number;
26
+ index: number;
27
+ polynomial: Polynomial;
28
+ }
29
+
30
+ export type Atom = IneqAtom | RootAtom;
31
+
32
+ // A clause, with the assumptions it depends on. isActive marks a learned clause that took part in
33
+ // a conflict since the last garbage collection.
34
+ export interface Clause {
35
+ id: number;
36
+ literals: number[];
37
+ isLearned: boolean;
38
+ assumptions: Dependency;
39
+ isActive: boolean;
40
+ }
41
+
42
+ export const isIneqAtom = (atom: Atom): atom is IneqAtom =>
43
+ atom.kind === "EQ" || atom.kind === "LT" || atom.kind === "GT";
@@ -0,0 +1,648 @@
1
+ // Ported from Z3 (src/math/polynomial/upolynomial_factorization{.cpp,_int.h}, the factorization
2
+ // in src/math/polynomial/upolynomial.cpp, src/util/prime_generator.cpp and mpz_manager::root),
3
+ // MIT license, see z3-license.txt. Factorization of univariate integer polynomials: square-free
4
+ // decomposition, Berlekamp's algorithm in Z_p for small primes p, quadratic Hensel lifting to
5
+ // p^e above a Mignotte bound, and a search over combinations of the lifted factors (Zassenhaus).
6
+ import { type Upolynomial, UpolynomialManager } from "./upolynomial";
7
+
8
+ const UINT_MAX = 4294967295;
9
+
10
+ export interface FactorParams {
11
+ // Factor in Z_p for primes p up to maxPrime.
12
+ maxPrime: number;
13
+ // The number of factorizations in Z_p whose degree sets are intersected before lifting.
14
+ primeTrials: number;
15
+ // The most combinations of lifted factors the search tries.
16
+ maxSearchSize: number;
17
+ }
18
+
19
+ // polynomial::factor_params(), which polynomial factorization and nlsat use.
20
+ export const DEFAULT_FACTOR_PARAMS: FactorParams = {
21
+ maxPrime: UINT_MAX,
22
+ primeTrials: 4,
23
+ maxSearchSize: UINT_MAX,
24
+ };
25
+
26
+ // constant * factors[0]^degrees[0] * ... * factors[n]^degrees[n].
27
+ export interface UpolynomialFactors {
28
+ constant: bigint;
29
+ factors: bigint[][];
30
+ degrees: number[];
31
+ }
32
+
33
+ const mkFactors = (): UpolynomialFactors => ({ constant: 1n, factors: [], degrees: [] });
34
+
35
+ const getTotalFactors = (fs: UpolynomialFactors) =>
36
+ fs.degrees.reduce((total, degree) => total + degree, 0);
37
+
38
+ const getTotalDegree = (fs: UpolynomialFactors) =>
39
+ fs.factors.reduce((total, factor, index) => total + (factor.length - 1) * fs.degrees[index], 0);
40
+
41
+ const pushFactor = (
42
+ um: UpolynomialManager,
43
+ fs: UpolynomialFactors,
44
+ factor: Upolynomial,
45
+ degree: number,
46
+ ) => {
47
+ fs.factors.push(um.set(factor));
48
+ fs.degrees.push(degree);
49
+ };
50
+
51
+ // factors::multiply
52
+ const multiplyFactors = (um: UpolynomialManager, fs: UpolynomialFactors) => {
53
+ if (fs.constant === 0n) return [];
54
+ let result = [um.normalizeNumeral(fs.constant)];
55
+ for (let index = 0; index < fs.factors.length; index++)
56
+ result = um.mul(
57
+ result,
58
+ fs.degrees[index] > 1 ? um.pw(fs.factors[index], fs.degrees[index]) : fs.factors[index],
59
+ );
60
+ return result;
61
+ };
62
+
63
+ // prime_iterator: 2, 3, 5, 7, ...
64
+ const mkPrimeIterator = () => {
65
+ let current = 1;
66
+ return () => {
67
+ for (current++; ; current++) {
68
+ let isPrime = true;
69
+ for (let divisor = 2; divisor * divisor <= current; divisor++)
70
+ if (current % divisor === 0) {
71
+ isPrime = false;
72
+ break;
73
+ }
74
+ if (isPrime) return current;
75
+ }
76
+ };
77
+ };
78
+
79
+ // mpz_manager::root for n = 2: bisection from powers of two, returning the upper end when the
80
+ // square root is not an integer.
81
+ const getSquareRoot = (value: bigint) => {
82
+ if (value === 0n) return value;
83
+ const log2 = value.toString(2).length - 1;
84
+ let lower = 1n << BigInt(Math.floor(log2 / 2));
85
+ let upper = 1n << BigInt(Math.ceil((log2 + 1) / 2));
86
+ if (lower === upper) return lower;
87
+ while (true) {
88
+ const middle = (upper + lower) >> 1n;
89
+ const square = middle * middle;
90
+ if (square === value) return middle;
91
+ if (middle === lower || middle === upper) return upper;
92
+ if (square < value) lower = middle;
93
+ else upper = middle;
94
+ }
95
+ };
96
+
97
+ // mpz_manager::is_perfect_square: the nonnegative square root, or null.
98
+ export const getExactSquareRoot = (value: bigint) => {
99
+ if (value < 0n) return null;
100
+ if (value < 2n) return value;
101
+ let root = BigInt(Math.floor(Math.sqrt(Number(value))));
102
+ while (root * root > value) root--;
103
+ while ((root + 1n) * (root + 1n) <= value) root++;
104
+ return root * root === value ? root : null;
105
+ };
106
+
107
+ // factorization_degree_set: the degrees that products of the factors can have.
108
+ const getDegreeSet = (fs: UpolynomialFactors) => {
109
+ let set = [true];
110
+ for (let index = 0; index < fs.factors.length; index++) {
111
+ const degree = fs.factors[index].length - 1;
112
+ for (let count = 0; count < fs.degrees[index]; count++) {
113
+ const shifted = [...Array.from({ length: degree }, () => false), ...set];
114
+ set = shifted.map((isIn, position) => isIn || (set[position] ?? false));
115
+ }
116
+ }
117
+ return set;
118
+ };
119
+
120
+ const isTrivialDegreeSet = (set: readonly boolean[]) => {
121
+ for (let degree = 1; degree < set.length - 1; degree++) if (set[degree]) return false;
122
+ return true;
123
+ };
124
+
125
+ // berlekamp_matrix: Q - I, where row i of Q holds x^(p*i) modulo f.
126
+ class BerlekampMatrix {
127
+ private matrix: bigint[];
128
+ private size: number;
129
+ private nullRow = 1;
130
+ private columnPivot: number[];
131
+ private rowPivot: number[];
132
+
133
+ constructor(
134
+ private zp: UpolynomialManager,
135
+ f: Upolynomial,
136
+ ) {
137
+ const size = f.length - 1;
138
+ this.size = size;
139
+ this.columnPivot = Array.from({ length: size }, () => -1);
140
+ this.rowPivot = Array.from({ length: size }, () => -1);
141
+ const prime = Number(zp.zp);
142
+ this.matrix = [1n, ...Array.from({ length: size }, () => 0n)];
143
+ let row = 0;
144
+ for (let k = 1, previousRow = 0; ; previousRow = row, k++) {
145
+ if (k % prime === 1) {
146
+ if (++row >= size) break;
147
+ for (let column = 0; column < size; column++) this.matrix.push(0n);
148
+ }
149
+ const multiplier = this.get(previousRow, size - 1);
150
+ for (let column = size - 1; column > 0; column--)
151
+ this.put(row, column, this.get(previousRow, column - 1) - multiplier * f[column]);
152
+ this.put(row, 0, -(f[0] * multiplier));
153
+ }
154
+ for (let index = 0; index < size; index++) this.put(index, index, this.get(index, index) - 1n);
155
+ }
156
+
157
+ private get(row: number, column: number) {
158
+ return this.matrix[row * this.size + column];
159
+ }
160
+
161
+ private put(row: number, column: number, value: bigint) {
162
+ this.matrix[row * this.size + column] = this.zp.normalizeNumeral(value);
163
+ }
164
+
165
+ // diagonalize: column operations that turn each pivot into -1. Returns the rank of the null
166
+ // space.
167
+ diagonalize() {
168
+ let nullRank = 0;
169
+ for (let row = 0; row < this.size; row++) {
170
+ let isColumnFound = false;
171
+ for (let column = 0; column < this.size; column++) {
172
+ if (this.columnPivot[column] >= 0 || this.get(row, column) === 0n) continue;
173
+ isColumnFound = true;
174
+ this.columnPivot[column] = row;
175
+ this.rowPivot[row] = column;
176
+ const pivotMultiplier = this.zp.normalizeNumeral(-this.zp.inv(this.get(row, column)));
177
+ for (let other = this.nullRow; other < this.size; other++)
178
+ this.put(other, column, this.get(other, column) * pivotMultiplier);
179
+ for (let otherColumn = 0; otherColumn < this.size; otherColumn++) {
180
+ if (otherColumn === column) continue;
181
+ const multiplier = this.get(row, otherColumn);
182
+ for (let other = this.nullRow; other < this.size; other++)
183
+ this.put(
184
+ other,
185
+ otherColumn,
186
+ this.get(other, otherColumn) + multiplier * this.get(other, column),
187
+ );
188
+ }
189
+ }
190
+ if (!isColumnFound) nullRank++;
191
+ }
192
+ return nullRank;
193
+ }
194
+
195
+ // next_null_space_vector: the next basis vector of the null space, skipping [1, 0, ..., 0].
196
+ nextNullSpaceVector() {
197
+ for (; this.nullRow < this.size; this.nullRow++) {
198
+ if (this.rowPivot[this.nullRow] >= 0) continue;
199
+ const vector = Array.from({ length: this.size }, (_unused, column) =>
200
+ this.rowPivot[column] >= 0
201
+ ? this.get(this.nullRow, this.rowPivot[column])
202
+ : column === this.nullRow
203
+ ? 1n
204
+ : 0n,
205
+ );
206
+ this.nullRow++;
207
+ return vector;
208
+ }
209
+ return null;
210
+ }
211
+ }
212
+
213
+ // zp_factor_square_free_berlekamp, deterministic: splits the monic square-free f in Z_p with
214
+ // gcd(v - s, f) for the null space vectors v of Q - I. Returns false when f is irreducible.
215
+ const factorSquareFreeInZp = (zp: UpolynomialManager, f: Upolynomial, fs: UpolynomialFactors) => {
216
+ const prime = Number(zp.zp);
217
+ const matrix = new BerlekampMatrix(zp, f);
218
+ const firstFactor = fs.factors.length;
219
+ pushFactor(zp, fs, f, 1);
220
+ const nullRank = matrix.diagonalize();
221
+ if (nullRank === 1) return false;
222
+ for (let vector = matrix.nextNullSpaceVector(); vector !== null;) {
223
+ const trimmed = zp.set(vector);
224
+ const factorEnd = fs.factors.length;
225
+ for (let factorIndex = firstFactor; factorIndex < factorEnd; factorIndex++) {
226
+ if (fs.factors[factorIndex].length === 2) continue;
227
+ for (let shift = 0; shift < prime; shift++) {
228
+ const current = fs.factors[factorIndex];
229
+ trimmed[0] = zp.normalizeNumeral(trimmed[0] - 1n);
230
+ const common = zp.gcd(trimmed, current);
231
+ if (common.length !== 1 && common.length !== current.length) {
232
+ fs.factors[factorIndex] = zp.div(current, common);
233
+ pushFactor(zp, fs, common, 1);
234
+ }
235
+ if (fs.factors.length - firstFactor === nullRank) return true;
236
+ }
237
+ }
238
+ vector = matrix.nextNullSpaceVector();
239
+ }
240
+ return true;
241
+ };
242
+
243
+ // hensel_lift: from C = A*B (mod b) and U*A + V*B = 1 (mod r) with r | b, the A1 = A (mod b) and
244
+ // B1 = B (mod b) with C = A1*B1 (mod b*r), deg(A1) = deg(A) and lc(A1) = lc(A).
245
+ const henselLiftOnce = (
246
+ z: UpolynomialManager,
247
+ b: bigint,
248
+ r: bigint,
249
+ polynomials: { u: Upolynomial; a: Upolynomial; v: Upolynomial; b: Upolynomial; c: Upolynomial },
250
+ ) => {
251
+ const zr = new UpolynomialManager(r);
252
+ const f = zr.set(z.divConst(z.sub(polynomials.c, z.mul(polynomials.a, polynomials.b)), b));
253
+ const division = zr.divRem(zr.mul(polynomials.v, f), polynomials.a);
254
+ const t = zr.add(zr.mul(polynomials.u, f), zr.mul(polynomials.b, division.quotient));
255
+ return {
256
+ a: z.add(polynomials.a, z.mulConst(division.remainder, b)),
257
+ b: z.add(polynomials.b, z.mulConst(t, b)),
258
+ };
259
+ };
260
+
261
+ // hensel_lift_quadratic: lifts C = A*B from Z_p to Z_(p^e), squaring the modulus of zpe and
262
+ // lifting U*A + V*B = 1 along with A and B.
263
+ const henselLiftQuadratic = (
264
+ z: UpolynomialManager,
265
+ c: Upolynomial,
266
+ zpe: UpolynomialManager,
267
+ a: Upolynomial,
268
+ b: Upolynomial,
269
+ e: number,
270
+ ) => {
271
+ const zp = new UpolynomialManager(zpe.zp);
272
+ const ext = zp.extGcd(a, b);
273
+ let u = ext.u;
274
+ let v = ext.v;
275
+ let currentA = [...a];
276
+ let currentB = [...b];
277
+ for (let k = 1; k < e; k *= 2) {
278
+ const modulus = zpe.zp as bigint;
279
+ const lifted = henselLiftOnce(z, modulus, modulus, {
280
+ u,
281
+ a: currentA,
282
+ v,
283
+ b: currentB,
284
+ c,
285
+ });
286
+ const g = zpe.set(
287
+ z.divConst(z.sub(z.sub([1n], z.mul(lifted.a, u)), z.mul(lifted.b, v)), modulus),
288
+ );
289
+ const division = zpe.divRem(zpe.mul(g, v), currentA);
290
+ const s = zpe.add(zpe.mul(g, u), zpe.mul(division.quotient, currentB));
291
+ u = z.add(u, z.mulConst(s, modulus));
292
+ v = z.add(v, z.mulConst(division.remainder, modulus));
293
+ zpe.squareModulus();
294
+ u = zpe.set(u);
295
+ v = zpe.set(v);
296
+ currentA = zpe.set(lifted.a);
297
+ currentB = zpe.set(lifted.b);
298
+ }
299
+ return { a: currentA, b: currentB };
300
+ };
301
+
302
+ // hensel_lift: the monic factors of f in Z_p lifted one by one to Z_(p^e), the last one carrying
303
+ // lc(f) until it is divided out.
304
+ const henselLiftFactors = (
305
+ z: UpolynomialManager,
306
+ f: Upolynomial,
307
+ zp: UpolynomialManager,
308
+ zpFs: UpolynomialFactors,
309
+ e: number,
310
+ zpe: UpolynomialManager,
311
+ ) => {
312
+ const prime = zp.zp as bigint;
313
+ const zpeFs = mkFactors();
314
+ zpe.setZp(prime);
315
+ let parts = z.set(f);
316
+ let b: Upolynomial = [];
317
+ for (let index = 0; index < zpFs.factors.length - 1; index++) {
318
+ const a = zp.set(zpFs.factors[index]);
319
+ const c =
320
+ index > 0
321
+ ? zp.set(parts)
322
+ : zp.mulConst(multiplyFactors(zp, zpFs), zp.normalizeNumeral(f[f.length - 1]));
323
+ zpe.setZp(prime);
324
+ const lifted = henselLiftQuadratic(z, parts, zpe, a, zp.div(c, a), e);
325
+ b = lifted.b;
326
+ if (index === 0) parts = zpe.set(f);
327
+ parts = zpe.div(parts, lifted.a);
328
+ zpeFs.factors.push(lifted.a);
329
+ zpeFs.degrees.push(1);
330
+ }
331
+ zpeFs.factors.push(zpe.mulConst(b, zpe.inv(f[f.length - 1])));
332
+ zpeFs.degrees.push(1);
333
+ return zpeFs;
334
+ };
335
+
336
+ // mignotte_bound: the e, a power of two, with p^e above 2^n * (|f| + |lc(f)|) for n = deg(f)/2,
337
+ // which bounds twice the coefficients of the factors of degree at most n.
338
+ const getMignotteBound = (f: Upolynomial, prime: bigint) => {
339
+ let squareNorm = 0n;
340
+ for (const coeff of f) if (coeff !== 0n) squareNorm += coeff * coeff;
341
+ const leading = f[f.length - 1];
342
+ const bound =
343
+ (1n << BigInt(Math.floor((f.length - 1) / 2))) *
344
+ (getSquareRoot(squareNorm) + (leading < 0n ? -leading : leading));
345
+ let e = 1;
346
+ for (let power = prime; power <= bound; e *= 2) power *= power;
347
+ return e;
348
+ };
349
+
350
+ // ufactorization_combination_iterator: the subsets of the enabled factors, smallest first and at
351
+ // most half of them, whose degree is in the degree set. Selected factors that turn out to be true
352
+ // factors are removed from later subsets.
353
+ class CombinationIterator {
354
+ private totalSize: number;
355
+ private maxSize: number;
356
+ private isEnabled: boolean[];
357
+ private currentSize = 0;
358
+ private current: number[];
359
+
360
+ constructor(
361
+ private zpe: UpolynomialManager,
362
+ private fs: UpolynomialFactors,
363
+ private degreeSet: readonly boolean[],
364
+ ) {
365
+ const count = fs.factors.length;
366
+ this.totalSize = count;
367
+ this.maxSize = Math.floor(count / 2);
368
+ this.isEnabled = Array.from({ length: count }, () => true);
369
+ this.current = Array.from({ length: count + 1 }, () => count);
370
+ }
371
+
372
+ private find(position: number, upperBound: number) {
373
+ let candidate = this.current[position] + 1;
374
+ while (candidate < upperBound && !this.isEnabled[candidate]) candidate++;
375
+ return candidate === upperBound ? -1 : candidate;
376
+ }
377
+
378
+ next(isRemovingCurrent: boolean) {
379
+ const maxUpperBound = this.fs.factors.length;
380
+ let isRemoving = isRemovingCurrent;
381
+ do {
382
+ let position = this.currentSize - 1;
383
+ let value = -1;
384
+ if (isRemoving) {
385
+ for (position = this.currentSize - 1; position > 0; position--) {
386
+ this.isEnabled[this.current[position]] = false;
387
+ this.current[position] = maxUpperBound;
388
+ }
389
+ this.isEnabled[this.current[0]] = false;
390
+ isRemoving = false;
391
+ this.totalSize -= this.currentSize;
392
+ this.maxSize = Math.floor(this.totalSize / 2);
393
+ }
394
+ while (position >= 0) {
395
+ value = this.find(position, this.current[position + 1]);
396
+ if (value >= 0) {
397
+ this.current[position] = value;
398
+ break;
399
+ }
400
+ position--;
401
+ }
402
+ do {
403
+ if (value === -1) {
404
+ if (this.currentSize >= this.maxSize) return false;
405
+ this.currentSize++;
406
+ this.current[0] = -1;
407
+ position = 0;
408
+ value = this.find(position, maxUpperBound);
409
+ if (value === -1) return false;
410
+ this.current[position] = value;
411
+ }
412
+ for (position++; position < this.currentSize; position++) {
413
+ this.current[position] = this.current[position - 1];
414
+ value = this.find(position, maxUpperBound);
415
+ if (value === -1) {
416
+ this.current[0] = -1;
417
+ break;
418
+ }
419
+ this.current[position] = value;
420
+ }
421
+ } while (value === -1);
422
+ } while (!this.degreeSet[this.getCurrentDegree()]);
423
+ return true;
424
+ }
425
+
426
+ getCurrentDegree() {
427
+ let degree = 0;
428
+ for (let index = 0; index < this.currentSize; index++)
429
+ degree += this.fs.factors[this.current[index]].length - 1;
430
+ return degree;
431
+ }
432
+
433
+ // The enabled factors outside the selection, in order.
434
+ private getRest() {
435
+ const rest: number[] = [];
436
+ for (let factor = 0, selected = 0; factor < this.fs.factors.length; factor++) {
437
+ if (!this.isEnabled[factor]) continue;
438
+ if (selected >= this.current.length || factor < this.current[selected]) rest.push(factor);
439
+ else selected++;
440
+ }
441
+ return rest;
442
+ }
443
+
444
+ getLeft() {
445
+ let result = this.zpe.set(this.fs.factors[this.current[0]]);
446
+ for (let index = 1; index < this.currentSize; index++)
447
+ result = this.zpe.mul(result, this.fs.factors[this.current[index]]);
448
+ return result;
449
+ }
450
+
451
+ getRight() {
452
+ let result: bigint[] = [];
453
+ for (const factor of this.getRest())
454
+ result =
455
+ result.length === 0
456
+ ? this.zpe.set(this.fs.factors[factor])
457
+ : this.zpe.mul(result, this.fs.factors[factor]);
458
+ return result;
459
+ }
460
+
461
+ // get_left_tail_coeff, get_right_tail_coeff: m times the constant terms of the side's factors.
462
+ getLeftTailCoeff(multiplier: bigint) {
463
+ let result = this.zpe.normalizeNumeral(multiplier);
464
+ for (let index = 0; index < this.currentSize; index++)
465
+ result = this.zpe.normalizeNumeral(result * this.fs.factors[this.current[index]][0]);
466
+ return result;
467
+ }
468
+
469
+ getRightTailCoeff(multiplier: bigint) {
470
+ let result = this.zpe.normalizeNumeral(multiplier);
471
+ for (const factor of this.getRest())
472
+ result = this.zpe.normalizeNumeral(result * this.fs.factors[factor][0]);
473
+ return result;
474
+ }
475
+ }
476
+
477
+ const divides = (divisor: bigint, dividend: bigint) =>
478
+ divisor === 0n ? dividend === 0n : dividend % divisor === 0n;
479
+
480
+ // factor_square_free: the factors of the primitive square-free f in Z[x], each pushed with
481
+ // multiplicity k. Returns false when a limit in params stopped the search, leaving a factor that
482
+ // may be reducible.
483
+ export const factorSquareFree = (
484
+ z: UpolynomialManager,
485
+ f: Upolynomial,
486
+ fs: UpolynomialFactors,
487
+ k: number,
488
+ params: FactorParams,
489
+ ) => {
490
+ let fPp = z.set(f);
491
+ if (fPp.length > 0 && fPp[fPp.length - 1] < 0n) {
492
+ fPp = fPp.map((coeff) => -coeff);
493
+ if (k % 2 === 1) fs.constant = -fs.constant;
494
+ }
495
+ const zp = new UpolynomialManager(2n);
496
+ let zpFs = mkFactors();
497
+ let zpFsPrime = 2n;
498
+ let degreeSet = [true];
499
+ const getNextPrime = mkPrimeIterator();
500
+ for (let trials = 0; trials <= params.primeTrials;) {
501
+ const nextPrime = getNextPrime();
502
+ if (nextPrime > params.maxPrime) {
503
+ pushFactor(z, fs, fPp, k);
504
+ return false;
505
+ }
506
+ const prime = BigInt(nextPrime);
507
+ zp.setZp(prime);
508
+ if (fPp[fPp.length - 1] % prime === 0n) continue;
509
+ const fPpZp = zp.set(fPp);
510
+ if (!zp.isSquareFree(fPpZp)) continue;
511
+ const currentFs = mkFactors();
512
+ if (!factorSquareFreeInZp(zp, zp.mkMonic(fPpZp), currentFs)) {
513
+ pushFactor(z, fs, fPp, k);
514
+ return true;
515
+ }
516
+ const currentDegreeSet = getDegreeSet(currentFs);
517
+ degreeSet =
518
+ degreeSet.length === 1
519
+ ? currentDegreeSet
520
+ : degreeSet.map((isIn, degree) => isIn && (currentDegreeSet[degree] ?? false));
521
+ if (isTrivialDegreeSet(degreeSet)) {
522
+ pushFactor(z, fs, fPp, k);
523
+ return true;
524
+ }
525
+ trials++;
526
+ if (zpFs.factors.length === 0 || getTotalFactors(zpFs) > getTotalFactors(currentFs)) {
527
+ zpFs = currentFs;
528
+ zpFsPrime = prime;
529
+ }
530
+ }
531
+ zp.setZp(zpFsPrime);
532
+ const zpe = new UpolynomialManager(zpFsPrime);
533
+ const zpeFs = henselLiftFactors(z, fPp, zp, zpFs, getMignotteBound(fPp, zpFsPrime), zpe);
534
+ let leading = zpe.normalizeNumeral(fPp[fPp.length - 1]);
535
+ fPp = z.mulConst(fPp, leading);
536
+ const iterator = new CombinationIterator(zpe, zpeFs, degreeSet);
537
+ const halfDegree = Math.floor(getTotalDegree(zpFs) / 2);
538
+ let result = true;
539
+ let isRemoving = false;
540
+ for (let counter = 1; iterator.next(isRemoving); counter++) {
541
+ if (counter > params.maxSearchSize) {
542
+ result = false;
543
+ break;
544
+ }
545
+ const isUsingLeft = iterator.getCurrentDegree() <= halfDegree;
546
+ const tail = isUsingLeft
547
+ ? iterator.getLeftTailCoeff(leading)
548
+ : iterator.getRightTailCoeff(leading);
549
+ if (!divides(tail, fPp[0])) {
550
+ isRemoving = false;
551
+ continue;
552
+ }
553
+ const trial = zpe.mulConst(isUsingLeft ? iterator.getLeft() : iterator.getRight(), leading);
554
+ const quotient = z.exactDiv(fPp, trial);
555
+ if (quotient === null) {
556
+ isRemoving = false;
557
+ continue;
558
+ }
559
+ // The factor is the side of degree at most half, which the bound makes recoverable. The
560
+ // search continues with the other side.
561
+ pushFactor(z, fs, z.getPrimitive(isUsingLeft ? trial : quotient), k);
562
+ fPp = z.getPrimitive(isUsingLeft ? quotient : trial);
563
+ leading = fPp[fPp.length - 1];
564
+ fPp = z.mulConst(fPp, leading);
565
+ isRemoving = true;
566
+ }
567
+ if (fPp.length > 1) pushFactor(z, fs, z.divConst(fPp, leading), k);
568
+ return result;
569
+ };
570
+
571
+ // factor_2_sqf_pp: a square-free primitive quadratic splits when its discriminant is a square.
572
+ const factorQuadratic = (
573
+ z: UpolynomialManager,
574
+ p: Upolynomial,
575
+ fs: UpolynomialFactors,
576
+ k: number,
577
+ ) => {
578
+ const root = getExactSquareRoot(p[1] * p[1] - 4n * p[2] * p[0]);
579
+ if (root === null) {
580
+ pushFactor(z, fs, p, k);
581
+ return;
582
+ }
583
+ pushFactor(z, fs, z.normalize([p[1] - root, 2n * p[2]]), k);
584
+ pushFactor(z, fs, z.normalize([p[1] + root, 2n * p[2]]), k);
585
+ };
586
+
587
+ // factor_sqf_pp
588
+ const factorSqfPp = (
589
+ z: UpolynomialManager,
590
+ p: Upolynomial,
591
+ fs: UpolynomialFactors,
592
+ k: number,
593
+ params: FactorParams,
594
+ ) => {
595
+ if (p.length <= 2) {
596
+ pushFactor(z, fs, p, k);
597
+ return true;
598
+ }
599
+ if (p.length === 3) {
600
+ factorQuadratic(z, p, fs, k);
601
+ return true;
602
+ }
603
+ return factorSquareFree(z, p, fs, k, params);
604
+ };
605
+
606
+ // flip_factor_sign_if_lm_neg
607
+ const flipFactorSignIfLmNeg = (p: Upolynomial, fs: UpolynomialFactors, k: number) => {
608
+ if (p.length === 0 || p[p.length - 1] >= 0n) return p;
609
+ if (k % 2 === 1) fs.constant = -fs.constant;
610
+ return p.map((coeff) => -coeff);
611
+ };
612
+
613
+ // manager::factor: the content and the irreducible factors of p with their multiplicities, by
614
+ // Yun's square-free decomposition. Returns false when a limit in params left a factor that may be
615
+ // reducible.
616
+ export const factorUpolynomial = (
617
+ z: UpolynomialManager,
618
+ p: Upolynomial,
619
+ params: FactorParams,
620
+ ): { isComplete: boolean; factors: UpolynomialFactors } => {
621
+ const fs = mkFactors();
622
+ if (p.length <= 1) {
623
+ fs.constant = p.length === 0 ? 0n : p[0];
624
+ return { isComplete: true, factors: fs };
625
+ }
626
+ fs.constant = z.getContent(p);
627
+ const primitive = z.getPrimitive(p);
628
+ let square = z.gcd(primitive, z.derivative(primitive));
629
+ if (square.length <= 1) {
630
+ const isComplete = factorSqfPp(z, flipFactorSignIfLmNeg(primitive, fs, 1), fs, 1, params);
631
+ return { isComplete, factors: fs };
632
+ }
633
+ let isComplete = true;
634
+ let product = z.exactDiv(primitive, square) as bigint[];
635
+ for (let multiplicity = 1; product.length > 1; multiplicity++) {
636
+ const next = z.gcd(product, square);
637
+ const factor = z.exactDiv(product, next) as bigint[];
638
+ if (factor.length > 1) {
639
+ if (
640
+ !factorSqfPp(z, flipFactorSignIfLmNeg(factor, fs, multiplicity), fs, multiplicity, params)
641
+ )
642
+ isComplete = false;
643
+ } else if (factor[0] === -1n && multiplicity % 2 === 1) fs.constant = -fs.constant;
644
+ square = z.exactDiv(square, next) as bigint[];
645
+ product = next;
646
+ }
647
+ return { isComplete, factors: fs };
648
+ };