tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.8be00045c

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 (509) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +4 -1
  5. package/dist/index.d.ts +4 -1
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +146 -58
  10. package/dist/prove.js +143 -55
  11. package/dist/run.cjs +43 -43
  12. package/dist/run.js +45 -45
  13. package/dist/transfer.cjs +29 -26
  14. package/dist/transfer.js +43 -40
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/bags.ts +46 -28
  20. package/src/check-trace.ts +2 -16
  21. package/src/check.ts +336 -88
  22. package/src/cli/runtime-invariants.ts +20 -56
  23. package/src/cli/tlapm.ts +261 -68
  24. package/src/cli/tlc-arguments.ts +2 -2
  25. package/src/cli/tlc-output.ts +4 -5
  26. package/src/cli/tlc-usage.ts +0 -1
  27. package/src/cli/tlc.ts +26 -7
  28. package/src/dependencies.ts +23 -2
  29. package/src/dfid.ts +9 -2
  30. package/src/environment.ts +27 -5
  31. package/src/errors.ts +1 -1
  32. package/src/evaluate.ts +9 -3
  33. package/src/exit-codes.ts +5 -2
  34. package/src/instances.ts +1 -1
  35. package/src/levels.ts +134 -86
  36. package/src/liveness-checker.ts +572 -204
  37. package/src/liveness.ts +47 -32
  38. package/src/obligations/action.ts +0 -2
  39. package/src/obligations/anonymize.ts +2 -6
  40. package/src/obligations/equality.ts +0 -2
  41. package/src/obligations/expression.ts +0 -2
  42. package/src/obligations/format.ts +0 -2
  43. package/src/obligations/generate.ts +0 -2
  44. package/src/obligations/index.ts +5 -3
  45. package/src/obligations/levels.ts +0 -2
  46. package/src/obligations/module.ts +0 -2
  47. package/src/obligations/normalize.ts +0 -2
  48. package/src/obligations/operators.ts +0 -2
  49. package/src/obligations/pragma.ts +2 -2
  50. package/src/obligations/printer.ts +0 -2
  51. package/src/obligations/proof.ts +0 -2
  52. package/src/obligations/regroup.ts +0 -2
  53. package/src/obligations/simplify.ts +0 -2
  54. package/src/obligations/subexpression.ts +0 -2
  55. package/src/obligations/substitution.ts +0 -2
  56. package/src/obligations/temporal.ts +0 -2
  57. package/src/obligations/tuples.ts +0 -2
  58. package/src/parallel-worker.ts +8 -2
  59. package/src/parallel.ts +7 -2
  60. package/src/parser.ts +224 -82
  61. package/src/pretty-print.ts +1 -1
  62. package/src/prover/deciders.ts +1 -8
  63. package/src/prover/isabelle/encode.ts +0 -2
  64. package/src/prover/isabelle/isar/attrib.ts +86 -49
  65. package/src/prover/isabelle/isar/context.ts +25 -26
  66. package/src/prover/isabelle/isar/induct.ts +2 -9
  67. package/src/prover/isabelle/isar/method.ts +5 -9
  68. package/src/prover/isabelle/isar/proof.ts +33 -18
  69. package/src/prover/isabelle/isar/rule-cases.ts +14 -22
  70. package/src/prover/isabelle/isar/theory.ts +16 -17
  71. package/src/prover/isabelle/isar/toplevel.ts +46 -56
  72. package/src/prover/isabelle/isar/type-check.ts +0 -2
  73. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  74. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  75. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  76. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  77. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  78. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  79. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  80. package/src/prover/isabelle/provers/classical.ts +1 -3
  81. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  82. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  83. package/src/prover/isabelle/pure/consts.ts +0 -2
  84. package/src/prover/isabelle/pure/conv.ts +0 -2
  85. package/src/prover/isabelle/pure/drule.ts +0 -2
  86. package/src/prover/isabelle/pure/envir.ts +0 -2
  87. package/src/prover/isabelle/pure/goal.ts +0 -2
  88. package/src/prover/isabelle/pure/logic.ts +0 -2
  89. package/src/prover/isabelle/pure/name.ts +0 -2
  90. package/src/prover/isabelle/pure/net.ts +0 -2
  91. package/src/prover/isabelle/pure/object-logic.ts +0 -2
  92. package/src/prover/isabelle/pure/pattern.ts +0 -2
  93. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  94. package/src/prover/isabelle/pure/rewriter.ts +0 -2
  95. package/src/prover/isabelle/pure/search.ts +0 -2
  96. package/src/prover/isabelle/pure/seq.ts +0 -2
  97. package/src/prover/isabelle/pure/simplifier.ts +0 -2
  98. package/src/prover/isabelle/pure/table.ts +0 -2
  99. package/src/prover/isabelle/pure/tactic.ts +0 -2
  100. package/src/prover/isabelle/pure/tactical.ts +0 -2
  101. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  102. package/src/prover/isabelle/pure/term.ts +0 -2
  103. package/src/prover/isabelle/pure/thm.ts +0 -2
  104. package/src/prover/isabelle/pure/type.ts +0 -2
  105. package/src/prover/isabelle/pure/unify.ts +0 -2
  106. package/src/prover/isabelle/pure/variable.ts +0 -2
  107. package/src/prover/isabelle/tla/classical-setup.ts +0 -2
  108. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  109. package/src/prover/isabelle/tools/intuitionistic.ts +0 -2
  110. package/src/prover/ocaml.ts +4 -1
  111. package/src/prover/prep/action.ts +1 -0
  112. package/src/prover/prep/methods.ts +50 -3
  113. package/src/prover/prep/normalize.ts +4 -1
  114. package/src/prover/prove.ts +58 -32
  115. package/src/prover/ptl/decide.ts +43 -63
  116. package/src/prover/smt/data.ts +51 -45
  117. package/src/prover/smt/encode.ts +1 -2
  118. package/src/prover/smt/rewrite.ts +3 -7
  119. package/src/prover/smt/simplify.ts +1 -1
  120. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +0 -2
  121. package/src/prover/smt/solver/ackr-helper.ts +0 -3
  122. package/src/prover/smt/solver/ackr-model-converter.ts +0 -1
  123. package/src/prover/smt/solver/act-cache.ts +0 -1
  124. package/src/prover/smt/solver/add-bounds-tactic.ts +0 -1
  125. package/src/prover/smt/solver/aig-tactic.ts +25 -16
  126. package/src/prover/smt/solver/aig.ts +2 -3
  127. package/src/prover/smt/solver/arith-rewriter.ts +3 -6
  128. package/src/prover/smt/solver/arith-terms.ts +0 -2
  129. package/src/prover/smt/solver/array-decl-plugin.ts +0 -1
  130. package/src/prover/smt/solver/array-rewriter.ts +0 -1
  131. package/src/prover/smt/solver/asserted-formulas.ts +9 -3
  132. package/src/prover/smt/solver/ast-lt.ts +1 -2
  133. package/src/prover/smt/solver/ast-util.ts +3 -3
  134. package/src/prover/smt/solver/ast.ts +112 -156
  135. package/src/prover/smt/solver/auf-solver.ts +0 -1
  136. package/src/prover/smt/solver/bit-blast-tactic.ts +0 -3
  137. package/src/prover/smt/solver/bit-blaster.ts +0 -3
  138. package/src/prover/smt/solver/bound-manager.ts +39 -29
  139. package/src/prover/smt/solver/bound-simplifier.ts +0 -2
  140. package/src/prover/smt/solver/bv-bound-chk.ts +2 -10
  141. package/src/prover/smt/solver/bv-decl-plugin.ts +0 -1
  142. package/src/prover/smt/solver/bv-divrem-bounds.ts +0 -2
  143. package/src/prover/smt/solver/bv-rewriter.ts +15 -19
  144. package/src/prover/smt/solver/bv1-blast.ts +1 -11
  145. package/src/prover/smt/solver/bv2fpa-converter.ts +0 -1
  146. package/src/prover/smt/solver/bv2int-rewriter.ts +0 -1
  147. package/src/prover/smt/solver/bv2real-rewriter.ts +0 -1
  148. package/src/prover/smt/solver/card2bv.ts +1 -4
  149. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  150. package/src/prover/smt/solver/cg-table.ts +19 -16
  151. package/src/prover/smt/solver/check-logic.ts +6 -2
  152. package/src/prover/smt/solver/clause.ts +0 -1
  153. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +0 -2
  154. package/src/prover/smt/solver/conflict-resolution.ts +0 -1
  155. package/src/prover/smt/solver/context.ts +41 -14
  156. package/src/prover/smt/solver/ctx-simplify.ts +1 -3
  157. package/src/prover/smt/solver/ctx-solver-simplify.ts +0 -2
  158. package/src/prover/smt/solver/datatype-decl-plugin.ts +0 -1
  159. package/src/prover/smt/solver/datatype-rewriter.ts +0 -1
  160. package/src/prover/smt/solver/demodulator.ts +2 -5
  161. package/src/prover/smt/solver/dependent-expr-state.ts +16 -3
  162. package/src/prover/smt/solver/der.ts +0 -1
  163. package/src/prover/smt/solver/diff-neq.ts +1 -3
  164. package/src/prover/smt/solver/distribute-forall.ts +1 -11
  165. package/src/prover/smt/solver/dom-simplify.ts +1 -3
  166. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -9
  167. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  168. package/src/prover/smt/solver/e-matching.ts +6 -7
  169. package/src/prover/smt/solver/elim-small-bv-tactic.ts +0 -1
  170. package/src/prover/smt/solver/elim-uncnstr.ts +7 -23
  171. package/src/prover/smt/solver/enode.ts +15 -2
  172. package/src/prover/smt/solver/eq2bv-tactic.ts +0 -1
  173. package/src/prover/smt/solver/euf/arith-axioms.ts +0 -1
  174. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -3
  175. package/src/prover/smt/solver/euf/arith-solver.ts +0 -1
  176. package/src/prover/smt/solver/euf/array-axioms.ts +0 -1
  177. package/src/prover/smt/solver/euf/array-internalize.ts +20 -11
  178. package/src/prover/smt/solver/euf/array-solver.ts +0 -2
  179. package/src/prover/smt/solver/euf/bv-ackerman.ts +0 -2
  180. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -3
  181. package/src/prover/smt/solver/euf/bv-solver.ts +0 -2
  182. package/src/prover/smt/solver/euf/dt-solver.ts +19 -21
  183. package/src/prover/smt/solver/euf/egraph.ts +68 -43
  184. package/src/prover/smt/solver/euf/euf-solver.ts +36 -23
  185. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -53
  186. package/src/prover/smt/solver/euf/mam.ts +7 -55
  187. package/src/prover/smt/solver/euf/q-ematch.ts +21 -97
  188. package/src/prover/smt/solver/euf/q-mbi.ts +4 -4
  189. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -4
  190. package/src/prover/smt/solver/euf/q-solver.ts +2 -2
  191. package/src/prover/smt/solver/euf/th-solver.ts +1 -10
  192. package/src/prover/smt/solver/euf/th-solvers.ts +0 -1
  193. package/src/prover/smt/solver/expr-ref.ts +0 -1
  194. package/src/prover/smt/solver/expr-safe-replace.ts +0 -1
  195. package/src/prover/smt/solver/expr2polynomial.ts +204 -80
  196. package/src/prover/smt/solver/factor.ts +37 -26
  197. package/src/prover/smt/solver/fd-solver.ts +3 -5
  198. package/src/prover/smt/solver/fingerprints.ts +0 -1
  199. package/src/prover/smt/solver/fix-dl-var.ts +1 -3
  200. package/src/prover/smt/solver/flat-literals.ts +0 -1
  201. package/src/prover/smt/solver/fm-tactic.ts +19 -14
  202. package/src/prover/smt/solver/fpa-decl-plugin.ts +0 -1
  203. package/src/prover/smt/solver/fpa-rewriter.ts +2 -2
  204. package/src/prover/smt/solver/fpa2bv-converter.ts +13 -8
  205. package/src/prover/smt/solver/fpa2bv-rewriter.ts +0 -1
  206. package/src/prover/smt/solver/fpa2bv-tactic.ts +0 -2
  207. package/src/prover/smt/solver/goal.ts +3 -2
  208. package/src/prover/smt/solver/goal2nlsat.ts +57 -32
  209. package/src/prover/smt/solver/guard-set.ts +0 -1
  210. package/src/prover/smt/solver/hash.ts +0 -1
  211. package/src/prover/smt/solver/hashtable.ts +0 -1
  212. package/src/prover/smt/solver/inf-eps.ts +1 -2
  213. package/src/prover/smt/solver/inj-axiom.ts +0 -1
  214. package/src/prover/smt/solver/internalizer.ts +41 -3
  215. package/src/prover/smt/solver/lackr.ts +0 -2
  216. package/src/prover/smt/solver/lbool.ts +0 -1
  217. package/src/prover/smt/solver/lia2card.ts +0 -1
  218. package/src/prover/smt/solver/lia2pb.ts +18 -5
  219. package/src/prover/smt/solver/literal.ts +0 -1
  220. package/src/prover/smt/solver/logic-tactics.ts +0 -4
  221. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  222. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  223. package/src/prover/smt/solver/lp/containers.ts +7 -2
  224. package/src/prover/smt/solver/lp/core-solver.ts +0 -3
  225. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  226. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  227. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  228. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  229. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  230. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  231. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  232. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  233. package/src/prover/smt/solver/lp/int-cube.ts +0 -1
  234. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  235. package/src/prover/smt/solver/lp/lar-solver.ts +1 -2
  236. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  237. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  238. package/src/prover/smt/solver/lp/maximize-term.ts +0 -3
  239. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  240. package/src/prover/smt/solver/lp/nex.ts +2 -2
  241. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  242. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  243. package/src/prover/smt/solver/lp/nla-core.ts +26 -7
  244. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  245. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  246. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  247. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -82
  248. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  249. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  250. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  251. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  252. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  253. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  254. package/src/prover/smt/solver/lp/nla-powers.ts +144 -108
  255. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  256. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  257. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -19
  258. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  259. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  260. package/src/prover/smt/solver/lp/nra-solver.ts +138 -97
  261. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  262. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  263. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  264. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  265. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  266. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  267. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  268. package/src/prover/smt/solver/lp/union-find.ts +1 -2
  269. package/src/prover/smt/solver/macro-finder.ts +1 -4
  270. package/src/prover/smt/solver/mam-compiler.ts +14 -15
  271. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  272. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -13
  273. package/src/prover/smt/solver/max-cliques.ts +0 -2
  274. package/src/prover/smt/solver/maxcore.ts +5 -14
  275. package/src/prover/smt/solver/maximize-ac-sharing.ts +0 -1
  276. package/src/prover/smt/solver/maxlex.ts +0 -8
  277. package/src/prover/smt/solver/maxsmt-base.ts +7 -1
  278. package/src/prover/smt/solver/maxsmt.ts +0 -1
  279. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -12
  280. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +0 -1
  281. package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -2
  282. package/src/prover/smt/solver/mbp/mbp-qel.ts +0 -1
  283. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -10
  284. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +0 -1
  285. package/src/prover/smt/solver/model-based-opt.ts +1 -2
  286. package/src/prover/smt/solver/model-checker.ts +0 -1
  287. package/src/prover/smt/solver/model-evaluator.ts +9 -6
  288. package/src/prover/smt/solver/model-finder.ts +0 -1
  289. package/src/prover/smt/solver/model-generator.ts +3 -2
  290. package/src/prover/smt/solver/model-macro-solver.ts +3 -4
  291. package/src/prover/smt/solver/model-printer.ts +0 -1
  292. package/src/prover/smt/solver/mpf.ts +2 -5
  293. package/src/prover/smt/solver/mus.ts +1 -3
  294. package/src/prover/smt/solver/muz/dl-context.ts +67 -9
  295. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +0 -1
  296. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -22
  297. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -3
  298. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +0 -2
  299. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -11
  300. package/src/prover/smt/solver/muz/dl-mk-slice.ts +78 -16
  301. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -4
  302. package/src/prover/smt/solver/muz/dl-rule-set.ts +0 -1
  303. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -4
  304. package/src/prover/smt/solver/muz/dl-rule.ts +95 -33
  305. package/src/prover/smt/solver/muz/hnf.ts +6 -6
  306. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  307. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -6
  308. package/src/prover/smt/solver/muz/rule-properties.ts +194 -37
  309. package/src/prover/smt/solver/muz/spacer-context.ts +104 -89
  310. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -3
  311. package/src/prover/smt/solver/muz/spacer-generalizers.ts +0 -3
  312. package/src/prover/smt/solver/muz/spacer-manager.ts +0 -2
  313. package/src/prover/smt/solver/muz/spacer-pdr.ts +4 -4
  314. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +3 -9
  315. package/src/prover/smt/solver/muz/spacer-util.ts +2 -3
  316. package/src/prover/smt/solver/muz/substitution.ts +88 -39
  317. package/src/prover/smt/solver/nla2bv-tactic.ts +0 -1
  318. package/src/prover/smt/solver/nlqsat.ts +4 -4
  319. package/src/prover/smt/solver/nlsat/algebraic.ts +194 -93
  320. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  321. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  322. package/src/prover/smt/solver/nlsat/explain.ts +379 -217
  323. package/src/prover/smt/solver/nlsat/interval-set.ts +0 -1
  324. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  325. package/src/prover/smt/solver/nlsat/mpbq.ts +0 -1
  326. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  327. package/src/prover/smt/solver/nlsat/solver.ts +112 -99
  328. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +2 -3
  329. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -19
  330. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  331. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  332. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  333. package/src/prover/smt/solver/nlsat-tactic.ts +0 -1
  334. package/src/prover/smt/solver/nnf.ts +0 -1
  335. package/src/prover/smt/solver/normalize-bounds.ts +0 -1
  336. package/src/prover/smt/solver/occf.ts +0 -1
  337. package/src/prover/smt/solver/opt-context.ts +15 -10
  338. package/src/prover/smt/solver/opt-nlsat.ts +97 -77
  339. package/src/prover/smt/solver/opt-pareto.ts +0 -2
  340. package/src/prover/smt/solver/opt-preprocess.ts +0 -1
  341. package/src/prover/smt/solver/opt-solver.ts +22 -11
  342. package/src/prover/smt/solver/opt-value.ts +0 -1
  343. package/src/prover/smt/solver/optsmt.ts +13 -12
  344. package/src/prover/smt/solver/parallel-tactic.ts +0 -2
  345. package/src/prover/smt/solver/pattern-inference.ts +2 -3
  346. package/src/prover/smt/solver/pb-rewriter.ts +14 -20
  347. package/src/prover/smt/solver/pb2bv-tactic.ts +0 -2
  348. package/src/prover/smt/solver/poly-rewriter.ts +2 -3
  349. package/src/prover/smt/solver/probes.ts +4 -7
  350. package/src/prover/smt/solver/propagate-values.ts +4 -1
  351. package/src/prover/smt/solver/proto-model.ts +6 -7
  352. package/src/prover/smt/solver/pull-quant.ts +0 -1
  353. package/src/prover/smt/solver/purify-arith.ts +50 -16
  354. package/src/prover/smt/solver/qe-arith-plugin.ts +4 -7
  355. package/src/prover/smt/solver/qe-lite-der.ts +0 -1
  356. package/src/prover/smt/solver/qe-lite-fm.ts +0 -1
  357. package/src/prover/smt/solver/qe-lite.ts +0 -1
  358. package/src/prover/smt/solver/qe-mbp.ts +13 -24
  359. package/src/prover/smt/solver/qe.ts +48 -57
  360. package/src/prover/smt/solver/qel.ts +0 -1
  361. package/src/prover/smt/solver/qi-queue.ts +0 -1
  362. package/src/prover/smt/solver/qsat.ts +70 -91
  363. package/src/prover/smt/solver/quant-hoist.ts +0 -1
  364. package/src/prover/smt/solver/quant-tactics.ts +0 -1
  365. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  366. package/src/prover/smt/solver/quantifier-manager.ts +14 -10
  367. package/src/prover/smt/solver/quasi-macros.ts +9 -20
  368. package/src/prover/smt/solver/random-gen.ts +0 -1
  369. package/src/prover/smt/solver/rational.ts +17 -1
  370. package/src/prover/smt/solver/recfun-decl-plugin.ts +35 -21
  371. package/src/prover/smt/solver/recfun-rewriter.ts +1 -2
  372. package/src/prover/smt/solver/reduce-args.ts +0 -1
  373. package/src/prover/smt/solver/reduce-bv-size.ts +0 -1
  374. package/src/prover/smt/solver/ref-vector.ts +0 -1
  375. package/src/prover/smt/solver/relevancy.ts +0 -1
  376. package/src/prover/smt/solver/rewriter-tpl.ts +6 -3
  377. package/src/prover/smt/solver/rewriter.ts +1 -2
  378. package/src/prover/smt/solver/rlimit.ts +13 -1
  379. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -48
  380. package/src/prover/smt/solver/sat/big.ts +0 -1
  381. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -8
  382. package/src/prover/smt/solver/sat/clause.ts +1 -6
  383. package/src/prover/smt/solver/sat/cleaner.ts +0 -2
  384. package/src/prover/smt/solver/sat/config.ts +4 -7
  385. package/src/prover/smt/solver/sat/consequences.ts +1 -2
  386. package/src/prover/smt/solver/sat/elim-eqs.ts +0 -2
  387. package/src/prover/smt/solver/sat/goal2sat.ts +1 -3
  388. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -13
  389. package/src/prover/smt/solver/sat/model-converter.ts +2 -18
  390. package/src/prover/smt/solver/sat/pb-constraint.ts +0 -3
  391. package/src/prover/smt/solver/sat/pb-solver.ts +50 -26
  392. package/src/prover/smt/solver/sat/probing.ts +22 -21
  393. package/src/prover/smt/solver/sat/sat-tactic.ts +2 -2
  394. package/src/prover/smt/solver/sat/sat2goal.ts +9 -12
  395. package/src/prover/smt/solver/sat/scc.ts +0 -1
  396. package/src/prover/smt/solver/sat/simplifier.ts +16 -60
  397. package/src/prover/smt/solver/sat/solver.ts +45 -68
  398. package/src/prover/smt/solver/sat/var-queue.ts +0 -2
  399. package/src/prover/smt/solver/sat/watch-list.ts +7 -3
  400. package/src/prover/smt/solver/search-tree.ts +0 -1
  401. package/src/prover/smt/solver/seq-axioms.ts +20 -36
  402. package/src/prover/smt/solver/seq-decl-plugin.ts +7 -8
  403. package/src/prover/smt/solver/seq-derive.ts +9 -15
  404. package/src/prover/smt/solver/seq-eq-approx.ts +0 -2
  405. package/src/prover/smt/solver/seq-eq-solver.ts +9 -10
  406. package/src/prover/smt/solver/seq-factory.ts +0 -1
  407. package/src/prover/smt/solver/seq-monadic.ts +7 -7
  408. package/src/prover/smt/solver/seq-range-predicate.ts +14 -3
  409. package/src/prover/smt/solver/seq-re-rewriter.ts +3 -12
  410. package/src/prover/smt/solver/seq-re-util.ts +2 -5
  411. package/src/prover/smt/solver/seq-regex-bisim.ts +2 -3
  412. package/src/prover/smt/solver/seq-regex-live.ts +6 -8
  413. package/src/prover/smt/solver/seq-rewriter.ts +31 -34
  414. package/src/prover/smt/solver/seq-skolem.ts +0 -24
  415. package/src/prover/smt/solver/seq-subset.ts +0 -1
  416. package/src/prover/smt/solver/seq-view-witness.ts +4 -6
  417. package/src/prover/smt/solver/smt-consequences.ts +0 -2
  418. package/src/prover/smt/solver/smt-kernel.ts +8 -3
  419. package/src/prover/smt/solver/smt-logics.ts +0 -1
  420. package/src/prover/smt/solver/smt-setup.ts +18 -14
  421. package/src/prover/smt/solver/smt2-printer.ts +0 -2
  422. package/src/prover/smt/solver/smtlib-parser.ts +1187 -592
  423. package/src/prover/smt/solver/smtlib-script.ts +957 -750
  424. package/src/prover/smt/solver/solve-eqs.ts +11 -19
  425. package/src/prover/smt/solver/solver.ts +1 -2
  426. package/src/prover/smt/solver/static-features.ts +0 -2
  427. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  428. package/src/prover/smt/solver/tactic.ts +77 -18
  429. package/src/prover/smt/solver/term-enumeration.ts +0 -1
  430. package/src/prover/smt/solver/theory-array.ts +25 -60
  431. package/src/prover/smt/solver/theory-bv.ts +15 -54
  432. package/src/prover/smt/solver/theory-char.ts +0 -1
  433. package/src/prover/smt/solver/theory-datatype.ts +0 -1
  434. package/src/prover/smt/solver/theory-finite-set.ts +2 -2
  435. package/src/prover/smt/solver/theory-fpa.ts +46 -79
  436. package/src/prover/smt/solver/theory-lra-axioms.ts +0 -1
  437. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -1
  438. package/src/prover/smt/solver/theory-lra-final-check.ts +0 -2
  439. package/src/prover/smt/solver/theory-lra-internalize.ts +8 -1
  440. package/src/prover/smt/solver/theory-lra-model.ts +0 -1
  441. package/src/prover/smt/solver/theory-lra-propagate.ts +0 -3
  442. package/src/prover/smt/solver/theory-lra-state.ts +0 -1
  443. package/src/prover/smt/solver/theory-lra.ts +0 -2
  444. package/src/prover/smt/solver/theory-pb.ts +12 -11
  445. package/src/prover/smt/solver/theory-polymorphism.ts +3 -4
  446. package/src/prover/smt/solver/theory-recfun.ts +2 -3
  447. package/src/prover/smt/solver/theory-seq-regex.ts +3 -7
  448. package/src/prover/smt/solver/theory-seq-solve.ts +6 -8
  449. package/src/prover/smt/solver/theory-seq-state.ts +8 -26
  450. package/src/prover/smt/solver/theory-seq.ts +32 -55
  451. package/src/prover/smt/solver/theory.ts +16 -2
  452. package/src/prover/smt/solver/tseitin-cnf.ts +3 -5
  453. package/src/prover/smt/solver/var-subst.ts +2 -3
  454. package/src/prover/smt/table.ts +3 -2
  455. package/src/prover/zenon/decide.ts +9 -13
  456. package/src/prover/zenon/encode.ts +0 -2
  457. package/src/prover/zenon/eqrel.ts +0 -2
  458. package/src/prover/zenon/equality-rules.ts +24 -2
  459. package/src/prover/zenon/expr.ts +21 -2
  460. package/src/prover/zenon/index-table.ts +7 -4
  461. package/src/prover/zenon/isar-case.ts +1 -3
  462. package/src/prover/zenon/isar.ts +2 -4
  463. package/src/prover/zenon/llproof.ts +0 -2
  464. package/src/prover/zenon/mltoll.ts +0 -2
  465. package/src/prover/zenon/node.ts +12 -13
  466. package/src/prover/zenon/parse.ts +0 -2
  467. package/src/prover/zenon/phrase.ts +1 -3
  468. package/src/prover/zenon/proof.ts +0 -2
  469. package/src/prover/zenon/propositional-rules.ts +0 -2
  470. package/src/prover/zenon/rules.ts +2 -3
  471. package/src/prover/zenon/search.ts +0 -2
  472. package/src/prover/zenon/tla/functions.ts +0 -2
  473. package/src/prover/zenon/tla/llproof.ts +0 -2
  474. package/src/prover/zenon/tla/records.ts +0 -2
  475. package/src/prover/zenon/tla/rewrites.ts +0 -2
  476. package/src/prover/zenon/tla/sets.ts +1 -3
  477. package/src/prover/zenon/tla/terms.ts +0 -2
  478. package/src/prover/zenon/tla/tla.ts +0 -2
  479. package/src/resolve.ts +264 -77
  480. package/src/runtime.ts +6 -0
  481. package/src/sany/generation.ts +1 -13
  482. package/src/sany/generator-definitions.ts +2 -1
  483. package/src/sany/generator-expressions.ts +30 -27
  484. package/src/sany/generator-proofs.ts +1 -1
  485. package/src/sany/generator.ts +2 -1
  486. package/src/sany/levels.ts +0 -2
  487. package/src/sany/linter.ts +0 -2
  488. package/src/sany/nodes.ts +1 -1
  489. package/src/sany/selectors.ts +6 -5
  490. package/src/search.ts +198 -45
  491. package/src/simulate.ts +3 -0
  492. package/src/standard-definitions.ts +4 -0
  493. package/src/state-graph.ts +0 -2
  494. package/src/subexpressions.ts +165 -78
  495. package/src/successors.ts +1 -1
  496. package/src/symmetry.ts +2 -2
  497. package/src/tableau.ts +2 -2
  498. package/src/tlc/fingerprint.ts +81 -9
  499. package/src/tlc/jar-data.ts +12 -0
  500. package/src/tlc/order.ts +14 -3
  501. package/src/tlc/summary.ts +29 -14
  502. package/src/tlc/tlcext-operators.ts +61 -16
  503. package/src/tlc/trace-spec.ts +2 -3
  504. package/src/typed-tier.ts +6541 -0
  505. package/src/typescript/types.ts +2 -2
  506. package/src/values.ts +1 -1
  507. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
  508. package/src/prover/smt/solver/z3-license.txt +0 -10
  509. package/src/prover/zenon/LICENSE +0 -32
@@ -1,8 +1,8 @@
1
- // Ported from Z3 (src/math/polynomial/polynomial.{h,cpp}, src/math/polynomial/polynomial_cache.cpp),
2
- // MIT license, see z3-license.txt.
3
1
  import { SmtInvariantError } from "../../../../errors";
2
+ import { RandomGen } from "../random-gen";
4
3
  import { getGcd, Rational } from "../rational";
5
- import { floorDiv, UpolynomialManager } from "./upolynomial";
4
+ import type { ResourceLimit } from "../rlimit";
5
+ import { BIG_PRIMES, getExtendedGcd, UpolynomialManager } from "./upolynomial";
6
6
  import {
7
7
  DEFAULT_FACTOR_PARAMS,
8
8
  factorSquareFree,
@@ -32,6 +32,24 @@ const RATIONAL_OPS: ValueOps<Rational> = {
32
32
  const getMonomialKey = (vars: readonly number[], degrees: readonly number[]) =>
33
33
  vars.map((variable, index) => `${variable}^${degrees[index]}`).join(",");
34
34
 
35
+ const normalizeZp = (value: bigint, modulus: bigint) => {
36
+ const upper = modulus / 2n;
37
+ const lower = modulus % 2n === 0n ? -upper + 1n : -upper;
38
+ const rest = value % modulus;
39
+ return rest > upper ? rest - modulus : rest < lower ? rest + modulus : rest;
40
+ };
41
+
42
+ const divMpz = (dividend: bigint, divisor: bigint) => {
43
+ const quotient = dividend / divisor;
44
+ if (dividend >= 0n || dividend % divisor === 0n) return quotient;
45
+ return divisor < 0n ? quotient + 1n : quotient - 1n;
46
+ };
47
+
48
+ const modMpz = (value: bigint, modulus: bigint) => {
49
+ const rest = value % modulus;
50
+ return rest < 0n ? rest + (modulus < 0n ? -modulus : modulus) : rest;
51
+ };
52
+
35
53
  class Monomial {
36
54
  readonly totalDegree: number;
37
55
 
@@ -67,6 +85,11 @@ class Monomial {
67
85
  for (const current of this.vars) if (current < variable) result = current;
68
86
  return result;
69
87
  }
88
+
89
+ isSquare() {
90
+ for (const degree of this.degrees) if (degree % 2 === 1) return false;
91
+ return true;
92
+ }
70
93
  }
71
94
 
72
95
  const lexCompare = (first: Monomial, second: Monomial) => {
@@ -91,6 +114,45 @@ const lexCompare = (first: Monomial, second: Monomial) => {
91
114
  return firstIndex < 0 ? -1 : 1;
92
115
  };
93
116
 
117
+ const lexCompare2 = (first: Monomial, second: Monomial, minVar: number) => {
118
+ if (first === second) return 0;
119
+ let firstIndex = first.size - 1;
120
+ let secondIndex = second.size - 1;
121
+ let firstMinVarDegree = 0;
122
+ let secondMinVarDegree = 0;
123
+ while (firstIndex >= 0 && secondIndex >= 0) {
124
+ const firstVar = first.vars[firstIndex];
125
+ const secondVar = second.vars[secondIndex];
126
+ if (firstVar === minVar) {
127
+ firstMinVarDegree = first.degrees[firstIndex];
128
+ firstIndex--;
129
+ if (secondVar === minVar) {
130
+ secondMinVarDegree = second.degrees[secondIndex];
131
+ secondIndex--;
132
+ }
133
+ continue;
134
+ }
135
+ if (secondVar === minVar) {
136
+ secondMinVarDegree = second.degrees[secondIndex];
137
+ secondIndex--;
138
+ continue;
139
+ }
140
+ if (firstVar === secondVar) {
141
+ const firstDegree = first.degrees[firstIndex];
142
+ const secondDegree = second.degrees[secondIndex];
143
+ if (firstDegree === secondDegree) {
144
+ firstIndex--;
145
+ secondIndex--;
146
+ continue;
147
+ }
148
+ return firstDegree < secondDegree ? -1 : 1;
149
+ }
150
+ return firstVar > secondVar ? 1 : -1;
151
+ }
152
+ if (firstIndex === secondIndex) return firstMinVarDegree < secondMinVarDegree ? -1 : 1;
153
+ return firstIndex < 0 ? -1 : 1;
154
+ };
155
+
94
156
  const gradedLexCompare = (first: Monomial, second: Monomial) =>
95
157
  first.totalDegree === second.totalDegree
96
158
  ? lexCompare(first, second)
@@ -107,6 +169,7 @@ const isPoGreater = (first: Monomial, second: Monomial) => {
107
169
 
108
170
  export class Polynomial {
109
171
  isLexSorted = false;
172
+ refCount = 0;
110
173
 
111
174
  constructor(
112
175
  readonly id: number,
@@ -162,6 +225,13 @@ export class Polynomial {
162
225
  return maxPos;
163
226
  }
164
227
 
228
+ getGradedLexMinPos() {
229
+ let minPos = 0;
230
+ for (let index = 1; index < this.ms.length; index++)
231
+ if (gradedLexCompare(this.ms[index], this.ms[minPos]) < 0) minPos = index;
232
+ return minPos;
233
+ }
234
+
165
235
  toString() {
166
236
  if (this.ms.length === 0) return "0";
167
237
  return this.ms
@@ -177,6 +247,112 @@ export class Polynomial {
177
247
  }
178
248
  }
179
249
 
250
+ export class PolynomialRef {
251
+ private value: Polynomial | null = null;
252
+
253
+ constructor(private readonly pm: PolynomialManager) {}
254
+
255
+ get() {
256
+ const value = this.value;
257
+ if (value === null) throw new SmtInvariantError("polynomial reference is null");
258
+ return value;
259
+ }
260
+
261
+ getOrNull() {
262
+ return this.value;
263
+ }
264
+
265
+ set(polynomial: Polynomial) {
266
+ this.pm.incRef(polynomial);
267
+ if (this.value !== null) this.pm.decRef(this.value);
268
+ this.value = polynomial;
269
+ }
270
+
271
+ copy(other: PolynomialRef) {
272
+ if (this.value === other.value) return;
273
+ if (this.value !== null) this.pm.decRef(this.value);
274
+ this.value = other.value;
275
+ if (this.value !== null) this.pm.incRef(this.value);
276
+ }
277
+
278
+ move(other: PolynomialRef) {
279
+ if (this === other) return;
280
+ if (this.value !== null) this.pm.decRef(this.value);
281
+ this.value = other.value;
282
+ other.value = null;
283
+ }
284
+
285
+ swap(other: PolynomialRef) {
286
+ const value = this.value;
287
+ this.value = other.value;
288
+ other.value = value;
289
+ }
290
+
291
+ reset() {
292
+ if (this.value !== null) this.pm.decRef(this.value);
293
+ this.value = null;
294
+ }
295
+ }
296
+
297
+ export class PolynomialRefVector {
298
+ readonly items: Polynomial[] = [];
299
+
300
+ constructor(private readonly pm: PolynomialManager) {}
301
+
302
+ get size() {
303
+ return this.items.length;
304
+ }
305
+
306
+ get(index: number) {
307
+ return this.items[index];
308
+ }
309
+
310
+ push(polynomial: Polynomial) {
311
+ this.pm.incRef(polynomial);
312
+ this.items.push(polynomial);
313
+ }
314
+
315
+ set(index: number, polynomial: Polynomial) {
316
+ this.pm.incRef(polynomial);
317
+ this.pm.decRef(this.items[index]);
318
+ this.items[index] = polynomial;
319
+ }
320
+
321
+ append(other: PolynomialRefVector) {
322
+ for (const polynomial of other.items) this.push(polynomial);
323
+ }
324
+
325
+ shrink(size: number) {
326
+ for (let index = size; index < this.items.length; index++) this.pm.decRef(this.items[index]);
327
+ this.items.length = size;
328
+ }
329
+
330
+ reset() {
331
+ this.shrink(0);
332
+ }
333
+ }
334
+
335
+ export class Factors {
336
+ constant = 1n;
337
+ readonly factors: Polynomial[] = [];
338
+ readonly degrees: number[] = [];
339
+
340
+ constructor(private readonly pm: PolynomialManager) {}
341
+
342
+ push(polynomial: Polynomial, degree: number) {
343
+ this.factors.push(polynomial);
344
+ this.degrees.push(degree);
345
+ this.pm.incRef(polynomial);
346
+ }
347
+
348
+ reset() {
349
+ for (const factor of this.factors) this.pm.decRef(factor);
350
+ this.factors.length = 0;
351
+ this.degrees.length = 0;
352
+ this.constant = 1n;
353
+ }
354
+ }
355
+
180
356
  class SomBuffer {
181
357
  as: bigint[] = [];
182
358
  ms: Monomial[] = [];
@@ -192,52 +368,69 @@ class SomBuffer {
192
368
 
193
369
  addTerm(coeff: bigint, monomial: Monomial) {
194
370
  if (coeff === 0n) return;
371
+ const modulus = this.manager.modulus;
195
372
  const position = this.positions.get(monomial.id);
196
373
  if (position === undefined) {
197
374
  this.positions.set(monomial.id, this.ms.length);
198
375
  this.ms.push(monomial);
199
- this.as.push(coeff);
376
+ this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
200
377
  return;
201
378
  }
202
- this.as[position] += coeff;
379
+ const sum = this.as[position] + coeff;
380
+ this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
203
381
  }
204
382
 
205
383
  add(polynomial: Polynomial) {
384
+ const modulus = this.manager.modulus;
206
385
  for (let index = 0; index < polynomial.size; index++) {
207
386
  const monomial = polynomial.ms[index];
208
387
  const position = this.positions.get(monomial.id);
209
388
  if (position === undefined) {
210
389
  this.positions.set(monomial.id, this.ms.length);
211
390
  this.ms.push(monomial);
212
- this.as.push(polynomial.as[index]);
213
- } else this.as[position] += polynomial.as[index];
391
+ const coeff = polynomial.as[index];
392
+ this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
393
+ continue;
394
+ }
395
+ const sum = this.as[position] + polynomial.as[index];
396
+ this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
214
397
  }
215
398
  }
216
399
 
217
400
  addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
218
401
  if (coeff === 0n) return;
402
+ const modulus = this.manager.modulus;
219
403
  for (let index = 0; index < polynomial.size; index++) {
220
404
  const product = this.manager.mulMonomials(monomial, polynomial.ms[index]);
221
405
  const position = this.positions.get(product.id);
222
406
  if (position === undefined) {
223
407
  this.positions.set(product.id, this.ms.length);
224
408
  this.ms.push(product);
225
- this.as.push(coeff * polynomial.as[index]);
226
- } else this.as[position] += coeff * polynomial.as[index];
409
+ const value = coeff * polynomial.as[index];
410
+ this.as.push(modulus === null ? value : normalizeZp(value, modulus));
411
+ continue;
412
+ }
413
+ const sum = this.as[position] + coeff * polynomial.as[index];
414
+ this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
227
415
  }
228
416
  }
229
417
 
230
418
  // Like Z3, zero entries of the other buffer are added too, which keeps their monomials' positions.
231
419
  addmulBuffer(coeff: bigint, monomial: Monomial, buffer: SomBuffer) {
232
420
  if (coeff === 0n) return;
421
+ const modulus = this.manager.modulus;
233
422
  for (let index = 0; index < buffer.ms.length; index++) {
234
423
  const product = this.manager.mulMonomials(monomial, buffer.ms[index]);
235
424
  const position = this.positions.get(product.id);
236
425
  if (position === undefined) {
237
426
  this.positions.set(product.id, this.ms.length);
238
427
  this.ms.push(product);
239
- this.as.push(coeff * buffer.as[index]);
240
- } else this.as[position] += coeff * buffer.as[index];
428
+ const value = coeff * buffer.as[index];
429
+ this.as.push(modulus === null ? value : normalizeZp(value, modulus));
430
+ continue;
431
+ }
432
+ const sum = this.as[position] + coeff * buffer.as[index];
433
+ this.as[position] = modulus === null ? sum : normalizeZp(sum, modulus);
241
434
  }
242
435
  }
243
436
 
@@ -259,8 +452,8 @@ class SomBuffer {
259
452
  ms.push(this.ms[index]);
260
453
  }
261
454
  this.reset();
262
- const gcd = isNormalized ? as.reduce((current, coeff) => getGcd(current, coeff), 0n) : 1n;
263
- return this.manager.mkPolynomialCore(gcd > 1n ? as.map((coeff) => coeff / gcd) : as, ms);
455
+ if (isNormalized) this.manager.normalizeNumerals(as);
456
+ return this.manager.mkPolynomialCore(as, ms);
264
457
  }
265
458
  }
266
459
 
@@ -270,20 +463,38 @@ class CheapSomBuffer {
270
463
 
271
464
  constructor(private manager: PolynomialManager) {}
272
465
 
273
- add(coeff: bigint, monomial: Monomial) {
466
+ addReset(coeff: bigint, monomial: Monomial) {
274
467
  if (coeff === 0n) return;
275
468
  this.as.push(coeff);
276
469
  this.ms.push(monomial);
277
470
  }
278
471
 
472
+ add(coeff: bigint, monomial: Monomial) {
473
+ if (coeff === 0n) return;
474
+ const modulus = this.manager.modulus;
475
+ this.as.push(modulus === null ? coeff : normalizeZp(coeff, modulus));
476
+ this.ms.push(monomial);
477
+ }
478
+
279
479
  addmul(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
280
480
  if (coeff === 0n) return;
481
+ const modulus = this.manager.modulus;
281
482
  for (let index = 0; index < polynomial.size; index++) {
282
- this.as.push(coeff * polynomial.as[index]);
483
+ const value = coeff * polynomial.as[index];
484
+ this.as.push(modulus === null ? value : normalizeZp(value, modulus));
283
485
  this.ms.push(this.manager.mulMonomials(monomial, polynomial.ms[index]));
284
486
  }
285
487
  }
286
488
 
489
+ normalize() {
490
+ this.manager.normalizeNumerals(this.as);
491
+ }
492
+
493
+ reset() {
494
+ this.as = [];
495
+ this.ms = [];
496
+ }
497
+
287
498
  mk() {
288
499
  const result = this.manager.mkPolynomialCore(this.as, this.ms);
289
500
  this.as = [];
@@ -292,27 +503,238 @@ class CheapSomBuffer {
292
503
  }
293
504
  }
294
505
 
295
- interface Factors {
296
- constant: bigint;
297
- factors: Polynomial[];
298
- degrees: number[];
506
+ class NewtonInterpolator {
507
+ readonly inputs: bigint[] = [];
508
+ private invs: bigint[] = [0n];
509
+ private vs: PolynomialRefVector;
510
+
511
+ constructor(private readonly pm: PolynomialManager) {
512
+ this.vs = new PolynomialRefVector(pm);
513
+ }
514
+
515
+ reset() {
516
+ this.inputs.length = 0;
517
+ this.invs.length = 1;
518
+ this.vs.reset();
519
+ }
520
+
521
+ add(input: bigint, output: Polynomial) {
522
+ const pm = this.pm;
523
+ const size = this.inputs.length;
524
+ if (size === 0) {
525
+ this.inputs.push(input);
526
+ this.vs.push(output);
527
+ return;
528
+ }
529
+ const k = size;
530
+ let product = pm.subNumeral(input, this.inputs[0]);
531
+ for (let index = 1; index <= k - 1; index++)
532
+ product = pm.mulNumeral(product, pm.subNumeral(input, this.inputs[index]));
533
+ product = pm.invNumeral(product);
534
+ this.inputs.push(input);
535
+ this.invs.push(product);
536
+ const temp = new PolynomialRef(pm);
537
+ const auxPoly = new PolynomialRef(pm);
538
+ temp.set(this.vs.get(k - 1));
539
+ for (let j = k - 2; j >= 0; j--) {
540
+ const aux = pm.subNumeral(input, this.inputs[j]);
541
+ auxPoly.set(pm.mulConst(aux, temp.get()));
542
+ temp.set(pm.add(auxPoly.get(), this.vs.get(j)));
543
+ }
544
+ auxPoly.set(pm.sub(output, temp.get()));
545
+ auxPoly.set(pm.mulConst(this.invs[size], auxPoly.get()));
546
+ this.vs.push(auxPoly.get());
547
+ auxPoly.reset();
548
+ temp.reset();
549
+ }
550
+
551
+ mk(x: number, r: PolynomialRef) {
552
+ const pm = this.pm;
553
+ const u = new PolynomialRef(pm);
554
+ const auxPoly = new PolynomialRef(pm);
555
+ const d = this.inputs.length - 1;
556
+ u.set(this.vs.get(d));
557
+ for (let k = d - 1; k >= 0; k--) {
558
+ const c = pm.negNumeral(this.inputs[k]);
559
+ auxPoly.set(pm.mkLinear([1n], [x], c));
560
+ auxPoly.set(pm.mul(u.get(), auxPoly.get()));
561
+ u.set(pm.add(auxPoly.get(), this.vs.get(k)));
562
+ }
563
+ r.copy(u);
564
+ auxPoly.reset();
565
+ u.reset();
566
+ }
567
+ }
568
+
569
+ interface SkeletonEntry {
570
+ monomial: Monomial;
571
+ firstPowerIndex: number;
572
+ numPowers: number;
573
+ }
574
+
575
+ class Skeleton {
576
+ readonly entries: SkeletonEntry[] = [];
577
+ readonly powers: number[] = [];
578
+ readonly origMonomials: Monomial[] = [];
579
+ maxPowers = 0;
580
+
581
+ constructor(pm: PolynomialManager, polynomial: Polynomial, x: number) {
582
+ const ms = [...polynomial.ms].sort((first, second) => lexCompare2(first, second, x));
583
+ let previous: Monomial | null = null;
584
+ for (const origMonomial of ms) {
585
+ const k = origMonomial.degreeOf(x);
586
+ const monomial = k > 0 ? pm.divX(origMonomial, x) : origMonomial;
587
+ if (monomial === previous) {
588
+ const entry = this.entries[this.entries.length - 1];
589
+ entry.numPowers++;
590
+ if (entry.numPowers > this.maxPowers) this.maxPowers = entry.numPowers;
591
+ } else {
592
+ previous = monomial;
593
+ this.entries.push({ monomial, firstPowerIndex: this.powers.length, numPowers: 1 });
594
+ if (this.maxPowers === 0) this.maxPowers = 1;
595
+ }
596
+ this.origMonomials.push(origMonomial);
597
+ this.powers.push(k);
598
+ }
599
+ }
600
+
601
+ getEntryIndex(monomial: Monomial) {
602
+ for (let index = 0; index < this.entries.length; index++)
603
+ if (this.entries[index].monomial === monomial) return index;
604
+ return -1;
605
+ }
606
+ }
607
+
608
+ const solveLinearEquations = (
609
+ pm: PolynomialManager,
610
+ rows: bigint[][],
611
+ b: bigint[],
612
+ xs: bigint[],
613
+ ) => {
614
+ const n = rows.length;
615
+ for (let k = 0; k < n; k++) {
616
+ let i = k;
617
+ for (; i < n; i++) if (rows[i][k] !== 0n) break;
618
+ if (i === n) return false;
619
+ const row = rows[k];
620
+ rows[k] = rows[i];
621
+ rows[i] = row;
622
+ const rowK = rows[k];
623
+ const pivot = rowK[k];
624
+ for (let column = k + 1; column < n; column++)
625
+ rowK[column] = pm.divNumeral(rowK[column], pivot);
626
+ b[k] = pm.divNumeral(b[k], pivot);
627
+ rowK[k] = pm.normalizeNumeral(1n);
628
+ for (let other = k + 1; other < n; other++) {
629
+ const rowI = rows[other];
630
+ const factor = rowI[k];
631
+ for (let column = k + 1; column < n; column++)
632
+ rowI[column] = pm.normalizeNumeral(rowI[column] - factor * rowK[column]);
633
+ b[other] = pm.normalizeNumeral(b[other] - factor * b[k]);
634
+ rowI[k] = 0n;
635
+ }
636
+ }
637
+ for (let k = n; k-- > 0;) {
638
+ xs[k] = b[k];
639
+ for (let other = k; other-- > 0;) {
640
+ b[other] = pm.normalizeNumeral(b[other] - rows[other][k] * b[k]);
641
+ rows[other][k] = 0n;
642
+ }
643
+ }
644
+ return true;
645
+ };
646
+
647
+ class SparseInterpolator {
648
+ private inputs: bigint[] = [];
649
+ private outputs: bigint[] = [];
650
+
651
+ constructor(
652
+ private readonly pm: PolynomialManager,
653
+ skeleton: Skeleton | null,
654
+ ) {
655
+ if (skeleton !== null)
656
+ for (const entry of skeleton.entries)
657
+ for (let index = 0; index < entry.numPowers; index++) this.outputs.push(0n);
658
+ }
659
+
660
+ reset() {
661
+ this.inputs.length = 0;
662
+ }
663
+
664
+ isReady(skeleton: Skeleton) {
665
+ return this.inputs.length === skeleton.maxPowers;
666
+ }
667
+
668
+ add(skeleton: Skeleton, input: bigint, q: Polynomial) {
669
+ const inputIndex = this.inputs.length;
670
+ this.inputs.push(this.pm.normalizeNumeral(input));
671
+ for (let index = 0; index < q.size; index++) {
672
+ const entryIndex = skeleton.getEntryIndex(q.ms[index]);
673
+ if (entryIndex === -1) return false;
674
+ const entry = skeleton.entries[entryIndex];
675
+ if (inputIndex >= entry.numPowers) continue;
676
+ this.outputs[entry.firstPowerIndex + inputIndex] = this.pm.normalizeNumeral(q.as[index]);
677
+ }
678
+ return true;
679
+ }
680
+
681
+ mk(skeleton: Skeleton, r: PolynomialRef) {
682
+ const pm = this.pm;
683
+ const as: bigint[] = [];
684
+ const ms: Monomial[] = [];
685
+ let rows: bigint[][] = [];
686
+ let b: bigint[] = [];
687
+ for (const entry of skeleton.entries) {
688
+ const numPowers = entry.numPowers;
689
+ if (rows.length !== numPowers) {
690
+ rows = Array.from({ length: numPowers }, () => Array.from({ length: numPowers }, () => 0n));
691
+ b = Array.from({ length: numPowers }, () => 0n);
692
+ }
693
+ const newAs = Array.from({ length: numPowers }, () => 0n);
694
+ for (let index = 0; index < numPowers; index++) {
695
+ const input = this.inputs[index];
696
+ for (let j = 0; j < numPowers; j++)
697
+ rows[index][j] = pm.powerNumeral(input, skeleton.powers[entry.firstPowerIndex + j]);
698
+ b[index] = this.outputs[entry.firstPowerIndex + index];
699
+ }
700
+ if (!solveLinearEquations(pm, rows, b, newAs)) return false;
701
+ for (let index = 0; index < numPowers; index++) {
702
+ if (newAs[index] === 0n) continue;
703
+ as.push(newAs[index]);
704
+ ms.push(skeleton.origMonomials[entry.firstPowerIndex + index]);
705
+ }
706
+ }
707
+ r.set(pm.mkPolynomial(as, ms));
708
+ return true;
709
+ }
299
710
  }
300
711
 
301
712
  export class PolynomialManager {
302
713
  private monomials = new Map<string, Monomial>();
303
714
  private nextPolynomialId = 0;
715
+ private freePolynomialIds: number[] = [];
716
+ private polynomials: (Polynomial | null)[] = [];
717
+ modulus: bigint | null = null;
304
718
  readonly unit: Monomial;
305
719
  readonly zero: Polynomial;
306
720
  readonly one: Polynomial;
307
- private um = new UpolynomialManager();
721
+ private um: UpolynomialManager;
308
722
  private som = new SomBuffer(this);
309
723
  private som2 = new SomBuffer(this);
310
724
  private cheap = new CheapSomBuffer(this);
311
-
312
- constructor() {
725
+ private cheap2 = new CheapSomBuffer(this);
726
+ private random = new RandomGen(0);
727
+ private mgcdInterpolators: NewtonInterpolator[] = [];
728
+ private mgcdSkeletons: (Skeleton | null)[] = [];
729
+ private iccpZpXBuffers: SomBuffer[] = [];
730
+
731
+ constructor(readonly limit: ResourceLimit) {
732
+ this.um = new UpolynomialManager(limit);
313
733
  this.unit = this.mkMonomial([], []);
314
734
  this.zero = this.mkPolynomialCore([], []);
315
- this.one = this.mkPolynomialCore([1n], [this.unit]);
735
+ this.incRef(this.zero);
736
+ this.one = this.mkConstCore(1n);
737
+ this.incRef(this.one);
316
738
  }
317
739
 
318
740
  mkMonomial(vars: readonly number[], degrees: readonly number[]) {
@@ -324,7 +746,7 @@ export class PolynomialManager {
324
746
  return monomial;
325
747
  }
326
748
 
327
- rename(permutation: readonly number[], polynomials: Iterable<Polynomial>) {
749
+ rename(permutation: readonly number[]) {
328
750
  const monomials = new Map<string, Monomial>();
329
751
  for (const monomial of this.monomials.values()) {
330
752
  const order = monomial.vars
@@ -338,7 +760,8 @@ export class PolynomialManager {
338
760
  monomials.set(getMonomialKey(monomial.vars, monomial.degrees), monomial);
339
761
  }
340
762
  this.monomials = monomials;
341
- for (const polynomial of polynomials) polynomial.makeFirstMaximal();
763
+ for (const polynomial of this.polynomials)
764
+ if (polynomial !== null) polynomial.makeFirstMaximal();
342
765
  }
343
766
 
344
767
  mkPower(variable: number, power: number) {
@@ -403,22 +826,114 @@ export class PolynomialManager {
403
826
  return this.mkMonomial(vars, degrees);
404
827
  }
405
828
 
406
- private divX(monomial: Monomial, variable: number) {
829
+ divX(monomial: Monomial, variable: number) {
407
830
  return this.divXk(monomial, variable, monomial.degreeOf(variable));
408
831
  }
409
832
 
833
+ private sqrtMonomial(monomial: Monomial) {
834
+ return this.mkMonomial(
835
+ monomial.vars,
836
+ monomial.degrees.map((degree) => degree / 2),
837
+ );
838
+ }
839
+
840
+ normalizeNumeral(value: bigint) {
841
+ const modulus = this.modulus;
842
+ return modulus === null ? value : normalizeZp(value, modulus);
843
+ }
844
+
845
+ subNumeral(first: bigint, second: bigint) {
846
+ return this.normalizeNumeral(first - second);
847
+ }
848
+
849
+ mulNumeral(first: bigint, second: bigint) {
850
+ return this.normalizeNumeral(first * second);
851
+ }
852
+
853
+ negNumeral(value: bigint) {
854
+ return this.normalizeNumeral(-value);
855
+ }
856
+
857
+ invNumeral(value: bigint) {
858
+ const modulus = this.modulus;
859
+ if (modulus === null) throw new SmtInvariantError("inverse over Z");
860
+ return normalizeZp(getExtendedGcd(normalizeZp(value, modulus), modulus).x, modulus);
861
+ }
862
+
863
+ divNumeral(dividend: bigint, divisor: bigint) {
864
+ return this.modulus === null
865
+ ? divMpz(dividend, divisor)
866
+ : this.mulNumeral(dividend, this.invNumeral(divisor));
867
+ }
868
+
869
+ powerNumeral(base: bigint, exponent: number) {
870
+ if (exponent === 1) return this.normalizeNumeral(base);
871
+ if (exponent === 0) return this.normalizeNumeral(1n);
872
+ let mask = 1;
873
+ let power = this.normalizeNumeral(base);
874
+ let result = this.normalizeNumeral(1n);
875
+ while (mask <= exponent) {
876
+ if ((mask & exponent) !== 0) result = this.mulNumeral(result, power);
877
+ power = this.mulNumeral(power, power);
878
+ mask <<= 1;
879
+ }
880
+ return result;
881
+ }
882
+
883
+ private dividesNumeral(divisor: bigint, dividend: bigint) {
884
+ if (this.modulus !== null && divisor !== 0n) return true;
885
+ return divisor === 0n ? dividend === 0n : dividend % divisor === 0n;
886
+ }
887
+
888
+ private gcdNumerals(as: readonly bigint[]) {
889
+ let result = 0n;
890
+ for (const coeff of as) result = getGcd(result, coeff);
891
+ return result;
892
+ }
893
+
894
+ normalizeNumerals(as: bigint[]) {
895
+ if (as.length === 0) return;
896
+ const g = this.gcdNumerals(as);
897
+ if (g === 1n) return;
898
+ for (let index = 0; index < as.length; index++) as[index] = this.divNumeral(as[index], g);
899
+ }
900
+
901
+ setZp(prime: bigint) {
902
+ this.modulus = prime;
903
+ }
904
+
410
905
  mkPolynomialCore(as: bigint[], ms: Monomial[]) {
411
- return new Polynomial(this.nextPolynomialId++, as, ms);
906
+ const id = this.freePolynomialIds.pop() ?? this.nextPolynomialId++;
907
+ const polynomial = new Polynomial(id, as, ms);
908
+ this.polynomials[id] = polynomial;
909
+ return polynomial;
910
+ }
911
+
912
+ incRef(polynomial: Polynomial) {
913
+ polynomial.refCount++;
914
+ }
915
+
916
+ decRef(polynomial: Polynomial) {
917
+ if (--polynomial.refCount === 0) this.del(polynomial);
918
+ }
919
+
920
+ private del(polynomial: Polynomial) {
921
+ this.polynomials[polynomial.id] = null;
922
+ this.freePolynomialIds.push(polynomial.id);
923
+ }
924
+
925
+ private mkConstCore(value: bigint) {
926
+ return this.mkPolynomialCore([value], [this.unit]);
412
927
  }
413
928
 
414
929
  mkConst(value: bigint) {
415
930
  if (value === 0n) return this.zero;
416
931
  if (value === 1n) return this.one;
417
- return this.mkPolynomialCore([value], [this.unit]);
932
+ return this.mkConstCore(value);
418
933
  }
419
934
 
420
935
  mkVar(variable: number, degree = 1) {
421
- return this.mkPolynomialCore([1n], [this.mkMonomial([variable], [degree])]);
936
+ return this.mkPolynomialCore([1n], [this.mkPower(variable, degree)]);
422
937
  }
423
938
 
424
939
  mkPolynomial(as: readonly bigint[], ms: readonly Monomial[]) {
@@ -427,6 +942,17 @@ export class PolynomialManager {
427
942
  return this.som.mk();
428
943
  }
429
944
 
945
+ private mkUnivariate(variable: number, coeffs: readonly bigint[]) {
946
+ for (let power = coeffs.length - 1; power >= 0; power--)
947
+ this.cheap.addReset(coeffs[power], this.mkPower(variable, power));
948
+ return this.cheap.mk();
949
+ }
950
+
951
+ toPolynomial(coeffs: readonly bigint[], variable: number) {
952
+ if (coeffs.length === 0) return this.zero;
953
+ return this.mkUnivariate(variable, coeffs);
954
+ }
955
+
430
956
  mkLinear(as: readonly bigint[], vars: readonly number[], constant: bigint) {
431
957
  const coeffs: bigint[] = [];
432
958
  const ms: Monomial[] = [];
@@ -504,29 +1030,47 @@ export class PolynomialManager {
504
1030
  return key;
505
1031
  }
506
1032
 
507
- addmul(firstCoeff: bigint, first: Polynomial, secondCoeff: bigint, second: Polynomial) {
1033
+ addmulTerms(
1034
+ firstCoeff: bigint,
1035
+ firstMonomial: Monomial,
1036
+ first: Polynomial,
1037
+ secondCoeff: bigint,
1038
+ secondMonomial: Monomial,
1039
+ second: Polynomial,
1040
+ ) {
508
1041
  this.som.reset();
509
- this.som.addmul(firstCoeff, this.unit, first);
510
- this.som.addmul(secondCoeff, this.unit, second);
1042
+ this.som.addmul(firstCoeff, firstMonomial, first);
1043
+ this.som.addmul(secondCoeff, secondMonomial, second);
511
1044
  return this.som.mk();
512
1045
  }
513
1046
 
1047
+ addmul(first: Polynomial, secondCoeff: bigint, second: Polynomial) {
1048
+ return this.addmulTerms(1n, this.unit, first, secondCoeff, this.unit, second);
1049
+ }
1050
+
514
1051
  add(first: Polynomial, second: Polynomial) {
515
- return this.addmul(1n, first, 1n, second);
1052
+ return this.addmulTerms(1n, this.unit, first, 1n, this.unit, second);
516
1053
  }
517
1054
 
518
1055
  sub(first: Polynomial, second: Polynomial) {
519
- return this.addmul(1n, first, -1n, second);
1056
+ return this.addmulTerms(1n, this.unit, first, this.normalizeNumeral(-1n), this.unit, second);
520
1057
  }
521
1058
 
522
- mul(first: Polynomial, second: Polynomial) {
523
- if (first.size === 0 || second.size === 0) return this.zero;
1059
+ muladd(first: Polynomial, second: Polynomial, constant: bigint) {
1060
+ if (first.size === 0 || second.size === 0) return this.mkConst(constant);
524
1061
  this.som.reset();
525
- for (let index = 0; index < first.size; index++)
1062
+ for (let index = 0; index < first.size; index++) {
1063
+ this.limit.checkpoint();
526
1064
  this.som.addmul(first.as[index], first.ms[index], second);
1065
+ }
1066
+ this.som.addTerm(constant, this.unit);
527
1067
  return this.som.mk();
528
1068
  }
529
1069
 
1070
+ mul(first: Polynomial, second: Polynomial) {
1071
+ return this.muladd(first, second, 0n);
1072
+ }
1073
+
530
1074
  mulTerm(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
531
1075
  if (coeff === 0n) return this.zero;
532
1076
  if (coeff === 1n && monomial === this.unit) return polynomial;
@@ -538,25 +1082,39 @@ export class PolynomialManager {
538
1082
  return this.mulTerm(coeff, this.unit, polynomial);
539
1083
  }
540
1084
 
1085
+ private mulScaled(coeff: bigint, first: Polynomial, second: Polynomial) {
1086
+ if (coeff === 0n || first.size === 0 || second.size === 0) return this.zero;
1087
+ this.som.reset();
1088
+ for (let index = 0; index < first.size; index++) {
1089
+ this.limit.checkpoint();
1090
+ this.som.addmul(this.mulNumeral(coeff, first.as[index]), first.ms[index], second);
1091
+ }
1092
+ return this.som.mk();
1093
+ }
1094
+
541
1095
  neg(polynomial: Polynomial) {
542
1096
  for (let index = 0; index < polynomial.size; index++)
543
- this.cheap.add(-polynomial.as[index], polynomial.ms[index]);
1097
+ this.cheap.add(this.negNumeral(polynomial.as[index]), polynomial.ms[index]);
544
1098
  return this.cheap.mk();
545
1099
  }
546
1100
 
547
- pw(polynomial: Polynomial, power: number) {
548
- if (power === 0) return this.one;
549
- let result = polynomial;
550
- for (let index = 1; index < power; index++) result = this.mul(result, polynomial);
551
- return result;
1101
+ coeff(polynomial: Polynomial, variable: number, power: number) {
1102
+ for (let index = 0; index < polynomial.size; index++) {
1103
+ const monomial = polynomial.ms[index];
1104
+ if (monomial.degreeOf(variable) === power)
1105
+ this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
1106
+ }
1107
+ return this.cheap.mk();
552
1108
  }
553
1109
 
554
- coeff(polynomial: Polynomial, variable: number, power: number) {
1110
+ coeffWithReduct(polynomial: Polynomial, variable: number, power: number, reduct: PolynomialRef) {
555
1111
  for (let index = 0; index < polynomial.size; index++) {
556
1112
  const monomial = polynomial.ms[index];
557
1113
  if (monomial.degreeOf(variable) === power)
558
1114
  this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
1115
+ else this.cheap2.add(polynomial.as[index], monomial);
559
1116
  }
1117
+ reduct.set(this.cheap2.mk());
560
1118
  return this.cheap.mk();
561
1119
  }
562
1120
 
@@ -571,6 +1129,17 @@ export class PolynomialManager {
571
1129
  return result;
572
1130
  }
573
1131
 
1132
+ isNonzeroConstCoeff(polynomial: Polynomial, variable: number, power: number) {
1133
+ const coeff = this.getConstCoeff(polynomial, variable, power);
1134
+ return coeff !== null && coeff !== 0n;
1135
+ }
1136
+
1137
+ private getUnivCoeff(polynomial: Polynomial, power: number) {
1138
+ for (let index = 0; index < polynomial.size; index++)
1139
+ if (polynomial.ms[index].totalDegree === power) return polynomial.as[index];
1140
+ return 0n;
1141
+ }
1142
+
574
1143
  lc(polynomial: Polynomial, variable: number) {
575
1144
  return this.coeff(polynomial, variable, this.degree(polynomial, variable));
576
1145
  }
@@ -580,7 +1149,10 @@ export class PolynomialManager {
580
1149
  const monomial = polynomial.ms[index];
581
1150
  const degree = monomial.degreeOf(variable);
582
1151
  if (degree > 0)
583
- this.cheap.add(polynomial.as[index] * BigInt(degree), this.divXk(monomial, variable, 1));
1152
+ this.cheap.addReset(
1153
+ this.mulNumeral(polynomial.as[index], BigInt(degree)),
1154
+ this.divXk(monomial, variable, 1),
1155
+ );
584
1156
  }
585
1157
  return this.cheap.mk();
586
1158
  }
@@ -601,24 +1173,43 @@ export class PolynomialManager {
601
1173
  return result;
602
1174
  }
603
1175
 
604
- private icWithContent(polynomial: Polynomial): [bigint, Polynomial] {
605
- if (polynomial.size === 0) return [0n, polynomial];
606
- if (this.isConst(polynomial)) return [polynomial.as[0], this.one];
607
- let content = 0n;
608
- for (const coeff of polynomial.as) content = getGcd(content, coeff);
609
- if (content === 1n) return [1n, polynomial];
1176
+ private icWithContent(polynomial: Polynomial, c: PolynomialRef) {
1177
+ if (polynomial.size === 0) {
1178
+ c.set(polynomial);
1179
+ return 0n;
1180
+ }
1181
+ if (this.isConst(polynomial)) {
1182
+ c.set(this.one);
1183
+ return polynomial.as[0];
1184
+ }
1185
+ const content = this.gcdNumerals(polynomial.as);
1186
+ if (content === 1n) {
1187
+ c.set(polynomial);
1188
+ return content;
1189
+ }
1190
+ this.cheap.reset();
610
1191
  for (let index = 0; index < polynomial.size; index++)
611
- this.cheap.add(polynomial.as[index] / content, polynomial.ms[index]);
612
- return [content, this.cheap.mk()];
1192
+ this.cheap.addReset(this.divNumeral(polynomial.as[index], content), polynomial.ms[index]);
1193
+ c.set(this.cheap.mk());
1194
+ return content;
613
1195
  }
614
1196
 
615
- iccp(polynomial: Polynomial, variable: number): [bigint, Polynomial, Polynomial] {
616
- if (polynomial.size === 0) return [0n, this.one, polynomial];
617
- if (this.isConst(polynomial)) return [polynomial.as[0], this.one, this.one];
1197
+ iccp(polynomial: Polynomial, variable: number, c: PolynomialRef, pp: PolynomialRef) {
1198
+ if (polynomial.size === 0) {
1199
+ c.set(this.one);
1200
+ pp.set(polynomial);
1201
+ return 0n;
1202
+ }
1203
+ if (this.isConst(polynomial)) {
1204
+ c.set(this.one);
1205
+ pp.set(this.one);
1206
+ return polynomial.as[0];
1207
+ }
618
1208
  const degree = this.degree(polynomial, variable);
619
1209
  if (degree === 0) {
620
- const [integer, content] = this.icWithContent(polynomial);
621
- return [integer, content, this.one];
1210
+ const integer = this.icWithContent(polynomial, c);
1211
+ pp.set(this.one);
1212
+ return integer;
622
1213
  }
623
1214
  const filter = Array.from({ length: degree + 1 }, () => 0);
624
1215
  const powers: number[] = [];
@@ -627,160 +1218,597 @@ export class PolynomialManager {
627
1218
  if (filter[power] === 0) powers.push(power);
628
1219
  filter[power] += monomial.size === (power > 0 ? 1 : 0) ? 1 : 2;
629
1220
  }
630
- const [integer, primitive] = this.icWithContent(polynomial);
631
- for (const power of powers) if (filter[power] === 1) return [integer, this.one, primitive];
632
- let content = this.coeff(primitive, variable, powers[0]);
1221
+ for (const power of powers)
1222
+ if (filter[power] === 1) {
1223
+ const integer = this.icWithContent(polynomial, pp);
1224
+ c.set(this.one);
1225
+ return integer;
1226
+ }
1227
+ const integer = this.icWithContent(polynomial, pp);
1228
+ const ci = new PolynomialRef(this);
1229
+ c.set(this.coeff(pp.get(), variable, powers[0]));
633
1230
  for (let index = 1; index < powers.length; index++) {
634
- content = this.gcd(content, this.coeff(primitive, variable, powers[index]));
635
- if (this.isConst(content)) return [integer, this.one, primitive];
1231
+ ci.set(this.coeff(pp.get(), variable, powers[index]));
1232
+ this.gcd(c.get(), ci.get(), c);
1233
+ if (this.isConst(c.get())) {
1234
+ c.set(this.one);
1235
+ ci.reset();
1236
+ return integer;
1237
+ }
636
1238
  }
637
- content = this.flipSignIfLmNeg(content);
638
- return [integer, content, this.exactDiv(primitive, content)];
1239
+ c.set(this.flipSignIfLmNeg(c.get()));
1240
+ pp.set(this.exactDiv(pp.get(), c.get()));
1241
+ ci.reset();
1242
+ return integer;
639
1243
  }
640
1244
 
641
1245
  pp(polynomial: Polynomial, variable: number) {
642
- return this.iccp(polynomial, variable)[2];
643
- }
644
-
645
- squareFree(polynomial: Polynomial): Polynomial {
646
- if (this.isConst(polynomial)) return polynomial;
647
- const variable = this.maxVar(polynomial);
648
- const [integer, content, primitive] = this.iccp(polynomial, variable);
649
- const squareFreeContent = this.squareFree(content);
650
- const g = this.gcd(primitive, this.derivative(primitive, variable));
651
- if (this.isConst(g) && this.eq(squareFreeContent, content)) return polynomial;
652
- const squareFreePrimitive = this.isConst(g) ? primitive : this.exactDiv(primitive, g);
653
- return this.mul(this.mulConst(integer, squareFreeContent), squareFreePrimitive);
1246
+ const c = new PolynomialRef(this);
1247
+ const result = new PolynomialRef(this);
1248
+ this.iccp(polynomial, variable, c, result);
1249
+ c.reset();
1250
+ return result;
654
1251
  }
655
1252
 
656
- normalize(polynomial: Polynomial) {
657
- if (polynomial.size === 0) return polynomial;
658
- let g = 0n;
659
- for (const coeff of polynomial.as) g = getGcd(g, coeff);
660
- if (g === 1n) return polynomial;
661
- for (let index = 0; index < polynomial.size; index++)
662
- this.cheap.add(polynomial.as[index] / g, polynomial.ms[index]);
663
- return this.cheap.mk();
1253
+ isPrimitive(polynomial: Polynomial, variable: number) {
1254
+ const c = new PolynomialRef(this);
1255
+ const pp = new PolynomialRef(this);
1256
+ this.iccp(polynomial, variable, c, pp);
1257
+ const result = this.eq(polynomial, pp.get());
1258
+ pp.reset();
1259
+ c.reset();
1260
+ return result;
664
1261
  }
665
1262
 
666
- isNonzeroConstCoeff(polynomial: Polynomial, variable: number, power: number) {
667
- const coeff = this.getConstCoeff(polynomial, variable, power);
668
- return coeff !== null && coeff !== 0n;
669
- }
670
-
671
- exactDiv(polynomial: Polynomial, divisor: Polynomial) {
672
- if (polynomial.size === 0) return polynomial;
673
- const remainder = this.som;
674
- const quotient = this.som2;
675
- remainder.reset();
676
- quotient.reset();
677
- remainder.add(polynomial);
678
- const maxPos = divisor.getGradedLexMaxPos();
679
- const divisorMonomial = divisor.ms[maxPos];
680
- const divisorCoeff = divisor.as[maxPos];
1263
+ private gcdPrs(first: Polynomial, second: Polynomial, variable: number, r: PolynomialRef) {
1264
+ const isSwapped = this.degree(first, variable) < this.degree(second, variable);
1265
+ const u = isSwapped ? second : first;
1266
+ const v = isSwapped ? first : second;
1267
+ const cU = new PolynomialRef(this);
1268
+ const cV = new PolynomialRef(this);
1269
+ const ppU = new PolynomialRef(this);
1270
+ const ppV = new PolynomialRef(this);
1271
+ const dR = new PolynomialRef(this);
1272
+ const g = new PolynomialRef(this);
1273
+ const h = new PolynomialRef(this);
1274
+ const rem = new PolynomialRef(this);
1275
+ const newH = new PolynomialRef(this);
1276
+ const release = () => {
1277
+ newH.reset();
1278
+ rem.reset();
1279
+ h.reset();
1280
+ g.reset();
1281
+ dR.reset();
1282
+ ppV.reset();
1283
+ ppU.reset();
1284
+ cV.reset();
1285
+ cU.reset();
1286
+ };
1287
+ const iU = this.iccp(u, variable, cU, ppU);
1288
+ const iV = this.iccp(v, variable, cV, ppV);
1289
+ this.gcd(cU.get(), cV.get(), dR);
1290
+ const dA = getGcd(iU, iV);
1291
+ g.set(this.one);
1292
+ h.set(this.one);
681
1293
  while (true) {
682
- const remainderPos = remainder.getGradedLexMaxPos();
683
- if (remainderPos === -1) {
684
- remainder.reset();
685
- return quotient.mk();
1294
+ this.limit.checkpoint();
1295
+ const delta = this.degree(ppU.get(), variable) - this.degree(ppV.get(), variable);
1296
+ this.exactPseudoRemainder(ppU.get(), ppV.get(), variable, rem);
1297
+ if (this.isZero(rem.get())) {
1298
+ ppV.set(this.flipSignIfLmNeg(ppV.get()));
1299
+ r.move(this.pp(ppV.get(), variable));
1300
+ r.set(this.mulScaled(dA, dR.get(), r.get()));
1301
+ release();
1302
+ return;
686
1303
  }
687
- const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
688
- if (monomial === null) throw new SmtInvariantError("exact_div: the divisor does not divide");
689
- const coeff = remainder.as[remainderPos] / divisorCoeff;
690
- quotient.addTerm(coeff, monomial);
691
- remainder.addmul(-coeff, monomial, divisor);
1304
+ if (this.isConst(rem.get())) {
1305
+ r.set(this.mulConst(dA, dR.get()));
1306
+ release();
1307
+ return;
1308
+ }
1309
+ ppU.copy(ppV);
1310
+ ppV.set(this.exactDiv(rem.get(), g.get()));
1311
+ for (let index = 0; index < delta; index++) ppV.set(this.exactDiv(ppV.get(), h.get()));
1312
+ g.set(this.lc(ppU.get(), variable));
1313
+ newH.set(this.one);
1314
+ for (let index = 0; index < delta; index++) newH.set(this.mul(newH.get(), g.get()));
1315
+ if (delta > 1)
1316
+ for (let index = 0; index < delta - 1; index++)
1317
+ newH.set(this.exactDiv(newH.get(), h.get()));
1318
+ h.copy(newH);
692
1319
  }
693
1320
  }
694
1321
 
695
- exactPseudoDivision(
696
- polynomial: Polynomial,
697
- divisor: Polynomial,
698
- variable: number,
699
- isQuotient = true,
700
- ) {
701
- return this.pseudoDivisionCore(polynomial, divisor, variable, true, isQuotient);
1322
+ private gcdContent(u: Polynomial, variable: number, v: Polynomial, r: PolynomialRef) {
1323
+ const cU = new PolynomialRef(this);
1324
+ const ppU = new PolynomialRef(this);
1325
+ const iU = this.iccp(u, variable, cU, ppU);
1326
+ cU.set(this.mulConst(iU, cU.get()));
1327
+ this.gcd(cU.get(), v, r);
1328
+ ppU.reset();
1329
+ cU.reset();
702
1330
  }
703
1331
 
704
- pseudoRemainder(polynomial: Polynomial, divisor: Polynomial, variable: number) {
705
- return this.pseudoDivisionCore(polynomial, divisor, variable, false, false);
1332
+ private euclidGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
1333
+ if (this.isZero(u)) {
1334
+ r.set(v);
1335
+ r.set(this.flipSignIfLmNeg(r.get()));
1336
+ return;
1337
+ }
1338
+ if (this.isZero(v)) {
1339
+ r.set(u);
1340
+ r.set(this.flipSignIfLmNeg(r.get()));
1341
+ return;
1342
+ }
1343
+ if (u === v) {
1344
+ r.set(u);
1345
+ r.set(this.flipSignIfLmNeg(r.get()));
1346
+ return;
1347
+ }
1348
+ if (this.isConst(u) || this.isConst(v)) {
1349
+ const iV = this.getIc(v);
1350
+ const iU = this.getIc(u);
1351
+ r.set(this.mkConst(getGcd(iV, iU)));
1352
+ return;
1353
+ }
1354
+ this.gcdPrs(u, v, this.maxVar(u), r);
706
1355
  }
707
1356
 
708
- private pseudoDivisionCore(
709
- polynomial: Polynomial,
710
- divisor: Polynomial,
711
- variable: number,
712
- isExact: boolean,
713
- isQuotient: boolean,
1357
+ private craCombineImages(
1358
+ c1: Polynomial,
1359
+ b1: bigint,
1360
+ c2: Polynomial,
1361
+ b2: bigint,
1362
+ r: PolynomialRef,
714
1363
  ) {
715
- const degA = this.degree(polynomial, variable);
716
- const degB = this.degree(divisor, variable);
717
- if (degB === 0) {
718
- const steps = isExact ? degA + 1 : 1;
719
- if (!isQuotient || !isExact || degA === 0)
720
- return { quotient: polynomial, remainder: this.zero, steps };
721
- return {
722
- quotient: this.mul(polynomial, this.pw(divisor, degA)),
723
- remainder: this.zero,
724
- steps,
725
- };
726
- }
727
- const lcB = this.coeff(divisor, variable, degB);
728
- const reductB = this.reduct(divisor, variable, degB);
729
- let remainder = polynomial;
730
- let quotient = this.zero;
731
- let steps = 0;
1364
+ c1.lexSort();
1365
+ c2.lexSort();
1366
+ const inverses = getExtendedGcd(b1, b2);
1367
+ const inv1 = modMpz(inverses.x, b2);
1368
+ const inv2 = modMpz(inverses.y, b1);
1369
+ const a1 = this.mulNumeral(b2, inv2);
1370
+ const a2 = this.mulNumeral(b1, inv1);
1371
+ const newBound = this.mulNumeral(b1, b2);
1372
+ const upper = divMpz(newBound, 2n);
1373
+ const add = (first: bigint, second: bigint, monomial: Monomial) => {
1374
+ const tmp3 = this.normalizeNumeral(this.mulNumeral(first, a1) + this.mulNumeral(second, a2));
1375
+ const value = modMpz(tmp3, newBound);
1376
+ this.cheap.add(value > upper ? this.subNumeral(value, newBound) : value, monomial);
1377
+ };
1378
+ let i1 = 0;
1379
+ let i2 = 0;
732
1380
  while (true) {
733
- const degR = this.degree(remainder, variable);
734
- if (degB > degR) {
735
- const exactSteps = degA - degB + 1;
736
- if (isExact && steps < exactSteps) {
737
- const power = this.pw(lcB, exactSteps - steps);
738
- if (isQuotient) quotient = this.mul(power, quotient);
739
- remainder = this.mul(power, remainder);
740
- }
741
- return { quotient, remainder, steps };
1381
+ if (i1 === c1.size) {
1382
+ for (; i2 < c2.size; i2++) add(0n, c2.as[i2], c2.ms[i2]);
1383
+ break;
742
1384
  }
743
- this.som.reset();
744
- this.som2.reset();
745
- for (let index = 0; index < remainder.size; index++) {
746
- const monomial = remainder.ms[index];
747
- const coeff = remainder.as[index];
748
- if (monomial.degreeOf(variable) === degR) {
749
- const shifted = this.divXk(monomial, variable, degB);
750
- if (isQuotient) this.som2.addTerm(coeff, shifted);
751
- this.som.addmul(-coeff, shifted, reductB);
752
- } else this.som.addmul(coeff, monomial, lcB);
1385
+ if (i2 === c2.size) {
1386
+ for (; i1 < c1.size; i1++) add(c1.as[i1], 0n, c1.ms[i1]);
1387
+ break;
753
1388
  }
754
- remainder = this.som.mk();
755
- if (isQuotient) {
756
- for (let index = 0; index < quotient.size; index++)
757
- this.som2.addmul(quotient.as[index], quotient.ms[index], lcB);
758
- quotient = this.som2.mk();
1389
+ const m1 = c1.ms[i1];
1390
+ const m2 = c2.ms[i2];
1391
+ const s = lexCompare(m1, m2);
1392
+ if (s === 0) {
1393
+ add(c1.as[i1], c2.as[i2], m1);
1394
+ i1++;
1395
+ i2++;
1396
+ } else if (s > 0) {
1397
+ add(c1.as[i1], 0n, m1);
1398
+ i1++;
1399
+ } else {
1400
+ add(0n, c2.as[i2], m2);
1401
+ i2++;
1402
+ }
1403
+ }
1404
+ r.set(this.cheap.mk());
1405
+ return newBound;
1406
+ }
1407
+
1408
+ private uniModGcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
1409
+ const x = this.maxVar(u);
1410
+ const ppU = new PolynomialRef(this);
1411
+ const ppV = new PolynomialRef(this);
1412
+ const cU = this.icWithContent(u, ppU);
1413
+ const cV = this.icWithContent(v, ppV);
1414
+ const dA = getGcd(cU, cV);
1415
+ const dU = this.degree(ppU.get(), x);
1416
+ const dV = this.degree(ppV.get(), x);
1417
+ const lcU = this.getUnivCoeff(ppU.get(), dU);
1418
+ const lcV = this.getUnivCoeff(ppV.get(), dV);
1419
+ const lcG = getGcd(lcU, lcV);
1420
+ const uZp = new PolynomialRef(this);
1421
+ const vZp = new PolynomialRef(this);
1422
+ const cStar = new PolynomialRef(this);
1423
+ let bound = 0n;
1424
+ const q = new PolynomialRef(this);
1425
+ const candidate = new PolynomialRef(this);
1426
+ const release = () => {
1427
+ candidate.reset();
1428
+ q.reset();
1429
+ cStar.reset();
1430
+ vZp.reset();
1431
+ uZp.reset();
1432
+ ppV.reset();
1433
+ ppU.reset();
1434
+ };
1435
+ for (const prime of BIG_PRIMES) {
1436
+ const savedModulus = this.modulus;
1437
+ this.setZp(prime);
1438
+ uZp.set(this.normalize(ppU.get()));
1439
+ vZp.set(this.normalize(ppV.get()));
1440
+ const isBadPrime = this.degree(uZp.get(), x) < dU || this.degree(vZp.get(), x) < dV;
1441
+ if (!isBadPrime) {
1442
+ this.euclidGcd(uZp.get(), vZp.get(), q);
1443
+ q.set(this.mkGlexMonic(q.get()));
1444
+ q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
1445
+ }
1446
+ this.modulus = savedModulus;
1447
+ if (isBadPrime) continue;
1448
+ if (this.isConst(q.get())) {
1449
+ // Deviation from Z3: when d_a is 1, uni_mod_gcd returns a constant q other than 1, so gcd(2x - 3, 2x - 1) is 2 there.
1450
+ r.set(dA === 1n && q.get().as[0] === 1n ? q.get() : this.mkConst(dA));
1451
+ release();
1452
+ return;
1453
+ }
1454
+ if (cStar.getOrNull() === null) {
1455
+ cStar.copy(q);
1456
+ bound = prime;
1457
+ } else if (this.degree(q.get(), x) < this.degree(cStar.get(), x)) {
1458
+ cStar.copy(q);
1459
+ bound = prime;
1460
+ } else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
1461
+ candidate.move(this.pp(cStar.get(), x));
1462
+ const lcCandidate = this.getUnivCoeff(candidate.get(), this.degree(candidate.get(), x));
1463
+ if (
1464
+ this.dividesNumeral(lcCandidate, lcG) &&
1465
+ this.divides(candidate.get(), ppU.get()) &&
1466
+ this.divides(candidate.get(), ppV.get())
1467
+ ) {
1468
+ r.set(this.mulConst(dA, candidate.get()));
1469
+ r.set(this.flipSignIfLmNeg(r.get()));
1470
+ release();
1471
+ return;
759
1472
  }
760
- steps++;
761
1473
  }
1474
+ this.gcdPrs(u, v, x, r);
1475
+ release();
762
1476
  }
763
1477
 
764
- exactPseudoRemainder(polynomial: Polynomial, divisor: Polynomial, variable: number) {
765
- return this.exactPseudoDivision(polynomial, divisor, variable, false).remainder;
1478
+ private iccpZpX(polynomial: Polynomial, x: number, c: PolynomialRef, pp: PolynomialRef): bigint {
1479
+ if (polynomial.size === 0) {
1480
+ c.set(this.one);
1481
+ pp.set(polynomial);
1482
+ return 0n;
1483
+ }
1484
+ if (this.isConst(polynomial)) {
1485
+ c.set(this.one);
1486
+ pp.set(this.one);
1487
+ return polynomial.as[0];
1488
+ }
1489
+ const degree = this.degree(polynomial, x);
1490
+ if (degree === 0) {
1491
+ const ci = this.icWithContent(polynomial, pp);
1492
+ c.set(this.one);
1493
+ return ci;
1494
+ }
1495
+ const marks = new Map<number, number>();
1496
+ const noXMonomials: Monomial[] = [];
1497
+ let minDegree = Infinity;
1498
+ for (const monomial of polynomial.ms) {
1499
+ const k = monomial.degreeOf(x);
1500
+ if (k === 0 && !marks.has(monomial.id)) {
1501
+ noXMonomials.push(monomial);
1502
+ marks.set(monomial.id, 1);
1503
+ }
1504
+ if (k < minDegree) minDegree = k;
1505
+ }
1506
+ if (minDegree > 0) {
1507
+ const xmin = new PolynomialRef(this);
1508
+ const newP = new PolynomialRef(this);
1509
+ xmin.set(this.mkVar(x, minDegree));
1510
+ newP.set(this.exactDiv(polynomial, xmin.get()));
1511
+ const ci = this.iccpZpX(newP.get(), x, c, pp);
1512
+ c.set(this.mul(xmin.get(), c.get()));
1513
+ newP.reset();
1514
+ xmin.reset();
1515
+ return ci;
1516
+ }
1517
+ const numMarked = noXMonomials.length;
1518
+ let numUnmarked = 0;
1519
+ for (const monomial of polynomial.ms) {
1520
+ if (monomial.degreeOf(x) === 0) continue;
1521
+ const reduced = this.divX(monomial, x);
1522
+ if (marks.get(reduced.id) === 1) {
1523
+ numUnmarked++;
1524
+ marks.delete(reduced.id);
1525
+ }
1526
+ }
1527
+ if (numUnmarked < numMarked) {
1528
+ const ci = this.icWithContent(polynomial, pp);
1529
+ c.set(this.one);
1530
+ return ci;
1531
+ }
1532
+ const ci = this.icWithContent(polynomial, pp);
1533
+ marks.clear();
1534
+ noXMonomials.length = 0;
1535
+ const buffers = this.iccpZpXBuffers;
1536
+ const ppValue = pp.get();
1537
+ for (let index = 0; index < polynomial.size; index++) {
1538
+ let monomial = ppValue.ms[index];
1539
+ const k = monomial.degreeOf(x);
1540
+ if (k !== 0) monomial = this.divX(monomial, x);
1541
+ let position = marks.get(monomial.id);
1542
+ if (position === undefined) {
1543
+ position = noXMonomials.length;
1544
+ noXMonomials.push(monomial);
1545
+ marks.set(monomial.id, position);
1546
+ }
1547
+ while (buffers.length <= position) buffers.push(new SomBuffer(this));
1548
+ buffers[position].addTerm(ppValue.as[index], this.mkPower(x, k));
1549
+ }
1550
+ const numMonomials = noXMonomials.length;
1551
+ const g = new PolynomialRef(this);
1552
+ const newG = new PolynomialRef(this);
1553
+ g.set(buffers[0].mk());
1554
+ for (let index = 1; index < numMonomials; index++) {
1555
+ const a = new PolynomialRef(this);
1556
+ a.set(buffers[index].mk());
1557
+ this.euclidGcd(g.get(), a.get(), newG);
1558
+ g.copy(newG);
1559
+ const isDone = this.isConst(g.get());
1560
+ a.reset();
1561
+ if (isDone) break;
1562
+ }
1563
+ if (!this.isConst(g.get())) {
1564
+ c.copy(g);
1565
+ pp.set(this.exactDiv(pp.get(), c.get()));
1566
+ } else c.set(this.one);
1567
+ for (let index = 0; index < numMonomials; index++) buffers[index].reset();
1568
+ newG.reset();
1569
+ g.reset();
1570
+ return ci;
1571
+ }
1572
+
1573
+ private lcGlexZpX(polynomial: Polynomial, x: number) {
1574
+ this.som.reset();
1575
+ let maxMonomial: Monomial | null = null;
1576
+ for (let index = 0; index < polynomial.size; index++) {
1577
+ let monomial = polynomial.ms[index];
1578
+ const k = monomial.degreeOf(x);
1579
+ if (k !== 0) monomial = this.divX(monomial, x);
1580
+ if (maxMonomial === null || gradedLexCompare(monomial, maxMonomial) > 0) {
1581
+ this.som.reset();
1582
+ maxMonomial = monomial;
1583
+ this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
1584
+ } else if (maxMonomial === monomial)
1585
+ this.som.addTerm(polynomial.as[index], this.mkPower(x, k));
1586
+ }
1587
+ return this.som.mk();
766
1588
  }
767
1589
 
768
- reduct(polynomial: Polynomial, variable: number, power: number) {
1590
+ private primitiveZpX(polynomial: Polynomial, x: number, pp: PolynomialRef) {
1591
+ const c = new PolynomialRef(this);
1592
+ this.iccpZpX(polynomial, x, c, pp);
1593
+ c.reset();
1594
+ }
1595
+
1596
+ private peekFresh(values: readonly bigint[], prime: number) {
1597
+ while (true) {
1598
+ const hi = this.random.next();
1599
+ const lo = this.random.next();
1600
+ const value = this.normalizeNumeral(BigInt(((hi << 15) | lo) % prime));
1601
+ if (!values.includes(value)) return value;
1602
+ }
1603
+ }
1604
+
1605
+ private univEval(polynomial: Polynomial, value: bigint) {
1606
+ if (polynomial.size === 0) return 0n;
1607
+ if (this.isConst(polynomial)) return this.normalizeNumeral(polynomial.as[0]);
1608
+ polynomial.lexSort();
1609
+ let result = 0n;
769
1610
  for (let index = 0; index < polynomial.size; index++)
770
- if (polynomial.ms[index].degreeOf(variable) !== power)
771
- this.cheap.add(polynomial.as[index], polynomial.ms[index]);
772
- return this.cheap.mk();
1611
+ result = this.normalizeNumeral(
1612
+ result +
1613
+ this.mulNumeral(
1614
+ polynomial.as[index],
1615
+ this.powerNumeral(value, polynomial.ms[index].totalDegree),
1616
+ ),
1617
+ );
1618
+ return result;
773
1619
  }
774
1620
 
775
- private getMaxDegrees(polynomial: Polynomial) {
776
- const degrees = new Map<number, number>();
777
- for (const monomial of polynomial.ms)
778
- for (let index = 0; index < monomial.size; index++) {
779
- const variable = monomial.vars[index];
780
- if (monomial.degrees[index] > (degrees.get(variable) ?? 0))
781
- degrees.set(variable, monomial.degrees[index]);
1621
+ private modGcdRec(
1622
+ u: Polynomial,
1623
+ v: Polynomial,
1624
+ prime: number,
1625
+ idx: number,
1626
+ vars: readonly number[],
1627
+ r: PolynomialRef,
1628
+ ): boolean {
1629
+ if (idx === vars.length - 1) {
1630
+ this.euclidGcd(u, v, r);
1631
+ return true;
1632
+ }
1633
+ const x = vars[idx];
1634
+ const cU = new PolynomialRef(this);
1635
+ const ppU = new PolynomialRef(this);
1636
+ const lcU = new PolynomialRef(this);
1637
+ const cV = new PolynomialRef(this);
1638
+ const ppV = new PolynomialRef(this);
1639
+ const lcV = new PolynomialRef(this);
1640
+ const cG = new PolynomialRef(this);
1641
+ const lcG = new PolynomialRef(this);
1642
+ const u1 = new PolynomialRef(this);
1643
+ const v1 = new PolynomialRef(this);
1644
+ const q = new PolynomialRef(this);
1645
+ const h = new PolynomialRef(this);
1646
+ const c = new PolynomialRef(this);
1647
+ const lcH = new PolynomialRef(this);
1648
+ try {
1649
+ const ciU = this.iccpZpX(u, x, cU, ppU);
1650
+ const ciV = this.iccpZpX(v, x, cV, ppV);
1651
+ lcU.set(this.lcGlexZpX(ppU.get(), x));
1652
+ lcV.set(this.lcGlexZpX(ppV.get(), x));
1653
+ const ciG = getGcd(ciU, ciV);
1654
+ this.euclidGcd(cU.get(), cV.get(), cG);
1655
+ this.euclidGcd(lcU.get(), lcV.get(), lcG);
1656
+ const skeleton = this.mgcdSkeletons[idx];
1657
+ while (this.mgcdInterpolators.length <= idx)
1658
+ this.mgcdInterpolators.push(new NewtonInterpolator(this));
1659
+ const interpolator = this.mgcdInterpolators[idx];
1660
+ const sparseInterpolator = new SparseInterpolator(this, skeleton);
1661
+ let minDegQ = Infinity;
1662
+ while (true) {
1663
+ let value = 0n;
1664
+ let lcGValue = 0n;
1665
+ while (true) {
1666
+ value = this.peekFresh(interpolator.inputs, prime);
1667
+ lcGValue = this.univEval(lcG.get(), value);
1668
+ if (lcGValue !== 0n) break;
1669
+ }
1670
+ u1.set(this.substitute(ppU.get(), [x], [value]));
1671
+ v1.set(this.substitute(ppV.get(), [x], [value]));
1672
+ if (!this.modGcdRec(u1.get(), v1.get(), prime, idx + 1, vars, q)) return false;
1673
+ q.set(this.mkGlexMonic(q.get()));
1674
+ q.set(this.mulConst(lcGValue, q.get()));
1675
+ const qVar = this.maxVar(q.get());
1676
+ const degQ = qVar === NULL_VAR ? 0 : this.degree(q.get(), qVar);
1677
+ if (degQ < minDegQ) {
1678
+ minDegQ = degQ;
1679
+ if (skeleton === null) {
1680
+ interpolator.reset();
1681
+ interpolator.add(value, q.get());
1682
+ } else {
1683
+ sparseInterpolator.reset();
1684
+ if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
1685
+ }
1686
+ } else if (degQ === minDegQ) {
1687
+ if (skeleton === null) interpolator.add(value, q.get());
1688
+ else if (!sparseInterpolator.add(skeleton, value, q.get())) return false;
1689
+ } else continue;
1690
+ let isCandidate = false;
1691
+ if (skeleton === null) {
1692
+ interpolator.mk(x, h);
1693
+ lcH.set(this.lcGlexZpX(h.get(), x));
1694
+ if (this.eq(lcH.get(), lcG.get())) isCandidate = true;
1695
+ } else if (sparseInterpolator.isReady(skeleton)) {
1696
+ if (!sparseInterpolator.mk(skeleton, h)) return false;
1697
+ isCandidate = true;
1698
+ }
1699
+ if (!isCandidate) continue;
1700
+ if (this.degree(h.get(), x) > 0) this.primitiveZpX(h.get(), x, c);
1701
+ else c.set(this.normalize(h.get()));
1702
+ if (this.divides(c.get(), ppU.get()) && this.divides(c.get(), ppV.get())) {
1703
+ r.set(this.mul(cG.get(), c.get()));
1704
+ r.set(this.mulConst(ciG, r.get()));
1705
+ } else if (minDegQ === 0) {
1706
+ r.copy(cG);
1707
+ r.set(this.mulConst(ciG, r.get()));
1708
+ } else if (skeleton !== null) return false;
1709
+ else continue;
1710
+ if (skeleton === null) this.mgcdSkeletons[idx] = new Skeleton(this, h.get(), x);
1711
+ return true;
782
1712
  }
783
- return degrees;
1713
+ } finally {
1714
+ lcH.reset();
1715
+ c.reset();
1716
+ h.reset();
1717
+ q.reset();
1718
+ v1.reset();
1719
+ u1.reset();
1720
+ lcG.reset();
1721
+ cG.reset();
1722
+ lcV.reset();
1723
+ ppV.reset();
1724
+ cV.reset();
1725
+ lcU.reset();
1726
+ ppU.reset();
1727
+ cU.reset();
1728
+ }
1729
+ }
1730
+
1731
+ private modGcd(
1732
+ u: Polynomial,
1733
+ v: Polynomial,
1734
+ uDegrees: readonly [number, number][],
1735
+ vDegrees: readonly [number, number][],
1736
+ r: PolynomialRef,
1737
+ ): boolean {
1738
+ const minDegrees = uDegrees.map((entry, index): [number, number] => [
1739
+ entry[0],
1740
+ Math.min(entry[1], vDegrees[index][1]),
1741
+ ]);
1742
+ minDegrees.sort((first, second) => first[1] - second[1] || first[0] - second[0]);
1743
+ this.mgcdSkeletons = minDegrees.map(() => null);
1744
+ const vars = minDegrees.map((entry) => entry[0]);
1745
+ const ppU = new PolynomialRef(this);
1746
+ const ppV = new PolynomialRef(this);
1747
+ const uZp = new PolynomialRef(this);
1748
+ const vZp = new PolynomialRef(this);
1749
+ const cStar = new PolynomialRef(this);
1750
+ const q = new PolynomialRef(this);
1751
+ const candidate = new PolynomialRef(this);
1752
+ try {
1753
+ const cU = this.icWithContent(u, ppU);
1754
+ const cV = this.icWithContent(v, ppV);
1755
+ const dA = getGcd(cU, cV);
1756
+ const lcU = ppU.get().as[ppU.get().getGradedLexMaxPos()];
1757
+ const lcV = ppV.get().as[ppV.get().getGradedLexMaxPos()];
1758
+ const lcG = getGcd(lcU, lcV);
1759
+ let bound = 0n;
1760
+ for (const prime of BIG_PRIMES) {
1761
+ const savedModulus = this.modulus;
1762
+ this.setZp(prime);
1763
+ try {
1764
+ uZp.set(this.normalize(ppU.get()));
1765
+ if (uZp.get().size !== ppU.get().size) continue;
1766
+ vZp.set(this.normalize(ppV.get()));
1767
+ if (vZp.get().size !== ppV.get().size) continue;
1768
+ if (!this.modGcdRec(uZp.get(), vZp.get(), Number(prime), 0, vars, q)) return false;
1769
+ q.set(this.mkGlexMonic(q.get()));
1770
+ q.set(this.mulConst(this.normalizeNumeral(lcG), q.get()));
1771
+ } finally {
1772
+ this.modulus = savedModulus;
1773
+ }
1774
+ if (this.isConst(q.get())) {
1775
+ r.set(this.mkConst(dA));
1776
+ return true;
1777
+ }
1778
+ if (cStar.getOrNull() === null) {
1779
+ cStar.copy(q);
1780
+ bound = prime;
1781
+ } else {
1782
+ const maxCStar = cStar.get().ms[cStar.get().getGradedLexMaxPos()];
1783
+ const maxQ = q.get().ms[q.get().getGradedLexMaxPos()];
1784
+ if (gradedLexCompare(maxQ, maxCStar) < 0) {
1785
+ cStar.copy(q);
1786
+ bound = prime;
1787
+ } else bound = this.craCombineImages(q.get(), prime, cStar.get(), bound, cStar);
1788
+ }
1789
+ candidate.set(this.normalize(cStar.get()));
1790
+ const lcCandidate = candidate.get().as[candidate.get().getGradedLexMaxPos()];
1791
+ if (
1792
+ this.dividesNumeral(lcCandidate, lcG) &&
1793
+ this.divides(candidate.get(), ppU.get()) &&
1794
+ this.divides(candidate.get(), ppV.get())
1795
+ ) {
1796
+ r.set(this.mulConst(dA, candidate.get()));
1797
+ r.set(this.flipSignIfLmNeg(r.get()));
1798
+ return true;
1799
+ }
1800
+ }
1801
+ this.gcdPrs(u, v, this.maxVar(u), r);
1802
+ return true;
1803
+ } finally {
1804
+ candidate.reset();
1805
+ q.reset();
1806
+ cStar.reset();
1807
+ vZp.reset();
1808
+ uZp.reset();
1809
+ ppV.reset();
1810
+ ppU.reset();
1811
+ }
784
1812
  }
785
1813
 
786
1814
  private getVarMaxDegrees(polynomial: Polynomial) {
@@ -789,207 +1817,666 @@ export class PolynomialManager {
789
1817
  );
790
1818
  }
791
1819
 
792
- // Deviation from Z3: subresultant PRS (gcd_prs), not mod_gcd, which can return 2 for coprime inputs (polynomial.cpp:4815).
793
- gcd(first: Polynomial, second: Polynomial): Polynomial {
794
- if (first.size === 0) return this.flipSignIfLmNeg(second);
795
- if (second.size === 0) return this.flipSignIfLmNeg(first);
796
- if (first === second) return this.flipSignIfLmNeg(first);
797
- if (this.isConst(first) || this.isConst(second))
798
- return this.mkConst(getGcd(this.getIc(second), this.getIc(first)));
799
- const firstDegrees = this.getVarMaxDegrees(first);
800
- const secondDegrees = this.getVarMaxDegrees(second);
801
- const size = Math.min(firstDegrees.length, secondDegrees.length);
1820
+ gcd(u: Polynomial, v: Polynomial, r: PolynomialRef) {
1821
+ if (this.isZero(u)) {
1822
+ r.set(v);
1823
+ r.set(this.flipSignIfLmNeg(r.get()));
1824
+ return;
1825
+ }
1826
+ if (this.isZero(v)) {
1827
+ r.set(u);
1828
+ r.set(this.flipSignIfLmNeg(r.get()));
1829
+ return;
1830
+ }
1831
+ if (u === v) {
1832
+ r.set(u);
1833
+ r.set(this.flipSignIfLmNeg(r.get()));
1834
+ return;
1835
+ }
1836
+ if (this.isConst(u) || this.isConst(v)) {
1837
+ const iV = this.getIc(v);
1838
+ const iU = this.getIc(u);
1839
+ r.set(this.mkConst(getGcd(iV, iU)));
1840
+ return;
1841
+ }
1842
+ const uDegrees = this.getVarMaxDegrees(u);
1843
+ const vDegrees = this.getVarMaxDegrees(v);
1844
+ const size = Math.min(uDegrees.length, vDegrees.length);
802
1845
  for (let index = 0; index < size; index++) {
803
- const firstVar = firstDegrees[index][0];
804
- const secondVar = secondDegrees[index][0];
805
- if (firstVar < secondVar) return this.gcdContent(first, firstVar, second);
806
- if (firstVar > secondVar) return this.gcdContent(second, secondVar, first);
807
- }
808
- if (size < firstDegrees.length) return this.gcdContent(first, firstDegrees[size][0], second);
809
- if (size < secondDegrees.length) return this.gcdContent(second, secondDegrees[size][0], first);
810
- return this.gcdPrs(first, second, firstDegrees[size - 1][0]);
811
- }
812
-
813
- private gcdContent(polynomial: Polynomial, variable: number, other: Polynomial) {
814
- const [integer, content] = this.iccp(polynomial, variable);
815
- return this.gcd(this.mulConst(integer, content), other);
816
- }
817
-
818
- private gcdPrs(first: Polynomial, second: Polynomial, variable: number) {
819
- const [u, v] =
820
- this.degree(first, variable) < this.degree(second, variable)
821
- ? [second, first]
822
- : [first, second];
823
- const [integerU, contentU, primitiveU] = this.iccp(u, variable);
824
- const [integerV, contentV, primitiveV] = this.iccp(v, variable);
825
- const contentGcd = this.gcd(contentU, contentV);
826
- const integerGcd = getGcd(integerU, integerV);
827
- let ppU = primitiveU;
828
- let ppV = primitiveV;
829
- let g = this.one;
830
- let h = this.one;
831
- while (true) {
832
- const delta = this.degree(ppU, variable) - this.degree(ppV, variable);
833
- const remainder = this.exactPseudoRemainder(ppU, ppV, variable);
834
- if (remainder.size === 0) {
835
- const result = this.pp(this.flipSignIfLmNeg(ppV), variable);
836
- return this.mulConst(integerGcd, this.mul(contentGcd, result));
1846
+ const xu = uDegrees[index][0];
1847
+ const xv = vDegrees[index][0];
1848
+ if (xu < xv) {
1849
+ this.gcdContent(u, xu, v, r);
1850
+ return;
1851
+ }
1852
+ if (xu > xv) {
1853
+ this.gcdContent(v, xv, u, r);
1854
+ return;
837
1855
  }
838
- if (this.isConst(remainder)) return this.mulConst(integerGcd, contentGcd);
839
- ppU = ppV;
840
- ppV = this.exactDiv(remainder, g);
841
- for (let index = 0; index < delta; index++) ppV = this.exactDiv(ppV, h);
842
- g = this.lc(ppU, variable);
843
- let newH = this.one;
844
- for (let index = 0; index < delta; index++) newH = this.mul(newH, g);
845
- for (let index = 1; index < delta; index++) newH = this.exactDiv(newH, h);
846
- h = newH;
847
1856
  }
1857
+ if (size < uDegrees.length) {
1858
+ this.gcdContent(u, uDegrees[size][0], v, r);
1859
+ return;
1860
+ }
1861
+ if (size < vDegrees.length) {
1862
+ this.gcdContent(v, vDegrees[size][0], u, r);
1863
+ return;
1864
+ }
1865
+ const x = uDegrees[size - 1][0];
1866
+ if (this.modulus !== null) {
1867
+ this.gcdPrs(u, v, x, r);
1868
+ return;
1869
+ }
1870
+ if (this.isUnivariate(u)) {
1871
+ this.uniModGcd(u, v, r);
1872
+ return;
1873
+ }
1874
+ if (!this.modGcd(u, v, uDegrees, vDegrees, r)) this.gcdPrs(u, v, x, r);
848
1875
  }
849
1876
 
850
- private getMinDegreeVar(polynomial: Polynomial) {
851
- let result = NULL_VAR;
852
- let minDegree = Infinity;
853
- for (const [variable, degree] of this.getMaxDegrees(polynomial))
854
- if (degree < minDegree) {
855
- result = variable;
856
- minDegree = degree;
1877
+ squareFree(polynomial: Polynomial, r: PolynomialRef) {
1878
+ if (this.isZero(polynomial)) {
1879
+ r.set(this.zero);
1880
+ return;
1881
+ }
1882
+ if (this.isConst(polynomial)) {
1883
+ r.set(polynomial);
1884
+ return;
1885
+ }
1886
+ const x = this.maxVar(polynomial);
1887
+ const c = new PolynomialRef(this);
1888
+ const pp = new PolynomialRef(this);
1889
+ const integer = this.iccp(polynomial, x, c, pp);
1890
+ const sqfC = new PolynomialRef(this);
1891
+ this.squareFree(c.get(), sqfC);
1892
+ const ppPrime = new PolynomialRef(this);
1893
+ ppPrime.set(this.derivative(pp.get(), x));
1894
+ const g = new PolynomialRef(this);
1895
+ this.gcd(pp.get(), ppPrime.get(), g);
1896
+ const release = () => {
1897
+ g.reset();
1898
+ ppPrime.reset();
1899
+ sqfC.reset();
1900
+ pp.reset();
1901
+ c.reset();
1902
+ };
1903
+ if (this.isConst(g.get())) {
1904
+ if (this.eq(sqfC.get(), c.get())) {
1905
+ r.set(polynomial);
1906
+ release();
1907
+ return;
857
1908
  }
858
- return result;
1909
+ } else pp.set(this.exactDiv(pp.get(), g.get()));
1910
+ r.set(this.mulConst(integer, sqfC.get()));
1911
+ r.set(this.mul(r.get(), pp.get()));
1912
+ release();
859
1913
  }
860
1914
 
861
- factor(polynomial: Polynomial): Factors {
862
- const result: Factors = { constant: 1n, factors: [], degrees: [] };
863
- if (polynomial.size === 0) result.constant = 0n;
864
- else this.factorCore(polynomial, result);
1915
+ private squareFreeIn(polynomial: Polynomial, x: number, r: PolynomialRef) {
1916
+ if (this.isZero(polynomial)) {
1917
+ r.set(this.zero);
1918
+ return;
1919
+ }
1920
+ if (this.isConst(polynomial)) {
1921
+ r.set(polynomial);
1922
+ return;
1923
+ }
1924
+ const pPrime = new PolynomialRef(this);
1925
+ pPrime.set(this.derivative(polynomial, x));
1926
+ const g = new PolynomialRef(this);
1927
+ this.gcd(polynomial, pPrime.get(), g);
1928
+ if (this.isConst(g.get())) r.set(polynomial);
1929
+ else r.set(this.exactDiv(polynomial, g.get()));
1930
+ g.reset();
1931
+ pPrime.reset();
1932
+ }
1933
+
1934
+ private isSquareFreeIn(polynomial: Polynomial, x: number) {
1935
+ const r = new PolynomialRef(this);
1936
+ this.squareFreeIn(polynomial, x, r);
1937
+ const result = polynomial === r.get();
1938
+ r.reset();
865
1939
  return result;
866
1940
  }
867
1941
 
868
- private factorCore(polynomial: Polynomial, result: Factors) {
1942
+ pw(polynomial: Polynomial, k: number, r: PolynomialRef) {
1943
+ if (k === 0) {
1944
+ r.set(this.one);
1945
+ return;
1946
+ }
1947
+ if (k === 1) {
1948
+ r.set(polynomial);
1949
+ return;
1950
+ }
1951
+ const result = new PolynomialRef(this);
1952
+ result.set(polynomial);
1953
+ for (let index = 1; index < k; index++) result.set(this.mul(result.get(), polynomial));
1954
+ r.copy(result);
1955
+ result.reset();
1956
+ }
1957
+
1958
+ composeXDivY(polynomial: Polynomial, y: number) {
1959
+ if (this.isConst(polynomial)) return polynomial;
1960
+ const x = this.maxVar(polynomial);
1961
+ const n = this.degree(polynomial, x);
1962
+ for (let index = 0; index < polynomial.size; index++) {
1963
+ const k = polynomial.ms[index].degreeOf(x);
1964
+ const vars: number[] = [];
1965
+ const degrees: number[] = [];
1966
+ const push = (variable: number, degree: number) => {
1967
+ if (degree === 0) return;
1968
+ vars.push(variable);
1969
+ degrees.push(degree);
1970
+ };
1971
+ if (x < y) {
1972
+ push(x, k);
1973
+ push(y, n - k);
1974
+ } else {
1975
+ push(y, n - k);
1976
+ push(x, k);
1977
+ }
1978
+ this.cheap.add(polynomial.as[index], this.mkMonomial(vars, degrees));
1979
+ }
1980
+ return this.cheap.mk();
1981
+ }
1982
+
1983
+ private compose(polynomial: Polynomial, q: Polynomial, r: PolynomialRef) {
869
1984
  if (this.isConst(polynomial)) {
870
- result.constant *= polynomial.as[0];
1985
+ r.set(polynomial);
871
1986
  return;
872
1987
  }
873
- const variable = this.getMinDegreeVar(polynomial);
874
- const [integer, content, primitive] = this.iccp(polynomial, variable);
875
- result.constant *= integer;
876
- this.factorCore(content, result);
877
- let square = this.gcd(primitive, this.derivative(primitive, variable));
878
- if (this.isConst(square)) {
879
- this.factorSqfPp(primitive, variable, 1, result);
1988
+ const x = this.maxVar(polynomial);
1989
+ const d = this.degree(polynomial, x);
1990
+ const degree2pos = Array.from({ length: d + 1 }, () => -1);
1991
+ for (let index = 0; index < polynomial.size; index++)
1992
+ degree2pos[polynomial.ms[index].totalDegree] = index;
1993
+ r.set(this.mkConst(polynomial.as[degree2pos[d]]));
1994
+ for (let index = 1; index <= d; index++) {
1995
+ const position = degree2pos[d - index];
1996
+ r.set(this.muladd(q, r.get(), position === -1 ? 0n : polynomial.as[position]));
1997
+ }
1998
+ }
1999
+
2000
+ private mkXMinusY(x: number, y: number) {
2001
+ return this.mkLinear([1n, this.normalizeNumeral(-1n)], [x, y], 0n);
2002
+ }
2003
+
2004
+ composeXMinusY(polynomial: Polynomial, y: number, r: PolynomialRef) {
2005
+ const x = this.maxVar(polynomial);
2006
+ if (y === x) {
2007
+ r.set(this.coeff(polynomial, x, 0));
880
2008
  return;
881
2009
  }
882
- let product = this.exactDiv(primitive, square);
883
- for (let multiplicity = 1; !this.isConst(product); multiplicity++) {
884
- const next = this.gcd(product, square);
885
- const factor = this.exactDiv(product, next);
886
- if (!this.isConst(factor)) this.factorSqfPp(factor, variable, multiplicity, result);
887
- else if (factor.as[0] === -1n && multiplicity % 2 === 1) result.constant = -result.constant;
888
- square = this.exactDiv(square, next);
889
- product = next;
2010
+ const xMinusY = new PolynomialRef(this);
2011
+ xMinusY.set(this.mkXMinusY(x, y));
2012
+ this.compose(polynomial, xMinusY.get(), r);
2013
+ xMinusY.reset();
2014
+ }
2015
+
2016
+ private pseudoDivisionCore(
2017
+ p: Polynomial,
2018
+ q: Polynomial,
2019
+ x: number,
2020
+ isExact: boolean,
2021
+ isQuotient: boolean,
2022
+ quotient: PolynomialRef,
2023
+ remainder: PolynomialRef,
2024
+ ) {
2025
+ const a = p;
2026
+ const b = q;
2027
+ const degA = this.degree(a, x);
2028
+ const degB = this.degree(b, x);
2029
+ if (degB === 0) {
2030
+ remainder.set(this.zero);
2031
+ if (!isQuotient) return 0;
2032
+ if (!isExact) {
2033
+ quotient.set(a);
2034
+ return 1;
2035
+ }
2036
+ const d = degA + 1;
2037
+ if (d === 1) {
2038
+ quotient.set(a);
2039
+ return d;
2040
+ }
2041
+ const bdm1 = new PolynomialRef(this);
2042
+ this.pw(b, d - 1, bdm1);
2043
+ quotient.set(this.mul(a, bdm1.get()));
2044
+ bdm1.reset();
2045
+ return d;
2046
+ }
2047
+ if (degB > degA) {
2048
+ quotient.set(this.zero);
2049
+ remainder.set(a);
2050
+ }
2051
+ const lB = new PolynomialRef(this);
2052
+ const rB = new PolynomialRef(this);
2053
+ lB.set(this.coeffWithReduct(b, x, degB, rB));
2054
+ let d = 0;
2055
+ remainder.set(a);
2056
+ quotient.set(this.zero);
2057
+ while (true) {
2058
+ this.limit.checkpoint();
2059
+ const r = remainder.get();
2060
+ const degR = this.degree(r, x);
2061
+ if (degB > degR) {
2062
+ if (isExact) {
2063
+ const exactD = degA - degB + 1;
2064
+ if (d < exactD) {
2065
+ const lBE = new PolynomialRef(this);
2066
+ this.pw(lB.get(), exactD - d, lBE);
2067
+ if (isQuotient) quotient.set(this.mul(lBE.get(), quotient.get()));
2068
+ remainder.set(this.mul(lBE.get(), remainder.get()));
2069
+ lBE.reset();
2070
+ }
2071
+ }
2072
+ rB.reset();
2073
+ lB.reset();
2074
+ return d;
2075
+ }
2076
+ this.som.reset();
2077
+ this.som2.reset();
2078
+ for (let index = 0; index < r.size; index++) {
2079
+ if (r.size > 100 && index % 100 === 0) this.limit.checkpoint();
2080
+ const monomial = r.ms[index];
2081
+ const coeff = r.as[index];
2082
+ if (monomial.degreeOf(x) === degR) {
2083
+ const shifted = this.divXk(monomial, x, degB);
2084
+ if (isQuotient) this.som2.addTerm(coeff, shifted);
2085
+ this.som.addmul(this.negNumeral(coeff), shifted, rB.get());
2086
+ } else this.som.addmul(coeff, monomial, lB.get());
2087
+ }
2088
+ remainder.set(this.som.mk());
2089
+ if (isQuotient) {
2090
+ const current = quotient.get();
2091
+ for (let index = 0; index < current.size; index++)
2092
+ this.som2.addmul(current.as[index], current.ms[index], lB.get());
2093
+ quotient.set(this.som2.mk());
2094
+ }
2095
+ d++;
890
2096
  }
891
2097
  }
892
2098
 
893
- private factorSqfPp(polynomial: Polynomial, variable: number, k: number, result: Factors) {
894
- const degree = this.degree(polynomial, variable);
895
- if (degree === 1) this.pushFactor(result, polynomial, k);
896
- else if (this.isUnivariate(polynomial)) this.factorSqfPpUniv(polynomial, k, result);
897
- else if (degree === 2) this.factorQuadratic(polynomial, variable, k, result);
898
- else if (!this.factorMultivariate(polynomial, variable, k, result))
899
- this.pushFactor(result, polynomial, k);
2099
+ exactPseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
2100
+ const quotient = new PolynomialRef(this);
2101
+ this.pseudoDivisionCore(p, q, x, true, false, quotient, remainder);
2102
+ quotient.reset();
900
2103
  }
901
2104
 
902
- private pushFactor(result: Factors, polynomial: Polynomial, k: number) {
903
- result.factors.push(polynomial);
904
- result.degrees.push(k);
2105
+ pseudoRemainder(p: Polynomial, q: Polynomial, x: number, remainder: PolynomialRef) {
2106
+ const quotient = new PolynomialRef(this);
2107
+ const d = this.pseudoDivisionCore(p, q, x, false, false, quotient, remainder);
2108
+ quotient.reset();
2109
+ return d;
905
2110
  }
906
2111
 
907
- toCoeffs(polynomial: Polynomial) {
908
- const coeffs = Array.from({ length: this.totalDegree(polynomial) + 1 }, () => 0n);
909
- for (let index = 0; index < polynomial.size; index++)
910
- coeffs[polynomial.ms[index].totalDegree] = polynomial.as[index];
911
- return this.um.set(coeffs);
2112
+ exactPseudoDivision(
2113
+ p: Polynomial,
2114
+ q: Polynomial,
2115
+ x: number,
2116
+ quotient: PolynomialRef,
2117
+ remainder: PolynomialRef,
2118
+ ) {
2119
+ this.pseudoDivisionCore(p, q, x, true, true, quotient, remainder);
912
2120
  }
913
2121
 
914
- fromCoeffs(coeffs: readonly bigint[], variable: number) {
915
- for (let power = coeffs.length - 1; power >= 0; power--)
916
- this.cheap.add(coeffs[power], this.mkPower(variable, power));
917
- return this.cheap.mk();
2122
+ exactDiv(polynomial: Polynomial, divisor: Polynomial) {
2123
+ if (polynomial.size === 0) return polynomial;
2124
+ const remainder = this.som;
2125
+ const quotient = this.som2;
2126
+ remainder.reset();
2127
+ quotient.reset();
2128
+ remainder.add(polynomial);
2129
+ const maxPos = divisor.getGradedLexMaxPos();
2130
+ const divisorMonomial = divisor.ms[maxPos];
2131
+ const divisorCoeff = divisor.as[maxPos];
2132
+ while (true) {
2133
+ this.limit.checkpoint();
2134
+ const remainderPos = remainder.getGradedLexMaxPos();
2135
+ if (remainderPos === -1) {
2136
+ remainder.reset();
2137
+ return quotient.mk();
2138
+ }
2139
+ const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
2140
+ if (monomial === null) throw new SmtInvariantError("exact_div: the divisor does not divide");
2141
+ const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
2142
+ quotient.addTerm(coeff, monomial);
2143
+ remainder.addmul(this.negNumeral(coeff), monomial, divisor);
2144
+ }
918
2145
  }
919
2146
 
920
- private factorSqfPpUniv(polynomial: Polynomial, k: number, result: Factors) {
921
- const variable = this.maxVar(polynomial);
922
- const fs = mkFactors();
923
- factorSquareFree(this.um, this.toCoeffs(polynomial), fs, 1, DEFAULT_FACTOR_PARAMS);
924
- if (fs.factors.length === 1 && fs.degrees[0] === 1) {
925
- this.pushFactor(result, polynomial, k);
926
- return;
2147
+ private divides(divisor: Polynomial, polynomial: Polynomial) {
2148
+ if (polynomial.size === 0) return true;
2149
+ const remainder = this.som;
2150
+ this.som.reset();
2151
+ this.som2.reset();
2152
+ remainder.add(polynomial);
2153
+ const maxPos = divisor.getGradedLexMaxPos();
2154
+ const divisorMonomial = divisor.ms[maxPos];
2155
+ const divisorCoeff = divisor.as[maxPos];
2156
+ while (true) {
2157
+ this.limit.checkpoint();
2158
+ const remainderPos = remainder.getGradedLexMaxPos();
2159
+ if (remainderPos === -1) return true;
2160
+ const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
2161
+ if (monomial === null) return false;
2162
+ if (!this.dividesNumeral(divisorCoeff, remainder.as[remainderPos])) return false;
2163
+ const coeff = this.divNumeral(remainder.as[remainderPos], divisorCoeff);
2164
+ remainder.addmul(this.negNumeral(coeff), monomial, divisor);
927
2165
  }
928
- for (let index = 0; index < fs.factors.length; index++)
929
- this.pushFactor(result, this.fromCoeffs(fs.factors[index], variable), k * fs.degrees[index]);
930
- if (fs.constant === -1n && k % 2 === 1) result.constant = -result.constant;
931
2166
  }
932
2167
 
933
- private factorQuadratic(polynomial: Polynomial, variable: number, k: number, result: Factors) {
934
- let a = this.coeff(polynomial, variable, 2);
935
- let b = this.coeff(polynomial, variable, 1);
936
- let c = this.coeff(polynomial, variable, 0);
937
- const isFlipped = a.as[a.getGradedLexMaxPos()] < 0n;
938
- if (isFlipped) {
939
- a = this.neg(a);
940
- b = this.neg(b);
941
- c = this.neg(c);
2168
+ resultant(p: Polynomial, q: Polynomial, x: number, result: PolynomialRef) {
2169
+ const a = new PolynomialRef(this);
2170
+ const b = new PolynomialRef(this);
2171
+ a.set(p);
2172
+ b.set(q);
2173
+ if (this.isZero(a.get()) || this.isZero(b.get())) {
2174
+ result.set(this.zero);
2175
+ b.reset();
2176
+ a.reset();
2177
+ return;
2178
+ }
2179
+ if (this.isConst(a.get())) {
2180
+ if (this.isConst(b.get())) result.set(this.one);
2181
+ else this.pw(a.get(), this.degree(b.get(), x), result);
2182
+ b.reset();
2183
+ a.reset();
2184
+ return;
942
2185
  }
943
- const root = this.sqrt(this.addmul(1n, this.mul(b, b), -4n, this.mul(a, c)));
944
- if (root === null) {
945
- this.pushFactor(result, polynomial, k);
2186
+ if (this.isConst(b.get())) {
2187
+ this.pw(b.get(), this.degree(a.get(), x), result);
2188
+ b.reset();
2189
+ a.reset();
946
2190
  return;
947
2191
  }
948
- if (isFlipped && k % 2 === 1) result.constant = -result.constant;
949
- const linear = this.add(this.mulTerm(2n, this.mkPower(variable, 1), a), b);
950
- this.pushFactor(result, this.pp(this.sub(linear, root), variable), k);
951
- this.pushFactor(result, this.pp(this.add(linear, root), variable), k);
2192
+ const cA = new PolynomialRef(this);
2193
+ const cB = new PolynomialRef(this);
2194
+ const ppA = new PolynomialRef(this);
2195
+ const ppB = new PolynomialRef(this);
2196
+ const iA = this.iccp(a.get(), x, cA, ppA);
2197
+ const iB = this.iccp(b.get(), x, cB, ppB);
2198
+ cA.set(this.mulConst(iA, cA.get()));
2199
+ cB.set(this.mulConst(iB, cB.get()));
2200
+ const t = new PolynomialRef(this);
2201
+ this.pw(cA.get(), this.degree(b.get(), x), cA);
2202
+ this.pw(cB.get(), this.degree(a.get(), x), cB);
2203
+ t.set(this.mul(cA.get(), cB.get()));
2204
+ a.copy(ppA);
2205
+ b.copy(ppB);
2206
+ let s = 1;
2207
+ let degA = this.degree(a.get(), x);
2208
+ let degB = this.degree(b.get(), x);
2209
+ if (degA < degB) {
2210
+ a.swap(b);
2211
+ if (degA % 2 === 1 && degB % 2 === 1) s = -1;
2212
+ }
2213
+ const remainder = new PolynomialRef(this);
2214
+ const g = new PolynomialRef(this);
2215
+ const h = new PolynomialRef(this);
2216
+ const newH = new PolynomialRef(this);
2217
+ g.set(this.one);
2218
+ h.set(this.one);
2219
+ while (true) {
2220
+ this.limit.checkpoint();
2221
+ degA = this.degree(a.get(), x);
2222
+ degB = this.degree(b.get(), x);
2223
+ const delta = degA - degB;
2224
+ if (degA % 2 === 1 && degB % 2 === 1) s = -s;
2225
+ this.exactPseudoRemainder(a.get(), b.get(), x, remainder);
2226
+ a.copy(b);
2227
+ b.set(this.exactDiv(remainder.get(), g.get()));
2228
+ for (let index = 0; index < delta; index++) b.set(this.exactDiv(b.get(), h.get()));
2229
+ g.set(this.lc(a.get(), x));
2230
+ newH.set(this.one);
2231
+ this.pw(g.get(), delta, newH);
2232
+ if (delta > 1)
2233
+ for (let index = 0; index < delta - 1; index++)
2234
+ newH.set(this.exactDiv(newH.get(), h.get()));
2235
+ h.copy(newH);
2236
+ if (this.degree(b.get(), x) === 0) {
2237
+ const lastDegA = this.degree(a.get(), x);
2238
+ newH.set(this.lc(b.get(), x));
2239
+ this.pw(newH.get(), lastDegA, newH);
2240
+ if (lastDegA > 1)
2241
+ for (let index = 0; index < lastDegA - 1; index++)
2242
+ newH.set(this.exactDiv(newH.get(), h.get()));
2243
+ h.copy(newH);
2244
+ result.set(this.mul(t.get(), h.get()));
2245
+ if (s < 0) result.set(this.neg(result.get()));
2246
+ newH.reset();
2247
+ h.reset();
2248
+ g.reset();
2249
+ remainder.reset();
2250
+ t.reset();
2251
+ ppB.reset();
2252
+ ppA.reset();
2253
+ cB.reset();
2254
+ cA.reset();
2255
+ b.reset();
2256
+ a.reset();
2257
+ return;
2258
+ }
2259
+ }
2260
+ }
2261
+
2262
+ private seLazard(d: number, lcSd: Polynomial, sd1: Polynomial, x: number, se: PolynomialRef) {
2263
+ let n = d - this.degree(sd1, x) - 1;
2264
+ if (n === 0) {
2265
+ se.set(sd1);
2266
+ return;
2267
+ }
2268
+ const xLc = new PolynomialRef(this);
2269
+ xLc.set(this.lc(sd1, x));
2270
+ const y = lcSd;
2271
+ let a = 1 << (31 - Math.clz32(n));
2272
+ const c = new PolynomialRef(this);
2273
+ c.copy(xLc);
2274
+ n -= a;
2275
+ while (a !== 1) {
2276
+ a /= 2;
2277
+ c.set(this.mul(c.get(), c.get()));
2278
+ c.set(this.exactDiv(c.get(), y));
2279
+ if (n >= a) {
2280
+ c.set(this.mul(c.get(), xLc.get()));
2281
+ c.set(this.exactDiv(c.get(), y));
2282
+ n -= a;
2283
+ }
2284
+ }
2285
+ se.set(this.mul(c.get(), sd1));
2286
+ se.set(this.exactDiv(se.get(), y));
2287
+ c.reset();
2288
+ xLc.reset();
2289
+ }
2290
+
2291
+ private optimizedSe1(
2292
+ d: number,
2293
+ e: number,
2294
+ a: Polynomial,
2295
+ sd1: Polynomial,
2296
+ se: Polynomial,
2297
+ s: Polynomial,
2298
+ x: number,
2299
+ se1: PolynomialRef,
2300
+ ) {
2301
+ const cD1 = new PolynomialRef(this);
2302
+ const sE = new PolynomialRef(this);
2303
+ const xJ = new PolynomialRef(this);
2304
+ const tmp = new PolynomialRef(this);
2305
+ cD1.set(this.lc(sd1, x));
2306
+ sE.set(this.lc(se, x));
2307
+ const h = new PolynomialRefVector(this);
2308
+ xJ.set(this.one);
2309
+ for (let j = 0; j <= e - 1; j++) {
2310
+ xJ.set(this.mkVar(x, j));
2311
+ h.push(this.mul(sE.get(), xJ.get()));
2312
+ }
2313
+ xJ.set(this.mkVar(x, e));
2314
+ xJ.set(this.mul(sE.get(), xJ.get()));
2315
+ h.push(this.sub(xJ.get(), se));
2316
+ const xPol = new PolynomialRef(this);
2317
+ const xH = new PolynomialRef(this);
2318
+ const xHe = new PolynomialRef(this);
2319
+ xPol.set(this.mkVar(x, 1));
2320
+ for (let j = e + 1; j <= d - 1; j++) {
2321
+ xH.set(this.mul(xPol.get(), h.get(j - 1)));
2322
+ xHe.set(this.coeff(xH.get(), x, e));
2323
+ tmp.set(this.mul(xHe.get(), sd1));
2324
+ tmp.set(this.exactDiv(tmp.get(), cD1.get()));
2325
+ h.push(this.sub(xH.get(), tmp.get()));
2326
+ }
2327
+ const dPolynomial = new PolynomialRef(this);
2328
+ dPolynomial.set(this.zero);
2329
+ for (let j = 0; j < d; j++) {
2330
+ tmp.set(this.coeff(a, x, j));
2331
+ tmp.set(this.mul(tmp.get(), h.get(j)));
2332
+ dPolynomial.set(this.add(dPolynomial.get(), tmp.get()));
2333
+ }
2334
+ const lcA = new PolynomialRef(this);
2335
+ lcA.set(this.lc(a, x));
2336
+ dPolynomial.set(this.exactDiv(dPolynomial.get(), lcA.get()));
2337
+ xH.set(this.mul(xPol.get(), h.get(d - 1)));
2338
+ xHe.set(this.coeff(xH.get(), x, e));
2339
+ xHe.set(this.mul(xHe.get(), sd1));
2340
+ se1.set(this.add(xH.get(), dPolynomial.get()));
2341
+ se1.set(this.mul(cD1.get(), se1.get()));
2342
+ se1.set(this.sub(se1.get(), xHe.get()));
2343
+ se1.set(this.exactDiv(se1.get(), s));
2344
+ if ((d - e + 1) % 2 === 1) se1.set(this.neg(se1.get()));
2345
+ lcA.reset();
2346
+ dPolynomial.reset();
2347
+ xHe.reset();
2348
+ xH.reset();
2349
+ xPol.reset();
2350
+ h.reset();
2351
+ tmp.reset();
2352
+ xJ.reset();
2353
+ sE.reset();
2354
+ cD1.reset();
2355
+ }
2356
+
2357
+ private pscChainOptimizedCore(
2358
+ p: Polynomial,
2359
+ q: Polynomial,
2360
+ x: number,
2361
+ chain: PolynomialRefVector,
2362
+ ) {
2363
+ const degP = this.degree(p, x);
2364
+ const degQ = this.degree(q, x);
2365
+ const a = new PolynomialRef(this);
2366
+ const b = new PolynomialRef(this);
2367
+ const c = new PolynomialRef(this);
2368
+ const minusQ = new PolynomialRef(this);
2369
+ const lcQ = new PolynomialRef(this);
2370
+ const ps = new PolynomialRef(this);
2371
+ lcQ.set(this.lc(q, x));
2372
+ const s = new PolynomialRef(this);
2373
+ const release = () => {
2374
+ s.reset();
2375
+ ps.reset();
2376
+ lcQ.reset();
2377
+ minusQ.reset();
2378
+ c.reset();
2379
+ b.reset();
2380
+ a.reset();
2381
+ };
2382
+ this.pw(lcQ.get(), degP - degQ, s);
2383
+ minusQ.set(this.neg(q));
2384
+ a.set(q);
2385
+ this.exactPseudoRemainder(p, minusQ.get(), x, b);
2386
+ while (true) {
2387
+ const d = this.degree(a.get(), x);
2388
+ const e = this.degree(b.get(), x);
2389
+ if (this.isZero(b.get())) {
2390
+ release();
2391
+ return;
2392
+ }
2393
+ ps.set(this.coeff(b.get(), x, d - 1));
2394
+ if (!this.isZero(ps.get())) chain.push(ps.get());
2395
+ const delta = d - e;
2396
+ if (delta > 1) {
2397
+ this.seLazard(d, s.get(), b.get(), x, c);
2398
+ ps.set(this.coeff(c.get(), x, e));
2399
+ if (!this.isZero(ps.get())) chain.push(ps.get());
2400
+ } else c.copy(b);
2401
+ if (e === 0) {
2402
+ release();
2403
+ return;
2404
+ }
2405
+ this.optimizedSe1(d, e, a.get(), b.get(), c.get(), s.get(), x, b);
2406
+ a.copy(c);
2407
+ s.set(this.lc(a.get(), x));
2408
+ }
2409
+ }
2410
+
2411
+ pscChain(p: Polynomial, q: Polynomial, x: number, chain: PolynomialRefVector) {
2412
+ chain.reset();
2413
+ if (this.degree(p, x) >= this.degree(q, x)) this.pscChainOptimizedCore(p, q, x, chain);
2414
+ else this.pscChainOptimizedCore(q, p, x, chain);
2415
+ if (chain.size === 0) chain.push(this.zero);
2416
+ chain.items.reverse();
2417
+ }
2418
+
2419
+ normalize(polynomial: Polynomial) {
2420
+ if (polynomial.size === 0) return polynomial;
2421
+ const modulus = this.modulus;
2422
+ if (modulus !== null) {
2423
+ let index = 0;
2424
+ for (; index < polynomial.size; index++)
2425
+ if (normalizeZp(polynomial.as[index], modulus) !== polynomial.as[index]) break;
2426
+ if (index < polynomial.size) {
2427
+ this.cheap.reset();
2428
+ for (let other = 0; other < polynomial.size; other++)
2429
+ this.cheap.addReset(normalizeZp(polynomial.as[other], modulus), polynomial.ms[other]);
2430
+ this.cheap.normalize();
2431
+ return this.cheap.mk();
2432
+ }
2433
+ }
2434
+ const g = this.gcdNumerals(polynomial.as);
2435
+ if (g === 1n) return polynomial;
2436
+ this.cheap.reset();
2437
+ for (let index = 0; index < polynomial.size; index++)
2438
+ this.cheap.addReset(this.divNumeral(polynomial.as[index], g), polynomial.ms[index]);
2439
+ return this.cheap.mk();
952
2440
  }
953
2441
 
954
2442
  private getTermSquareRoot(polynomial: Polynomial, position: number) {
955
- const monomial = polynomial.ms[position];
956
- if (monomial.degrees.some((degree) => degree % 2 === 1)) return null;
2443
+ if (!polynomial.ms[position].isSquare()) return null;
957
2444
  return getExactSquareRoot(polynomial.as[position]);
958
2445
  }
959
2446
 
960
- sqrt(polynomial: Polynomial) {
961
- if (polynomial.size === 0) return polynomial;
962
- if (this.getTermSquareRoot(polynomial, this.getGradedLexMinPos(polynomial)) === null)
963
- return null;
2447
+ sqrt(polynomial: Polynomial, r: PolynomialRef) {
2448
+ if (polynomial.size === 0) {
2449
+ r.set(polynomial);
2450
+ return true;
2451
+ }
2452
+ if (this.getTermSquareRoot(polynomial, polynomial.getGradedLexMinPos()) === null) return false;
964
2453
  const maxPos = polynomial.getGradedLexMaxPos();
965
2454
  const a = this.getTermSquareRoot(polynomial, maxPos);
966
- if (a === null) return null;
967
- const maxMonomial = polynomial.ms[maxPos];
968
- const m1 = this.mkMonomial(
969
- maxMonomial.vars,
970
- maxMonomial.degrees.map((degree) => degree / 2),
971
- );
2455
+ if (a === null) return false;
2456
+ const m1 = this.sqrtMonomial(polynomial.ms[maxPos]);
972
2457
  const root = this.som;
973
2458
  const rest = this.som2;
974
2459
  root.reset();
975
2460
  rest.reset();
976
- const twoA = 2n * a;
2461
+ const twoA = a * 2n;
977
2462
  root.addTerm(a, m1);
978
2463
  for (let index = 0; index < polynomial.size; index++)
979
2464
  if (index !== maxPos) rest.addTerm(polynomial.as[index], polynomial.ms[index]);
980
2465
  while (true) {
2466
+ this.limit.checkpoint();
981
2467
  const restMax = rest.getGradedLexMaxPos();
982
2468
  if (restMax === -1) {
2469
+ r.set(root.mk());
983
2470
  rest.reset();
984
- return root.mk();
2471
+ return true;
985
2472
  }
986
2473
  const monomial = this.divMonomials(rest.ms[restMax], m1);
987
- if (monomial === null || rest.as[restMax] % twoA !== 0n) {
988
- root.reset();
2474
+ if (monomial === null || !this.dividesNumeral(twoA, rest.as[restMax])) {
989
2475
  rest.reset();
990
- return null;
2476
+ root.reset();
2477
+ return false;
991
2478
  }
992
- const coeff = floorDiv(rest.as[restMax], twoA);
2479
+ const coeff = this.divNumeral(rest.as[restMax], twoA);
993
2480
  const rootSize = root.as.length;
994
2481
  for (let index = 0; index < rootSize; index++) {
995
2482
  if (root.as[index] === 0n) continue;
@@ -1000,13 +2487,6 @@ export class PolynomialManager {
1000
2487
  }
1001
2488
  }
1002
2489
 
1003
- private getGradedLexMinPos(polynomial: Polynomial) {
1004
- let minPos = 0;
1005
- for (let index = 1; index < polynomial.size; index++)
1006
- if (gradedLexCompare(polynomial.ms[index], polynomial.ms[minPos]) < 0) minPos = index;
1007
- return minPos;
1008
- }
1009
-
1010
2490
  getVars(polynomial: Polynomial) {
1011
2491
  const vars: number[] = [];
1012
2492
  for (const monomial of polynomial.ms)
@@ -1014,11 +2494,22 @@ export class PolynomialManager {
1014
2494
  return vars;
1015
2495
  }
1016
2496
 
2497
+ private getMaxDegrees(polynomial: Polynomial) {
2498
+ const degrees = new Map<number, number>();
2499
+ for (const monomial of polynomial.ms)
2500
+ for (let index = 0; index < monomial.size; index++) {
2501
+ const variable = monomial.vars[index];
2502
+ if (monomial.degrees[index] > (degrees.get(variable) ?? 0))
2503
+ degrees.set(variable, monomial.degrees[index]);
2504
+ }
2505
+ return degrees;
2506
+ }
2507
+
1017
2508
  substitute(polynomial: Polynomial, vars: readonly number[], values: readonly bigint[]) {
1018
2509
  this.som.reset();
1019
2510
  for (let index = 0; index < polynomial.size; index++) {
1020
2511
  const monomial = polynomial.ms[index];
1021
- let coeff = polynomial.as[index];
2512
+ let coeff = this.normalizeNumeral(polynomial.as[index]);
1022
2513
  const keptVars: number[] = [];
1023
2514
  const keptDegrees: number[] = [];
1024
2515
  for (let power = 0; power < monomial.size; power++) {
@@ -1026,7 +2517,11 @@ export class PolynomialManager {
1026
2517
  if (position === -1) {
1027
2518
  keptVars.push(monomial.vars[power]);
1028
2519
  keptDegrees.push(monomial.degrees[power]);
1029
- } else coeff *= values[position] ** BigInt(monomial.degrees[power]);
2520
+ } else
2521
+ coeff = this.mulNumeral(
2522
+ this.powerNumeral(values[position], monomial.degrees[power]),
2523
+ coeff,
2524
+ );
1030
2525
  }
1031
2526
  this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
1032
2527
  }
@@ -1044,9 +2539,11 @@ export class PolynomialManager {
1044
2539
  this.divX(monomial, variable),
1045
2540
  );
1046
2541
  }
1047
- for (let step = 1; step <= degree; step++)
2542
+ for (let step = 1; step <= degree; step++) {
2543
+ this.limit.checkpoint();
1048
2544
  for (let power = degree - step; power <= degree - 1; power++)
1049
2545
  coeffs[power].addmulBuffer(value, this.unit, coeffs[power + 1]);
2546
+ }
1050
2547
  this.som.reset();
1051
2548
  for (let power = 0; power <= degree; power++)
1052
2549
  this.som.addmulBuffer(1n, this.mkPower(variable, power), coeffs[power]);
@@ -1081,377 +2578,538 @@ export class PolynomialManager {
1081
2578
  if (value !== undefined && monomial.degreeOf(variable) === 0)
1082
2579
  coeff *= value.den ** BigInt(maxDegree);
1083
2580
  }
1084
- this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
2581
+ if (coeff !== 0n) this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
1085
2582
  }
1086
2583
  return this.som.mk(true);
1087
2584
  }
1088
2585
 
1089
- private muladd(first: Polynomial, second: Polynomial, constant: bigint) {
1090
- if (first.size === 0 || second.size === 0) return this.mkConst(constant);
1091
- this.som.reset();
1092
- for (let index = 0; index < first.size; index++)
1093
- this.som.addmul(first.as[index], first.ms[index], second);
1094
- this.som.addTerm(constant, this.unit);
1095
- return this.som.mk();
2586
+ private mkGlexMonic(polynomial: Polynomial) {
2587
+ if (polynomial.size === 0) return polynomial;
2588
+ const position = polynomial.getGradedLexMaxPos();
2589
+ if (polynomial.as[position] === 1n) return polynomial;
2590
+ const inverse = this.invNumeral(polynomial.as[position]);
2591
+ this.cheap.reset();
2592
+ for (let index = 0; index < polynomial.size; index++)
2593
+ this.cheap.add(this.mulNumeral(polynomial.as[index], inverse), polynomial.ms[index]);
2594
+ return this.cheap.mk();
1096
2595
  }
1097
2596
 
1098
- private compose(polynomial: Polynomial, inner: Polynomial) {
1099
- if (this.isConst(polynomial)) return polynomial;
1100
- const variable = this.maxVar(polynomial);
1101
- const degree = this.degree(polynomial, variable);
1102
- const coeffs = Array.from({ length: degree + 1 }, () => 0n);
1103
- for (let index = 0; index < polynomial.size; index++)
1104
- coeffs[polynomial.ms[index].degreeOf(variable)] = polynomial.as[index];
1105
- let result = this.mkConst(coeffs[degree]);
1106
- for (let power = degree - 1; power >= 0; power--)
1107
- result = this.muladd(inner, result, coeffs[power]);
2597
+ private getMinDegreeVar(polynomial: Polynomial) {
2598
+ let result = NULL_VAR;
2599
+ let minDegree = Infinity;
2600
+ for (const [variable, degree] of this.getMaxDegrees(polynomial))
2601
+ if (degree < minDegree) {
2602
+ result = variable;
2603
+ minDegree = degree;
2604
+ }
1108
2605
  return result;
1109
2606
  }
1110
2607
 
1111
- composeXMinusY(polynomial: Polynomial, variable: number) {
1112
- const x = this.maxVar(polynomial);
1113
- if (variable === x) return this.coeff(polynomial, x, 0);
1114
- return this.compose(polynomial, this.mkLinear([1n, -1n], [x, variable], 0n));
2608
+ toCoeffs(polynomial: Polynomial) {
2609
+ // Z3's to_numeral_vector builds normalize(p) and drops it, which takes and frees an id.
2610
+ const normalized = this.normalize(polynomial);
2611
+ if (normalized !== polynomial) {
2612
+ this.incRef(normalized);
2613
+ this.decRef(normalized);
2614
+ }
2615
+ const coeffs = Array.from({ length: this.totalDegree(polynomial) + 1 }, () => 0n);
2616
+ for (let index = 0; index < polynomial.size; index++)
2617
+ coeffs[polynomial.ms[index].totalDegree] = polynomial.as[index];
2618
+ return this.um.set(coeffs);
1115
2619
  }
1116
2620
 
1117
- composeXDivY(polynomial: Polynomial, variable: number) {
1118
- if (this.isConst(polynomial)) return polynomial;
1119
- const x = this.maxVar(polynomial);
1120
- const degree = this.degree(polynomial, x);
1121
- for (let index = 0; index < polynomial.size; index++) {
1122
- const power = polynomial.ms[index].degreeOf(x);
1123
- const powers: [number, number][] =
1124
- x < variable
1125
- ? [
1126
- [x, power],
1127
- [variable, degree - power],
1128
- ]
1129
- : [
1130
- [variable, degree - power],
1131
- [x, power],
1132
- ];
1133
- const kept = powers.filter((entry) => entry[1] > 0);
1134
- this.cheap.add(
1135
- polynomial.as[index],
1136
- this.mkMonomial(
1137
- kept.map((entry) => entry[0]),
1138
- kept.map((entry) => entry[1]),
1139
- ),
1140
- );
2621
+ factor(polynomial: Polynomial, r: Factors) {
2622
+ if (polynomial.size === 0) {
2623
+ r.constant = 0n;
2624
+ return;
1141
2625
  }
1142
- return this.cheap.mk();
2626
+ this.factorCore(polynomial, r);
1143
2627
  }
1144
2628
 
1145
- resultant(first: Polynomial, second: Polynomial, variable: number) {
1146
- if (first.size === 0 || second.size === 0) return this.zero;
1147
- if (this.isConst(first))
1148
- return this.isConst(second) ? this.one : this.pw(first, this.degree(second, variable));
1149
- if (this.isConst(second)) return this.pw(second, this.degree(first, variable));
1150
- const [integerA, contentA, ppA] = this.iccp(first, variable);
1151
- const [integerB, contentB, ppB] = this.iccp(second, variable);
1152
- const scale = this.mul(
1153
- this.pw(this.mulConst(integerA, contentA), this.degree(second, variable)),
1154
- this.pw(this.mulConst(integerB, contentB), this.degree(first, variable)),
1155
- );
1156
- let a = ppA;
1157
- let b = ppB;
1158
- let sign = 1;
1159
- if (this.degree(a, variable) < this.degree(b, variable)) {
1160
- if (this.degree(a, variable) % 2 === 1 && this.degree(b, variable) % 2 === 1) sign = -1;
1161
- [a, b] = [b, a];
1162
- }
1163
- let g = this.one;
1164
- let h = this.one;
1165
- while (true) {
1166
- const degreeA = this.degree(a, variable);
1167
- const degreeB = this.degree(b, variable);
1168
- const delta = degreeA - degreeB;
1169
- if (degreeA % 2 === 1 && degreeB % 2 === 1) sign = -sign;
1170
- const remainder = this.exactPseudoRemainder(a, b, variable);
1171
- a = b;
1172
- b = this.exactDiv(remainder, g);
1173
- for (let index = 0; index < delta; index++) b = this.exactDiv(b, h);
1174
- g = this.lc(a, variable);
1175
- let nextH = this.pw(g, delta);
1176
- for (let index = 1; index < delta; index++) nextH = this.exactDiv(nextH, h);
1177
- h = nextH;
1178
- if (this.degree(b, variable) === 0) {
1179
- const degree = this.degree(a, variable);
1180
- let lastH = this.pw(this.lc(b, variable), degree);
1181
- for (let index = 1; index < degree; index++) lastH = this.exactDiv(lastH, h);
1182
- const result = this.mul(scale, lastH);
1183
- return sign < 0 ? this.neg(result) : result;
2629
+ private factorCore(polynomial: Polynomial, r: Factors) {
2630
+ if (this.isConst(polynomial)) {
2631
+ r.constant *= polynomial.as[0];
2632
+ return;
2633
+ }
2634
+ const x = this.getMinDegreeVar(polynomial);
2635
+ const c = new PolynomialRef(this);
2636
+ const pp = new PolynomialRef(this);
2637
+ const integer = this.iccp(polynomial, x, c, pp);
2638
+ r.constant *= integer;
2639
+ this.factorCore(c.get(), r);
2640
+ const cPart = new PolynomialRef(this);
2641
+ cPart.copy(pp);
2642
+ const cPrime = new PolynomialRef(this);
2643
+ cPrime.set(this.derivative(cPart.get(), x));
2644
+ const b = new PolynomialRef(this);
2645
+ const a = new PolynomialRef(this);
2646
+ const d = new PolynomialRef(this);
2647
+ this.gcd(cPart.get(), cPrime.get(), b);
2648
+ if (this.isConst(b.get())) this.factorSqfPp(cPart.get(), r, x, 1);
2649
+ else {
2650
+ a.set(this.exactDiv(cPart.get(), b.get()));
2651
+ for (let j = 1; !this.isConst(a.get()); j++) {
2652
+ this.limit.checkpoint();
2653
+ this.gcd(a.get(), b.get(), d);
2654
+ cPart.set(this.exactDiv(a.get(), d.get()));
2655
+ if (!this.isConst(cPart.get())) this.factorSqfPp(cPart.get(), r, x, j);
2656
+ else if (cPart.get().as[0] === -1n && j % 2 === 1) r.constant = -r.constant;
2657
+ b.set(this.exactDiv(b.get(), d.get()));
2658
+ a.copy(d);
1184
2659
  }
1185
2660
  }
2661
+ d.reset();
2662
+ a.reset();
2663
+ b.reset();
2664
+ cPrime.reset();
2665
+ cPart.reset();
2666
+ pp.reset();
2667
+ c.reset();
1186
2668
  }
1187
2669
 
1188
- private isSquareFreeIn(polynomial: Polynomial, variable: number) {
1189
- if (this.isConst(polynomial)) return polynomial.size > 0;
1190
- return this.isConst(this.gcd(polynomial, this.derivative(polynomial, variable)));
2670
+ private factorSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
2671
+ const degree = this.degree(polynomial, x);
2672
+ if (degree === 1) r.push(polynomial, k);
2673
+ else if (this.isUnivariate(polynomial)) this.factorSqfPpUniv(polynomial, r, k);
2674
+ else if (degree === 2) this.factor2SqfPp(polynomial, r, x, k);
2675
+ else this.factorNSqfPp(polynomial, r, x, k);
2676
+ }
2677
+
2678
+ private factor2SqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
2679
+ const a = new PolynomialRef(this);
2680
+ const b = new PolynomialRef(this);
2681
+ const c = new PolynomialRef(this);
2682
+ a.set(this.coeff(polynomial, x, 2));
2683
+ b.set(this.coeff(polynomial, x, 1));
2684
+ c.set(this.coeff(polynomial, x, 0));
2685
+ let isFlipped = false;
2686
+ if (a.get().as[a.get().getGradedLexMaxPos()] < 0n) {
2687
+ a.set(this.neg(a.get()));
2688
+ b.set(this.neg(b.get()));
2689
+ c.set(this.neg(c.get()));
2690
+ isFlipped = true;
2691
+ }
2692
+ const b2 = new PolynomialRef(this);
2693
+ b2.set(this.mul(b.get(), b.get()));
2694
+ const ac = new PolynomialRef(this);
2695
+ ac.set(this.mul(a.get(), c.get()));
2696
+ const disc = new PolynomialRef(this);
2697
+ disc.set(this.addmul(b2.get(), -4n, ac.get()));
2698
+ const discSqrt = new PolynomialRef(this);
2699
+ const f1 = new PolynomialRef(this);
2700
+ const f2 = new PolynomialRef(this);
2701
+ const twoAx = new PolynomialRef(this);
2702
+ if (!this.sqrt(disc.get(), discSqrt)) r.push(polynomial, k);
2703
+ else {
2704
+ if (isFlipped && k % 2 === 1) r.constant = -r.constant;
2705
+ twoAx.set(this.mulTerm(2n, this.mkPower(x, 1), a.get()));
2706
+ f1.set(this.add(twoAx.get(), b.get()));
2707
+ f2.copy(f1);
2708
+ f1.set(this.sub(f1.get(), discSqrt.get()));
2709
+ f2.set(this.add(f2.get(), discSqrt.get()));
2710
+ f1.move(this.pp(f1.get(), x));
2711
+ f2.move(this.pp(f2.get(), x));
2712
+ r.push(f1.get(), k);
2713
+ r.push(f2.get(), k);
2714
+ }
2715
+ twoAx.reset();
2716
+ f2.reset();
2717
+ f1.reset();
2718
+ discSqrt.reset();
2719
+ disc.reset();
2720
+ ac.reset();
2721
+ b2.reset();
2722
+ c.reset();
2723
+ b.reset();
2724
+ a.reset();
2725
+ }
2726
+
2727
+ private factorSqfPpUniv(polynomial: Polynomial, r: Factors, k: number) {
2728
+ const x = this.maxVar(polynomial);
2729
+ const pRef = new PolynomialRef(this);
2730
+ pRef.set(polynomial);
2731
+ const fs = mkFactors();
2732
+ factorSquareFree(this.um, this.toCoeffs(polynomial), fs, 1, DEFAULT_FACTOR_PARAMS);
2733
+ if (fs.factors.length === 1 && fs.degrees[0] === 1) r.push(polynomial, k);
2734
+ else {
2735
+ const f = new PolynomialRef(this);
2736
+ for (let index = 0; index < fs.factors.length; index++) {
2737
+ f.set(this.toPolynomial(fs.factors[index], x));
2738
+ r.push(f.get(), k * fs.degrees[index]);
2739
+ }
2740
+ if (fs.constant === -1n && k % 2 === 1) r.constant = -r.constant;
2741
+ f.reset();
2742
+ }
2743
+ pRef.reset();
2744
+ }
2745
+
2746
+ private factorNSqfPp(polynomial: Polynomial, r: Factors, x: number, k: number) {
2747
+ if (this.isUnivariate(polynomial)) {
2748
+ this.factorSqfPpUniv(polynomial, r, k);
2749
+ return;
2750
+ }
2751
+ if (this.tryMultivarFactor(polynomial, r, x, k)) return;
2752
+ r.push(polynomial, k);
1191
2753
  }
1192
2754
 
1193
- private isPrimitive(polynomial: Polynomial, variable: number) {
1194
- return this.eq(polynomial, this.pp(polynomial, variable));
2755
+ private pushSmallFactor(part: PolynomialRef, r: Factors, x: number, k: number) {
2756
+ const d = this.degree(part.get(), x);
2757
+ if (d === 1) r.push(part.get(), k);
2758
+ else if (d === 2 && this.isPrimitive(part.get(), x) && this.isSquareFreeIn(part.get(), x))
2759
+ this.factor2SqfPp(part.get(), r, x, k);
2760
+ else r.push(part.get(), k);
1195
2761
  }
1196
2762
 
1197
- private factorMultivariate(polynomial: Polynomial, x: number, k: number, result: Factors) {
2763
+ private tryMultivarFactor(polynomial: Polynomial, r: Factors, x: number, k: number) {
1198
2764
  const allVars = this.getVars(polynomial);
1199
- const mainVars = [
1200
- x,
1201
- ...allVars
1202
- .filter((variable) => variable !== x)
1203
- .map((variable) => [this.degree(polynomial, variable), variable])
1204
- .sort((first, second) => second[0] - first[0] || second[1] - first[1])
1205
- .filter((entry) => entry[0] > 1)
1206
- .map((entry) => entry[1]),
1207
- ];
2765
+ const mainVars = [x];
2766
+ const varsByDegree: [number, number][] = [];
2767
+ for (const variable of allVars)
2768
+ if (variable !== x) varsByDegree.push([this.degree(polynomial, variable), variable]);
2769
+ varsByDegree.sort((first, second) => second[0] - first[0] || second[1] - first[1]);
2770
+ for (const [degree, variable] of varsByDegree) if (degree > 1) mainVars.push(variable);
1208
2771
  for (const mainVar of mainVars) {
1209
2772
  const degMain = this.degree(polynomial, mainVar);
1210
2773
  if (degMain <= 1) continue;
1211
2774
  for (const liftVar of allVars) {
1212
2775
  if (liftVar === mainVar) continue;
1213
- const evalVars = allVars.filter((variable) => variable !== mainVar && variable !== liftVar);
1214
- const maxCombos = evalVars.length === 0 ? 1 : 5;
2776
+ this.limit.checkpoint();
2777
+ const evalVars: number[] = [];
2778
+ for (const variable of allVars)
2779
+ if (variable !== mainVar && variable !== liftVar) evalVars.push(variable);
2780
+ const nEval = evalVars.length;
2781
+ const maxCombos = nEval === 0 ? 1 : Math.min(FACTOR_EVAL_VALUES.length, 5);
1215
2782
  for (let combo = 0; combo < maxCombos; combo++) {
1216
- const bivariate =
1217
- evalVars.length === 0
1218
- ? polynomial
1219
- : this.substitute(
1220
- polynomial,
1221
- evalVars,
1222
- evalVars.map(
1223
- (_variable, index) =>
1224
- FACTOR_EVAL_VALUES[
1225
- Math.floor(combo / FACTOR_EVAL_VALUES.length ** index) %
1226
- FACTOR_EVAL_VALUES.length
1227
- ],
1228
- ),
1229
- );
1230
- if (this.degree(bivariate, mainVar) !== degMain) continue;
1231
- const degLift = this.degree(bivariate, liftVar);
1232
- if (degLift === 0) continue;
1233
- for (const point of FACTOR_EVAL_VALUES) {
1234
- const univariate = this.substitute(bivariate, [liftVar], [point]);
1235
- if (!this.isUnivariate(univariate)) continue;
1236
- if (this.degree(univariate, mainVar) !== degMain) continue;
1237
- if (!this.isSquareFreeIn(univariate, mainVar)) continue;
1238
- const univariateFs = mkFactors();
1239
- factorSquareFree(
1240
- this.um,
1241
- this.um.getPrimitive(this.toCoeffs(univariate)),
1242
- univariateFs,
1243
- 1,
1244
- DEFAULT_FACTOR_PARAMS,
1245
- );
1246
- const factorCount = univariateFs.factors.length;
1247
- if (factorCount <= 1) continue;
1248
- const translated = this.translate(bivariate, liftVar, point);
1249
- const lcPolynomial = this.coeff(translated, mainVar, degMain);
1250
- const lcAtZero = this.isConst(lcPolynomial)
1251
- ? (lcPolynomial.as[0] ?? 0n)
1252
- : this.getConstValue(this.substitute(lcPolynomial, [liftVar], [0n]));
1253
- if (lcAtZero === null) continue;
1254
- for (const prime of FACTOR_PRIMES) {
1255
- if (getGcd(prime, lcAtZero) !== 1n) continue;
1256
- for (let split = 1; split <= Math.floor(factorCount / 2); split++) {
1257
- let h1 = univariateFs.factors[0];
1258
- for (let index = 1; index < split; index++)
1259
- h1 = this.um.mul(h1, univariateFs.factors[index]);
1260
- let h2 = univariateFs.factors[split];
1261
- for (let index = split + 1; index < factorCount; index++)
1262
- h2 = this.um.mul(h2, univariateFs.factors[index]);
1263
- const lifted = this.liftBivariate(
1264
- translated,
1265
- mainVar,
1266
- liftVar,
1267
- degLift,
1268
- this.um.flipSignIfLmNeg(h1),
1269
- this.um.flipSignIfLmNeg(h2),
1270
- lcAtZero,
1271
- prime,
1272
- );
1273
- if (lifted === null) continue;
1274
- const candidates = lifted.map((factor) => this.translate(factor, liftVar, -point));
1275
- if (evalVars.length === 0) {
1276
- for (const candidate of candidates) {
1277
- if (this.isConst(candidate) || this.degree(candidate, x) === 0) continue;
1278
- this.pushSmallFactor(candidate, x, k, result);
1279
- }
1280
- return true;
1281
- }
1282
- for (const candidate of candidates) {
1283
- if (this.isConst(candidate)) continue;
1284
- const division = this.exactPseudoDivision(
1285
- polynomial,
1286
- candidate,
1287
- this.maxVar(candidate),
1288
- );
1289
- if (division.remainder.size !== 0) continue;
1290
- if (!this.eq(this.mul(candidate, division.quotient), polynomial)) continue;
1291
- for (const part of [candidate, division.quotient]) {
1292
- if (this.isConst(part)) result.constant *= part.as[0];
1293
- else if (this.degree(part, x) !== 0) this.pushSmallFactor(part, x, k, result);
1294
- }
1295
- return true;
1296
- }
1297
- }
1298
- }
1299
- }
2783
+ this.limit.checkpoint();
2784
+ const pBivar = new PolynomialRef(this);
2785
+ const isFound = this.tryMultivarFactorCombo(
2786
+ polynomial,
2787
+ r,
2788
+ x,
2789
+ k,
2790
+ mainVar,
2791
+ degMain,
2792
+ liftVar,
2793
+ evalVars,
2794
+ combo,
2795
+ pBivar,
2796
+ );
2797
+ pBivar.reset();
2798
+ if (isFound) return true;
1300
2799
  }
1301
2800
  }
1302
2801
  }
1303
2802
  return false;
1304
2803
  }
1305
2804
 
1306
- private pushSmallFactor(polynomial: Polynomial, x: number, k: number, result: Factors) {
1307
- const degree = this.degree(polynomial, x);
1308
- if (degree === 2 && this.isPrimitive(polynomial, x) && this.isSquareFreeIn(polynomial, x))
1309
- this.factorQuadratic(polynomial, x, k, result);
1310
- else this.pushFactor(result, polynomial, k);
2805
+ private tryMultivarFactorCombo(
2806
+ polynomial: Polynomial,
2807
+ r: Factors,
2808
+ x: number,
2809
+ k: number,
2810
+ mainVar: number,
2811
+ degMain: number,
2812
+ liftVar: number,
2813
+ evalVars: readonly number[],
2814
+ combo: number,
2815
+ pBivar: PolynomialRef,
2816
+ ) {
2817
+ const nEval = evalVars.length;
2818
+ if (nEval > 0) {
2819
+ const evalValues: bigint[] = [];
2820
+ for (let index = 0; index < nEval; index++) {
2821
+ let c = combo;
2822
+ for (let skip = 0; skip < index; skip++) c = Math.floor(c / FACTOR_EVAL_VALUES.length);
2823
+ evalValues.push(FACTOR_EVAL_VALUES[c % FACTOR_EVAL_VALUES.length]);
2824
+ }
2825
+ pBivar.set(this.substitute(polynomial, evalVars, evalValues));
2826
+ } else pBivar.set(polynomial);
2827
+ if (this.degree(pBivar.get(), mainVar) !== degMain) return false;
2828
+ const degLift = this.degree(pBivar.get(), liftVar);
2829
+ if (degLift === 0) return false;
2830
+ for (const point of FACTOR_EVAL_VALUES) {
2831
+ const pUniv = new PolynomialRef(this);
2832
+ const pUnivRef = new PolynomialRef(this);
2833
+ const q = new PolynomialRef(this);
2834
+ const lcPoly = new PolynomialRef(this);
2835
+ const isFound = this.tryMultivarFactorPoint(
2836
+ polynomial,
2837
+ r,
2838
+ x,
2839
+ k,
2840
+ mainVar,
2841
+ degMain,
2842
+ liftVar,
2843
+ nEval,
2844
+ degLift,
2845
+ point,
2846
+ pBivar,
2847
+ pUniv,
2848
+ pUnivRef,
2849
+ q,
2850
+ lcPoly,
2851
+ );
2852
+ lcPoly.reset();
2853
+ q.reset();
2854
+ pUnivRef.reset();
2855
+ pUniv.reset();
2856
+ if (isFound) return true;
2857
+ }
2858
+ return false;
2859
+ }
2860
+
2861
+ private tryMultivarFactorPoint(
2862
+ polynomial: Polynomial,
2863
+ r: Factors,
2864
+ x: number,
2865
+ k: number,
2866
+ mainVar: number,
2867
+ degMain: number,
2868
+ liftVar: number,
2869
+ nEval: number,
2870
+ degLift: number,
2871
+ point: bigint,
2872
+ pBivar: PolynomialRef,
2873
+ pUniv: PolynomialRef,
2874
+ pUnivRef: PolynomialRef,
2875
+ q: PolynomialRef,
2876
+ lcPoly: PolynomialRef,
2877
+ ) {
2878
+ pUniv.set(this.substitute(pBivar.get(), [liftVar], [point]));
2879
+ if (!this.isUnivariate(pUniv.get())) return false;
2880
+ if (this.degree(pUniv.get(), mainVar) !== degMain) return false;
2881
+ if (!this.isSquareFreeIn(pUniv.get(), mainVar)) return false;
2882
+ pUnivRef.copy(pUniv);
2883
+ const univariateFs = mkFactors();
2884
+ factorSquareFree(
2885
+ this.um,
2886
+ this.um.getPrimitive(this.toCoeffs(pUnivRef.get())),
2887
+ univariateFs,
2888
+ 1,
2889
+ DEFAULT_FACTOR_PARAMS,
2890
+ );
2891
+ const nf = univariateFs.factors.length;
2892
+ if (nf <= 1) return false;
2893
+ q.set(this.translate(pBivar.get(), liftVar, point));
2894
+ lcPoly.set(this.coeff(q.get(), mainVar, degMain));
2895
+ let lcAtZero = 0n;
2896
+ if (this.isConst(lcPoly.get())) lcAtZero = lcPoly.get().as[0] ?? 0n;
2897
+ else {
2898
+ const lcEval = new PolynomialRef(this);
2899
+ lcEval.set(this.substitute(lcPoly.get(), [liftVar], [0n]));
2900
+ const isConstant = this.isConst(lcEval.get());
2901
+ if (isConstant) lcAtZero = lcEval.get().as[0] ?? 0n;
2902
+ lcEval.reset();
2903
+ if (!isConstant) return false;
2904
+ }
2905
+ for (const prime of FACTOR_PRIMES) {
2906
+ if (getGcd(prime, lcAtZero) !== 1n) continue;
2907
+ for (let split = 1; split <= Math.floor(nf / 2); split++) {
2908
+ this.limit.checkpoint();
2909
+ let h1 = this.um.set(univariateFs.factors[0]);
2910
+ for (let index = 1; index < split; index++)
2911
+ h1 = this.um.mul(h1, univariateFs.factors[index]);
2912
+ let h2 = this.um.set(univariateFs.factors[split]);
2913
+ for (let index = split + 1; index < nf; index++)
2914
+ h2 = this.um.mul(h2, univariateFs.factors[index]);
2915
+ if (h1.length > 0 && h1[h1.length - 1] < 0n) h1 = h1.map((coeff) => -coeff);
2916
+ if (h2.length > 0 && h2[h2.length - 1] < 0n) h2 = h2.map((coeff) => -coeff);
2917
+ const f1 = new PolynomialRef(this);
2918
+ const f2 = new PolynomialRef(this);
2919
+ const isFound =
2920
+ this.tryBivarHenselLift(
2921
+ q.get(),
2922
+ mainVar,
2923
+ liftVar,
2924
+ degLift,
2925
+ h1,
2926
+ h2,
2927
+ lcAtZero,
2928
+ prime,
2929
+ f1,
2930
+ f2,
2931
+ ) && this.pushLiftedFactors(polynomial, r, x, k, nEval, liftVar, point, f1, f2);
2932
+ f2.reset();
2933
+ f1.reset();
2934
+ if (isFound) return true;
2935
+ }
2936
+ }
2937
+ return false;
1311
2938
  }
1312
2939
 
1313
- private getConstValue(polynomial: Polynomial) {
1314
- if (!this.isConst(polynomial)) return null;
1315
- return polynomial.as[0] ?? 0n;
2940
+ private pushLiftedFactors(
2941
+ polynomial: Polynomial,
2942
+ r: Factors,
2943
+ x: number,
2944
+ k: number,
2945
+ nEval: number,
2946
+ liftVar: number,
2947
+ point: bigint,
2948
+ f1: PolynomialRef,
2949
+ f2: PolynomialRef,
2950
+ ) {
2951
+ f1.set(this.translate(f1.get(), liftVar, -point));
2952
+ f2.set(this.translate(f2.get(), liftVar, -point));
2953
+ if (nEval === 0) {
2954
+ const bivarFs = [new PolynomialRef(this), new PolynomialRef(this)];
2955
+ bivarFs[0].copy(f1);
2956
+ bivarFs[1].copy(f2);
2957
+ for (const bf of bivarFs) {
2958
+ if (this.isConst(bf.get()) || this.degree(bf.get(), x) === 0) continue;
2959
+ this.pushSmallFactor(bf, r, x, k);
2960
+ }
2961
+ bivarFs[1].reset();
2962
+ bivarFs[0].reset();
2963
+ return true;
2964
+ }
2965
+ const cands = [new PolynomialRef(this), new PolynomialRef(this)];
2966
+ cands[0].copy(f1);
2967
+ cands[1].copy(f2);
2968
+ let isFound = false;
2969
+ for (const cand of cands) {
2970
+ if (this.isConst(cand.get())) continue;
2971
+ const qDiv = new PolynomialRef(this);
2972
+ const rDiv = new PolynomialRef(this);
2973
+ const divVar = this.maxVar(cand.get());
2974
+ this.exactPseudoDivision(polynomial, cand.get(), divVar, qDiv, rDiv);
2975
+ if (!this.isZero(rDiv.get())) {
2976
+ rDiv.reset();
2977
+ qDiv.reset();
2978
+ continue;
2979
+ }
2980
+ const check = new PolynomialRef(this);
2981
+ check.set(this.mul(cand.get(), qDiv.get()));
2982
+ if (this.eq(check.get(), polynomial)) {
2983
+ const parts = [new PolynomialRef(this), new PolynomialRef(this)];
2984
+ parts[0].copy(cand);
2985
+ parts[1].copy(qDiv);
2986
+ for (const part of parts) {
2987
+ if (this.isConst(part.get())) {
2988
+ r.constant *= part.get().as[0];
2989
+ continue;
2990
+ }
2991
+ if (this.degree(part.get(), x) === 0) continue;
2992
+ this.pushSmallFactor(part, r, x, k);
2993
+ }
2994
+ parts[1].reset();
2995
+ parts[0].reset();
2996
+ isFound = true;
2997
+ }
2998
+ check.reset();
2999
+ rDiv.reset();
3000
+ qDiv.reset();
3001
+ if (isFound) break;
3002
+ }
3003
+ cands[1].reset();
3004
+ cands[0].reset();
3005
+ return isFound;
1316
3006
  }
1317
3007
 
1318
- private liftBivariate(
3008
+ private tryBivarHenselLift(
1319
3009
  q: Polynomial,
1320
3010
  x: number,
1321
3011
  y: number,
1322
3012
  degY: number,
1323
3013
  h1: readonly bigint[],
1324
3014
  h2: readonly bigint[],
1325
- lc: bigint,
3015
+ lcValue: bigint,
1326
3016
  prime: bigint,
3017
+ f1Out: PolynomialRef,
3018
+ f2Out: PolynomialRef,
1327
3019
  ) {
1328
- const zp = new UpolynomialManager(prime);
3020
+ const zp = new UpolynomialManager(this.limit, prime);
1329
3021
  const f1 = zp.mkMonic(zp.set(h1));
1330
3022
  const f2 = zp.mkMonic(zp.set(h2));
1331
3023
  const ext = zp.extGcd(f1, f2);
1332
- if (ext.d.length !== 1 || ext.d[0] !== 1n) return null;
3024
+ if (ext.d.length !== 1 || ext.d[0] !== 1n) return false;
1333
3025
  const qCoeffs: bigint[][] = [];
1334
- for (let power = 0; power <= degY; power++) {
1335
- const coeff = this.coeff(q, y, power);
1336
- if (coeff.size !== 0 && !this.isUnivariate(coeff) && !this.isConst(coeff)) return null;
1337
- qCoeffs.push(zp.set(coeff.size === 0 ? [] : this.toCoeffs(coeff)));
3026
+ for (let j = 0; j <= degY; j++) {
3027
+ const cj = new PolynomialRef(this);
3028
+ cj.set(this.coeff(q, y, j));
3029
+ const isBivariate = this.isZero(cj.get()) || this.isUnivariate(cj.get());
3030
+ if (isBivariate) qCoeffs.push(zp.set(this.isZero(cj.get()) ? [] : this.toCoeffs(cj.get())));
3031
+ cj.reset();
3032
+ if (!isBivariate) return false;
1338
3033
  }
1339
3034
  const f1Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
1340
3035
  const f2Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
1341
3036
  f1Coeffs[0] = zp.set(f1);
1342
- f2Coeffs[0] = zp.mulConst(f2, zp.normalizeNumeral(lc));
1343
- const lcInv = zp.inv(lc);
1344
- for (let power = 1; power <= degY; power++) {
1345
- let error = zp.set(qCoeffs[power]);
1346
- for (let first = 0; first <= power; first++) {
1347
- const second = power - first;
1348
- if (second > degY || second === 0 || first === 0) continue;
3037
+ f2Coeffs[0] = zp.mulConst(zp.set(f2), zp.normalizeNumeral(lcValue));
3038
+ const lcInv = zp.inv(lcValue);
3039
+ for (let j = 1; j <= degY; j++) {
3040
+ this.limit.checkpoint();
3041
+ let e = zp.set(qCoeffs[j]);
3042
+ for (let first = 0; first <= j; first++) {
3043
+ const second = j - first;
3044
+ if (second > degY) continue;
3045
+ if (first === j && second === 0) continue;
3046
+ if (first === 0 && second === j) continue;
1349
3047
  if (f1Coeffs[first].length === 0 || f2Coeffs[second].length === 0) continue;
1350
- error = zp.sub(error, zp.mul(f1Coeffs[first], f2Coeffs[second]));
1351
- }
1352
- if (error.length === 0) continue;
1353
- const a = zp.divRem(zp.mul(error, ext.v), f1).remainder;
1354
- const b = zp.divRem(zp.mul(error, ext.u), f2).remainder;
1355
- f1Coeffs[power] = zp.mulConst(a, lcInv);
1356
- f2Coeffs[power] = zp.set(b);
1357
- }
1358
- const toPolynomial = (coeffs: readonly bigint[][]) => {
1359
- let result = this.zero;
1360
- for (let power = 0; power <= degY; power++) {
1361
- if (coeffs[power].length === 0) continue;
1362
- const univariate = this.fromCoeffs(coeffs[power], x);
1363
- if (univariate.size === 0) continue;
1364
- result = this.add(result, this.mulTerm(1n, this.mkPower(y, power), univariate));
3048
+ e = zp.sub(e, zp.mul(f1Coeffs[first], f2Coeffs[second]));
1365
3049
  }
1366
- return result;
1367
- };
1368
- const first = toPolynomial(f1Coeffs);
1369
- const second = toPolynomial(f2Coeffs);
1370
- return this.eq(this.mul(first, second), q) ? [first, second] : null;
1371
- }
1372
-
1373
- pscChain(first: Polynomial, second: Polynomial, variable: number) {
1374
- const chain =
1375
- this.degree(first, variable) >= this.degree(second, variable)
1376
- ? this.pscChainCore(first, second, variable)
1377
- : this.pscChainCore(second, first, variable);
1378
- return chain.length === 0 ? [this.zero] : chain.reverse();
1379
- }
1380
-
1381
- private pscChainCore(p: Polynomial, q: Polynomial, x: number) {
1382
- const chain: Polynomial[] = [];
1383
- let s = this.pw(this.lc(q, x), this.degree(p, x) - this.degree(q, x));
1384
- let a = q;
1385
- let b = this.exactPseudoRemainder(p, this.neg(q), x);
1386
- while (b.size > 0) {
1387
- const d = this.degree(a, x);
1388
- const e = this.degree(b, x);
1389
- const principal = this.coeff(b, x, d - 1);
1390
- if (principal.size > 0) chain.push(principal);
1391
- let c = b;
1392
- if (d - e > 1) {
1393
- c = this.getSeLazard(d, s, b, x);
1394
- const principalE = this.coeff(c, x, e);
1395
- if (principalE.size > 0) chain.push(principalE);
1396
- }
1397
- if (e === 0) break;
1398
- b = this.getOptimizedSe1(d, e, a, b, c, s, x);
1399
- a = c;
1400
- s = this.lc(a, x);
3050
+ if (e.length === 0) continue;
3051
+ const a = zp.divRem(zp.mul(e, ext.v), f1).remainder;
3052
+ const b = zp.divRem(zp.mul(e, ext.u), f2).remainder;
3053
+ f1Coeffs[j] = zp.mulConst(a, lcInv);
3054
+ f2Coeffs[j] = zp.set(b);
1401
3055
  }
1402
- return chain;
3056
+ return this.reconstructLiftedFactors(q, x, y, degY, f1Coeffs, f2Coeffs, f1Out, f2Out);
1403
3057
  }
1404
3058
 
1405
- private getSeLazard(d: number, lcSd: Polynomial, sd1: Polynomial, x: number) {
1406
- let n = d - this.degree(sd1, x) - 1;
1407
- if (n === 0) return sd1;
1408
- const lcSd1 = this.lc(sd1, x);
1409
- let a = 1 << (31 - Math.clz32(n));
1410
- let c = lcSd1;
1411
- n -= a;
1412
- while (a !== 1) {
1413
- a /= 2;
1414
- c = this.exactDiv(this.mul(c, c), lcSd);
1415
- if (n >= a) {
1416
- c = this.exactDiv(this.mul(c, lcSd1), lcSd);
1417
- n -= a;
3059
+ private reconstructLiftedFactors(
3060
+ q: Polynomial,
3061
+ x: number,
3062
+ y: number,
3063
+ degY: number,
3064
+ f1Coeffs: readonly bigint[][],
3065
+ f2Coeffs: readonly bigint[][],
3066
+ f1Out: PolynomialRef,
3067
+ f2Out: PolynomialRef,
3068
+ ) {
3069
+ const f1Poly = new PolynomialRef(this);
3070
+ const f2Poly = new PolynomialRef(this);
3071
+ f1Poly.set(this.zero);
3072
+ f2Poly.set(this.zero);
3073
+ const addTerm = (coeffs: readonly bigint[], power: number, target: PolynomialRef) => {
3074
+ if (coeffs.length === 0) return;
3075
+ const univ = new PolynomialRef(this);
3076
+ univ.set(this.toPolynomial(coeffs, x));
3077
+ if (!this.isZero(univ.get())) {
3078
+ const term = new PolynomialRef(this);
3079
+ term.set(this.mulTerm(1n, this.mkPower(y, power), univ.get()));
3080
+ target.set(this.add(target.get(), term.get()));
3081
+ term.reset();
1418
3082
  }
3083
+ univ.reset();
3084
+ };
3085
+ for (let j = 0; j <= degY; j++) {
3086
+ addTerm(f1Coeffs[j], j, f1Poly);
3087
+ addTerm(f2Coeffs[j], j, f2Poly);
1419
3088
  }
1420
- return this.exactDiv(this.mul(c, sd1), lcSd);
3089
+ const product = new PolynomialRef(this);
3090
+ product.set(this.mul(f1Poly.get(), f2Poly.get()));
3091
+ const isEqual = this.eq(product.get(), q);
3092
+ if (isEqual) {
3093
+ f1Out.copy(f1Poly);
3094
+ f2Out.copy(f2Poly);
3095
+ }
3096
+ product.reset();
3097
+ f2Poly.reset();
3098
+ f1Poly.reset();
3099
+ return isEqual;
1421
3100
  }
1422
3101
 
1423
- private getOptimizedSe1(
1424
- d: number,
1425
- e: number,
1426
- a: Polynomial,
1427
- sd1: Polynomial,
1428
- se: Polynomial,
1429
- s: Polynomial,
1430
- x: number,
1431
- ) {
1432
- const cd1 = this.lc(sd1, x);
1433
- const lcSe = this.lc(se, x);
1434
- const getPower = (power: number) => (power === 0 ? this.one : this.mkVar(x, power));
1435
- const h: Polynomial[] = [];
1436
- for (let j = 0; j < e; j++) h.push(this.mul(lcSe, getPower(j)));
1437
- h.push(this.sub(this.mul(lcSe, getPower(e)), se));
1438
- const xPolynomial = this.mkVar(x);
1439
- for (let j = e + 1; j < d; j++) {
1440
- const xh = this.mul(xPolynomial, h[j - 1]);
1441
- h.push(this.sub(xh, this.exactDiv(this.mul(this.coeff(xh, x, e), sd1), cd1)));
1442
- }
1443
- let sum = this.zero;
1444
- for (let j = 0; j < d; j++) sum = this.add(sum, this.mul(this.coeff(a, x, j), h[j]));
1445
- const dPolynomial = this.exactDiv(sum, this.lc(a, x));
1446
- const xh = this.mul(xPolynomial, h[d - 1]);
1447
- const result = this.exactDiv(
1448
- this.sub(this.mul(cd1, this.add(xh, dPolynomial)), this.mul(this.coeff(xh, x, e), sd1)),
1449
- s,
1450
- );
1451
- return (d - e + 1) % 2 === 1 ? this.neg(result) : result;
3102
+ evaluateWith<T>(polynomial: Polynomial, ops: ValueOps<T>, getValue: (variable: number) => T) {
3103
+ const result = this.evaluatePartially(polynomial, ops, getValue);
3104
+ if (result === null) throw new SmtInvariantError("a total evaluation stopped early");
3105
+ return result;
1452
3106
  }
1453
3107
 
1454
- evaluateWith<T>(polynomial: Polynomial, ops: ValueOps<T>, getValue: (variable: number) => T) {
3108
+ private evaluatePartially<T>(
3109
+ polynomial: Polynomial,
3110
+ ops: ValueOps<T>,
3111
+ getValue: (variable: number) => T | null,
3112
+ ) {
1455
3113
  if (polynomial.size === 0) return ops.fromInteger(0n);
1456
3114
  if (this.isConst(polynomial)) return ops.fromInteger(polynomial.as[0]);
1457
3115
  polynomial.lexSort();
@@ -1468,34 +3126,38 @@ export class PolynomialManager {
1468
3126
  private evaluateCore<T>(
1469
3127
  polynomial: Polynomial,
1470
3128
  ops: ValueOps<T>,
1471
- getValue: (variable: number) => T,
3129
+ getValue: (variable: number) => T | null,
1472
3130
  start: number,
1473
3131
  end: number,
1474
3132
  x: number,
1475
- ): T {
3133
+ ): T | null {
1476
3134
  if (end === start + 1) {
1477
3135
  let result = ops.fromInteger(polynomial.as[start]);
1478
3136
  const monomial = polynomial.ms[start];
1479
3137
  for (let index = 0; index < monomial.size; index++) {
1480
3138
  const variable = monomial.vars[index];
1481
3139
  if (variable > x) break;
1482
- result = ops.mul(result, ops.power(getValue(variable), monomial.degrees[index]));
3140
+ const value = getValue(variable);
3141
+ if (value === null) return null;
3142
+ result = ops.mul(result, ops.power(value, monomial.degrees[index]));
1483
3143
  }
1484
3144
  return result;
1485
3145
  }
1486
3146
  const value = getValue(x);
3147
+ if (value === null) return null;
1487
3148
  let result = ops.fromInteger(0n);
1488
3149
  let index = start;
1489
3150
  while (index < end) {
3151
+ this.limit.checkpoint();
1490
3152
  const degree = polynomial.ms[index].degreeOf(x);
1491
3153
  if (degree === 0) {
1492
3154
  const below = this.maxSmallerThan(polynomial, index, end, x);
1493
- result = ops.add(
1494
- result,
3155
+ const rest =
1495
3156
  below === NULL_VAR
1496
3157
  ? ops.fromInteger(polynomial.as[index])
1497
- : this.evaluateCore(polynomial, ops, getValue, index, end, below),
1498
- );
3158
+ : this.evaluateCore(polynomial, ops, getValue, index, end, below);
3159
+ if (rest === null) return null;
3160
+ result = ops.add(result, rest);
1499
3161
  break;
1500
3162
  }
1501
3163
  let next = index + 1;
@@ -1508,13 +3170,12 @@ export class PolynomialManager {
1508
3170
  }
1509
3171
  }
1510
3172
  const below = this.maxSmallerThan(polynomial, index, next, x);
1511
- result = ops.add(
1512
- result,
3173
+ const coeff =
1513
3174
  below === NULL_VAR
1514
3175
  ? ops.fromInteger(polynomial.as[index])
1515
- : this.evaluateCore(polynomial, ops, getValue, index, next, below),
1516
- );
1517
- result = ops.mul(result, ops.power(value, degree - nextDegree));
3176
+ : this.evaluateCore(polynomial, ops, getValue, index, next, below);
3177
+ if (coeff === null) return null;
3178
+ result = ops.mul(ops.add(result, coeff), ops.power(value, degree - nextDegree));
1518
3179
  index = next;
1519
3180
  }
1520
3181
  return result;
@@ -1527,66 +3188,88 @@ export class PolynomialManager {
1527
3188
  return max;
1528
3189
  }
1529
3190
 
1530
- evaluate(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
1531
- return this.evaluateWith(polynomial, RATIONAL_OPS, (variable) => {
1532
- const value = values[variable];
1533
- if (value === undefined) throw new SmtInvariantError(`x${variable} is unassigned`);
1534
- return value;
1535
- });
1536
- }
1537
-
1538
- getSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
1539
- const value = this.evaluate(polynomial, values);
1540
- return value.isZero() ? 0 : value.isPositive() ? 1 : -1;
3191
+ getRationalSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
3192
+ const value = this.evaluatePartially(
3193
+ polynomial,
3194
+ RATIONAL_OPS,
3195
+ (variable) => values[variable] ?? null,
3196
+ );
3197
+ return value === null ? null : value.isZero() ? 0 : value.isPositive() ? 1 : -1;
1541
3198
  }
1542
3199
  }
1543
3200
 
1544
3201
  export class PolynomialCache {
1545
3202
  private table = new Map<string, Polynomial>();
1546
- private inCache = new Set<number>();
3203
+ private cachedPolys: PolynomialRefVector;
3204
+ private inCache: boolean[] = [];
1547
3205
  private pscChains = new Map<string, Polynomial[]>();
1548
3206
  private factorizations = new Map<number, Polynomial[]>();
1549
3207
 
1550
- constructor(readonly pm: PolynomialManager) {}
3208
+ constructor(readonly pm: PolynomialManager) {
3209
+ this.cachedPolys = new PolynomialRefVector(pm);
3210
+ }
1551
3211
 
1552
3212
  reset() {
1553
3213
  this.table.clear();
1554
- this.inCache.clear();
1555
3214
  this.pscChains.clear();
1556
3215
  this.factorizations.clear();
3216
+ this.inCache = [];
3217
+ this.cachedPolys.reset();
1557
3218
  }
1558
3219
 
1559
3220
  mkUnique(polynomial: Polynomial) {
1560
- if (this.inCache.has(polynomial.id)) return polynomial;
3221
+ if (this.inCache[polynomial.id] === true) return polynomial;
1561
3222
  const key = this.pm.getKey(polynomial);
1562
3223
  const existing = this.table.get(key);
1563
3224
  if (existing !== undefined) return existing;
1564
3225
  this.table.set(key, polynomial);
1565
- this.inCache.add(polynomial.id);
3226
+ this.cachedPolys.push(polynomial);
3227
+ this.inCache[polynomial.id] = true;
1566
3228
  return polynomial;
1567
3229
  }
1568
3230
 
1569
3231
  contains(polynomial: Polynomial) {
1570
- return this.inCache.has(polynomial.id);
3232
+ return this.inCache[polynomial.id] === true;
1571
3233
  }
1572
3234
 
1573
- pscChain(first: Polynomial, second: Polynomial, variable: number) {
3235
+ pscChain(first: Polynomial, second: Polynomial, variable: number, chain: PolynomialRefVector) {
1574
3236
  const p = this.mkUnique(first);
1575
3237
  const q = this.mkUnique(second);
1576
3238
  const key = `${p.id},${q.id},${variable}`;
1577
3239
  const cached = this.pscChains.get(key);
1578
- if (cached !== undefined) return cached;
1579
- const chain = this.pm.pscChain(p, q, variable).map((element) => this.mkUnique(element));
1580
- this.pscChains.set(key, chain);
1581
- return chain;
1582
- }
1583
-
1584
- factor(polynomial: Polynomial) {
1585
- const unique = this.mkUnique(polynomial);
1586
- const cached = this.factorizations.get(unique.id);
1587
- if (cached !== undefined) return cached;
1588
- const factors = this.pm.factor(unique).factors.map((factor) => this.mkUnique(factor));
1589
- this.factorizations.set(unique.id, factors);
1590
- return factors;
3240
+ if (cached !== undefined) {
3241
+ chain.reset();
3242
+ for (const element of cached) chain.push(element);
3243
+ return;
3244
+ }
3245
+ this.pm.pscChain(p, q, variable, chain);
3246
+ const result: Polynomial[] = [];
3247
+ for (let index = 0; index < chain.size; index++) {
3248
+ const unique = this.mkUnique(chain.get(index));
3249
+ chain.set(index, unique);
3250
+ result.push(unique);
3251
+ }
3252
+ this.pscChains.set(key, result);
3253
+ }
3254
+
3255
+ factor(polynomial: Polynomial, distinctFactors: PolynomialRefVector) {
3256
+ distinctFactors.reset();
3257
+ const p = this.mkUnique(polynomial);
3258
+ const cached = this.factorizations.get(p.id);
3259
+ if (cached !== undefined) {
3260
+ distinctFactors.reset();
3261
+ for (const factor of cached) distinctFactors.push(factor);
3262
+ return;
3263
+ }
3264
+ const fs = new Factors(this.pm);
3265
+ this.pm.factor(p, fs);
3266
+ const result: Polynomial[] = [];
3267
+ for (const factor of fs.factors) {
3268
+ const unique = this.mkUnique(factor);
3269
+ distinctFactors.push(unique);
3270
+ result.push(unique);
3271
+ }
3272
+ this.factorizations.set(p.id, result);
3273
+ fs.reset();
1591
3274
  }
1592
3275
  }