tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479

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 (587) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +41 -37
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +21 -4
  8. package/dist/index.d.ts +21 -4
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2681 -425
  15. package/dist/prove.js +2681 -425
  16. package/dist/run.cjs +41 -42
  17. package/dist/run.js +41 -42
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +97 -89
  21. package/dist/transfer.js +97 -89
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +72 -39
  26. package/src/bags.ts +50 -29
  27. package/src/builtins.ts +8 -16
  28. package/src/check-failure.ts +118 -0
  29. package/src/check-trace.ts +321 -0
  30. package/src/check.ts +828 -770
  31. package/src/cli/options.ts +6 -31
  32. package/src/cli/runtime-invariants.ts +20 -56
  33. package/src/cli/shared.ts +1 -1
  34. package/src/cli/tlapm.ts +433 -70
  35. package/src/cli/tlc-arguments.ts +224 -212
  36. package/src/cli/tlc-output.ts +701 -0
  37. package/src/cli/tlc-usage.ts +1 -2
  38. package/src/cli/tlc.ts +65 -712
  39. package/src/cli/xml-exporter.ts +23 -33
  40. package/src/codegen.ts +28 -20
  41. package/src/coverage.ts +255 -20
  42. package/src/dependencies.ts +96 -27
  43. package/src/dfid.ts +115 -50
  44. package/src/environment-config.ts +315 -0
  45. package/src/environment.ts +175 -373
  46. package/src/errors.ts +40 -5
  47. package/src/evaluate.ts +429 -139
  48. package/src/exit-codes.ts +28 -12
  49. package/src/fingerprints.ts +65 -1
  50. package/src/instances.ts +178 -17
  51. package/src/java-hash.ts +14 -0
  52. package/src/java-overrides.ts +2 -2
  53. package/src/json.ts +4 -7
  54. package/src/levels.ts +708 -272
  55. package/src/lexer.ts +17 -5
  56. package/src/liveness-checker.ts +707 -249
  57. package/src/liveness.ts +148 -95
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +39 -9
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +27 -18
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +48 -18
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +120 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +29 -47
  82. package/src/parser.ts +757 -326
  83. package/src/pretty-print.ts +1 -1
  84. package/src/prover/decide-pool.ts +3 -3
  85. package/src/prover/deciders.ts +12 -9
  86. package/src/prover/isabelle/decide.ts +3 -25
  87. package/src/prover/isabelle/encode.ts +72 -42
  88. package/src/prover/isabelle/isar/attrib.ts +250 -0
  89. package/src/prover/isabelle/isar/context.ts +335 -0
  90. package/src/prover/isabelle/isar/induct.ts +382 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  92. package/src/prover/isabelle/isar/method.ts +509 -212
  93. package/src/prover/isabelle/isar/proof.ts +570 -14
  94. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  95. package/src/prover/isabelle/isar/theory.ts +487 -76
  96. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  97. package/src/prover/isabelle/isar/type-check.ts +89 -14
  98. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  99. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  100. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  101. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  102. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  103. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  104. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  105. package/src/prover/isabelle/provers/classical.ts +45 -20
  106. package/src/prover/isabelle/provers/hypsubst.ts +19 -30
  107. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  108. package/src/prover/isabelle/pure/consts.ts +0 -2
  109. package/src/prover/isabelle/pure/conv.ts +2 -10
  110. package/src/prover/isabelle/pure/drule.ts +72 -6
  111. package/src/prover/isabelle/pure/envir.ts +0 -2
  112. package/src/prover/isabelle/pure/goal.ts +1 -3
  113. package/src/prover/isabelle/pure/logic.ts +1 -3
  114. package/src/prover/isabelle/pure/name.ts +0 -2
  115. package/src/prover/isabelle/pure/net.ts +0 -2
  116. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  117. package/src/prover/isabelle/pure/pattern.ts +0 -2
  118. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  119. package/src/prover/isabelle/pure/rewriter.ts +9 -20
  120. package/src/prover/isabelle/pure/search.ts +0 -2
  121. package/src/prover/isabelle/pure/seq.ts +0 -2
  122. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  123. package/src/prover/isabelle/pure/table.ts +2 -3
  124. package/src/prover/isabelle/pure/tactic.ts +0 -2
  125. package/src/prover/isabelle/pure/tactical.ts +42 -37
  126. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  127. package/src/prover/isabelle/pure/term.ts +3 -5
  128. package/src/prover/isabelle/pure/thm.ts +14 -13
  129. package/src/prover/isabelle/pure/type.ts +0 -2
  130. package/src/prover/isabelle/pure/unify.ts +0 -2
  131. package/src/prover/isabelle/pure/variable.ts +0 -2
  132. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  133. package/src/prover/isabelle/tla/context.ts +58 -11
  134. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  135. package/src/prover/isabelle/tla/logic.ts +49 -21
  136. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  137. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  138. package/src/prover/ocaml.ts +4 -1
  139. package/src/prover/prep/action.ts +30 -31
  140. package/src/prover/prep/enabled-axioms.ts +11 -2
  141. package/src/prover/prep/fingerprint.ts +2 -5
  142. package/src/prover/prep/md5.ts +26 -29
  143. package/src/prover/prep/methods.ts +181 -51
  144. package/src/prover/prep/normalize.ts +38 -9
  145. package/src/prover/prove.ts +395 -94
  146. package/src/prover/ptl/decide.ts +95 -50
  147. package/src/prover/ptl/encode.ts +2 -3
  148. package/src/prover/ptl/tableau.ts +28 -2
  149. package/src/prover/smt/arithmetic.ts +310 -0
  150. package/src/prover/smt/axioms.ts +12 -8
  151. package/src/prover/smt/context.ts +43 -8
  152. package/src/prover/smt/data.ts +498 -379
  153. package/src/prover/smt/encode.ts +148 -57
  154. package/src/prover/smt/extensionality.ts +5 -3
  155. package/src/prover/smt/flatten.ts +4 -6
  156. package/src/prover/smt/format.ts +28 -4
  157. package/src/prover/smt/instances.ts +7 -1
  158. package/src/prover/smt/layout.ts +91 -0
  159. package/src/prover/smt/rewrite.ts +1016 -618
  160. package/src/prover/smt/simplify.ts +441 -0
  161. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
  162. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  163. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  164. package/src/prover/smt/solver/act-cache.ts +0 -1
  165. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  166. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  167. package/src/prover/smt/solver/aig.ts +889 -0
  168. package/src/prover/smt/solver/arith-rewriter.ts +624 -9
  169. package/src/prover/smt/solver/arith-terms.ts +121 -0
  170. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  171. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  172. package/src/prover/smt/solver/asserted-formulas.ts +240 -56
  173. package/src/prover/smt/solver/ast-lt.ts +165 -11
  174. package/src/prover/smt/solver/ast-util.ts +160 -2
  175. package/src/prover/smt/solver/ast.ts +1483 -45
  176. package/src/prover/smt/solver/auf-solver.ts +25 -18
  177. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  178. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  179. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  180. package/src/prover/smt/solver/bound-manager.ts +196 -0
  181. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  182. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  183. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  184. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  185. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  186. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  187. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  188. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  189. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  190. package/src/prover/smt/solver/card2bv.ts +127 -0
  191. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  192. package/src/prover/smt/solver/cg-table.ts +39 -25
  193. package/src/prover/smt/solver/check-logic.ts +330 -0
  194. package/src/prover/smt/solver/clause.ts +0 -1
  195. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  196. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  197. package/src/prover/smt/solver/context.ts +598 -128
  198. package/src/prover/smt/solver/ctx-simplify.ts +29 -14
  199. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  200. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  201. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  202. package/src/prover/smt/solver/demodulator.ts +786 -0
  203. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  204. package/src/prover/smt/solver/der.ts +38 -10
  205. package/src/prover/smt/solver/diff-neq.ts +207 -0
  206. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  207. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  208. package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
  209. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  210. package/src/prover/smt/solver/e-matching.ts +7 -8
  211. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  212. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  213. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  214. package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
  215. package/src/prover/smt/solver/enode.ts +100 -3
  216. package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
  217. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  218. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  219. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  220. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  221. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  222. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  223. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  224. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  225. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  226. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  227. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  228. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  229. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  230. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  231. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  232. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  233. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  234. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  235. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  236. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  237. package/src/prover/smt/solver/expr-ref.ts +0 -1
  238. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  239. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  240. package/src/prover/smt/solver/factor.ts +163 -0
  241. package/src/prover/smt/solver/fd-solver.ts +734 -0
  242. package/src/prover/smt/solver/fingerprints.ts +15 -15
  243. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  244. package/src/prover/smt/solver/flat-literals.ts +0 -1
  245. package/src/prover/smt/solver/fm-tactic.ts +886 -0
  246. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  247. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  248. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  249. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  250. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  251. package/src/prover/smt/solver/goal.ts +178 -15
  252. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  253. package/src/prover/smt/solver/guard-set.ts +219 -0
  254. package/src/prover/smt/solver/hash.ts +0 -1
  255. package/src/prover/smt/solver/hashtable.ts +34 -16
  256. package/src/prover/smt/solver/inf-eps.ts +63 -0
  257. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  258. package/src/prover/smt/solver/internalizer.ts +111 -39
  259. package/src/prover/smt/solver/lackr.ts +381 -0
  260. package/src/prover/smt/solver/lbool.ts +0 -1
  261. package/src/prover/smt/solver/lia2card.ts +268 -0
  262. package/src/prover/smt/solver/lia2pb.ts +154 -0
  263. package/src/prover/smt/solver/literal.ts +0 -1
  264. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  265. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  266. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  267. package/src/prover/smt/solver/lp/containers.ts +7 -2
  268. package/src/prover/smt/solver/lp/core-solver.ts +30 -11
  269. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  270. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  271. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  272. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  273. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  274. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  275. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  276. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  277. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  278. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  279. package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
  280. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  281. package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
  282. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  283. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  284. package/src/prover/smt/solver/lp/nex.ts +2 -2
  285. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  287. package/src/prover/smt/solver/lp/nla-core.ts +68 -17
  288. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  290. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  292. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  293. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  294. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  295. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  296. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  297. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  298. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  299. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  300. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  301. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  302. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  303. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  304. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  305. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  306. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  307. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  308. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  309. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  310. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  311. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  312. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  313. package/src/prover/smt/solver/macro-finder.ts +530 -0
  314. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  315. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  316. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  317. package/src/prover/smt/solver/max-cliques.ts +105 -0
  318. package/src/prover/smt/solver/maxcore.ts +310 -0
  319. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  320. package/src/prover/smt/solver/maxlex.ts +115 -0
  321. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  322. package/src/prover/smt/solver/maxsmt.ts +92 -0
  323. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  324. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  325. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  326. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  327. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  328. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  329. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  330. package/src/prover/smt/solver/model-checker.ts +19 -28
  331. package/src/prover/smt/solver/model-evaluator.ts +190 -12
  332. package/src/prover/smt/solver/model-finder.ts +12 -18
  333. package/src/prover/smt/solver/model-generator.ts +104 -35
  334. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  335. package/src/prover/smt/solver/model-printer.ts +214 -0
  336. package/src/prover/smt/solver/mpf.ts +709 -0
  337. package/src/prover/smt/solver/mus.ts +50 -0
  338. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  339. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  340. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  341. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  342. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  343. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  344. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  345. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  346. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  347. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  348. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  349. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  350. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  351. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  352. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  353. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  354. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  355. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  356. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  357. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  358. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  359. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  360. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  361. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  362. package/src/prover/smt/solver/nlqsat.ts +485 -0
  363. package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
  364. package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
  365. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  366. package/src/prover/smt/solver/nlsat/explain.ts +427 -229
  367. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  368. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
  369. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  370. package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
  371. package/src/prover/smt/solver/nlsat/solver.ts +293 -92
  372. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  373. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  374. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  375. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
  376. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  377. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  378. package/src/prover/smt/solver/nnf.ts +110 -24
  379. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  380. package/src/prover/smt/solver/occf.ts +97 -0
  381. package/src/prover/smt/solver/opt-context.ts +801 -0
  382. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  383. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  384. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  385. package/src/prover/smt/solver/opt-solver.ts +312 -0
  386. package/src/prover/smt/solver/opt-value.ts +55 -0
  387. package/src/prover/smt/solver/optsmt.ts +692 -0
  388. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  389. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  390. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  391. package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
  392. package/src/prover/smt/solver/poly-rewriter.ts +259 -57
  393. package/src/prover/smt/solver/probes.ts +577 -0
  394. package/src/prover/smt/solver/propagate-values.ts +37 -21
  395. package/src/prover/smt/solver/proto-model.ts +648 -19
  396. package/src/prover/smt/solver/pull-quant.ts +28 -12
  397. package/src/prover/smt/solver/purify-arith.ts +634 -0
  398. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +39 -19
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1499 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +829 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +22 -25
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
  422. package/src/prover/smt/solver/rewriter.ts +505 -60
  423. package/src/prover/smt/solver/rlimit.ts +45 -5
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +589 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
  468. package/src/prover/smt/solver/smtlib-script.ts +2136 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  470. package/src/prover/smt/solver/solver.ts +128 -23
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +2176 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
  487. package/src/prover/smt/solver/theory-lra-state.ts +7 -23
  488. package/src/prover/smt/solver/theory-lra.ts +189 -2
  489. package/src/prover/smt/solver/theory-pb.ts +951 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  497. package/src/prover/smt/solver/theory.ts +189 -0
  498. package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
  499. package/src/prover/smt/solver/var-subst.ts +36 -14
  500. package/src/prover/smt/table.ts +3 -2
  501. package/src/prover/smt/types.ts +146 -0
  502. package/src/prover/tlapm/cache.ts +57 -26
  503. package/src/prover/tlapm/tlapm.ts +15 -9
  504. package/src/prover/tlapm-library.ts +3208 -0
  505. package/src/prover/verdict.ts +9 -0
  506. package/src/prover/zenon/check/check.ts +1 -2
  507. package/src/prover/zenon/check/records.ts +1 -1
  508. package/src/prover/zenon/check/relations.ts +2 -1
  509. package/src/prover/zenon/check/rewrites.ts +2 -15
  510. package/src/prover/zenon/check/sets.ts +40 -58
  511. package/src/prover/zenon/check/terms.ts +1 -2
  512. package/src/prover/zenon/decide.ts +10 -7
  513. package/src/prover/zenon/encode.ts +0 -2
  514. package/src/prover/zenon/eqrel.ts +2 -2
  515. package/src/prover/zenon/equality-rules.ts +24 -2
  516. package/src/prover/zenon/expr.ts +28 -2
  517. package/src/prover/zenon/index-table.ts +16 -23
  518. package/src/prover/zenon/isar-case.ts +1 -3
  519. package/src/prover/zenon/isar.ts +37 -39
  520. package/src/prover/zenon/llproof.ts +2 -13
  521. package/src/prover/zenon/mltoll.ts +12 -30
  522. package/src/prover/zenon/node.ts +20 -5
  523. package/src/prover/zenon/parse.ts +9 -8
  524. package/src/prover/zenon/phrase.ts +1 -3
  525. package/src/prover/zenon/proof.ts +0 -2
  526. package/src/prover/zenon/propositional-rules.ts +0 -2
  527. package/src/prover/zenon/rules.ts +2 -3
  528. package/src/prover/zenon/search.ts +11 -19
  529. package/src/prover/zenon/tla/functions.ts +2 -4
  530. package/src/prover/zenon/tla/llproof.ts +9 -13
  531. package/src/prover/zenon/tla/records.ts +1 -8
  532. package/src/prover/zenon/tla/rewrites.ts +0 -2
  533. package/src/prover/zenon/tla/sets.ts +22 -22
  534. package/src/prover/zenon/tla/terms.ts +0 -2
  535. package/src/prover/zenon/tla/tla.ts +7 -8
  536. package/src/resolve.ts +1327 -328
  537. package/src/runtime.ts +25 -2
  538. package/src/sany/builtins.ts +10 -10
  539. package/src/sany/generation.ts +384 -0
  540. package/src/sany/generator-def-entries.ts +297 -0
  541. package/src/sany/generator-definitions.ts +688 -0
  542. package/src/sany/generator-expressions.ts +1123 -0
  543. package/src/sany/generator-proofs.ts +668 -0
  544. package/src/sany/generator.ts +161 -2625
  545. package/src/sany/levels.ts +0 -2
  546. package/src/sany/lexer.ts +32 -23
  547. package/src/sany/linter.ts +0 -2
  548. package/src/sany/modules.ts +4 -2
  549. package/src/sany/nodes.ts +3 -4
  550. package/src/sany/report.ts +3 -6
  551. package/src/sany/selectors.ts +46 -44
  552. package/src/sany/xml.ts +25 -58
  553. package/src/search.ts +513 -165
  554. package/src/simulate.ts +340 -251
  555. package/src/spec-description.ts +48 -55
  556. package/src/standard-definitions.ts +5 -0
  557. package/src/standard-modules.ts +72 -54
  558. package/src/state-graph.ts +0 -2
  559. package/src/subexpressions.ts +564 -138
  560. package/src/substitution-levels.ts +5 -4
  561. package/src/successors.ts +56 -28
  562. package/src/symmetry.ts +4 -3
  563. package/src/tableau.ts +2 -2
  564. package/src/tlc/fingerprint.ts +81 -9
  565. package/src/tlc/jar-data.ts +10 -0
  566. package/src/tlc/messages.ts +23 -18
  567. package/src/tlc/order.ts +14 -3
  568. package/src/tlc/random.ts +6 -5
  569. package/src/tlc/replay.ts +152 -58
  570. package/src/tlc/summary.ts +29 -14
  571. package/src/tlc/tlc-operators.ts +12 -11
  572. package/src/tlc/tlcext-operators.ts +87 -26
  573. package/src/tlc/trace-spec.ts +27 -60
  574. package/src/trace-liveness.ts +529 -0
  575. package/src/typed-tier.ts +6556 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/typescript/types.ts +2 -2
  583. package/src/values.ts +208 -227
  584. package/src/prover/isabelle/isar/statement.ts +0 -52
  585. package/src/prover/smt/solver/z3-license.txt +0 -10
  586. package/src/prover/tlaps-module.ts +0 -510
  587. package/src/prover/zenon/LICENSE +0 -32
@@ -1,13 +1,13 @@
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,
9
9
  getExactSquareRoot,
10
- type UpolynomialFactors,
10
+ mkFactors,
11
11
  } from "./upolynomial-factorization";
12
12
 
13
13
  export const NULL_VAR = -1;
@@ -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[] = [];
@@ -462,6 +988,15 @@ export class PolynomialManager {
462
988
  return polynomial.size === 0 ? NULL_VAR : polynomial.ms[0].maxVar;
463
989
  }
464
990
 
991
+ getMaxVarOfPolys(polynomials: readonly Polynomial[]) {
992
+ let result = NULL_VAR;
993
+ for (const polynomial of polynomials) {
994
+ const variable = this.maxVar(polynomial);
995
+ if (result === NULL_VAR || variable > result) result = variable;
996
+ }
997
+ return result;
998
+ }
999
+
465
1000
  degree(polynomial: Polynomial, variable: number) {
466
1001
  let result = 0;
467
1002
  for (const monomial of polynomial.ms) result = Math.max(result, monomial.degreeOf(variable));
@@ -495,29 +1030,47 @@ export class PolynomialManager {
495
1030
  return key;
496
1031
  }
497
1032
 
498
- private 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
+ ) {
499
1041
  this.som.reset();
500
- this.som.addmul(firstCoeff, this.unit, first);
501
- this.som.addmul(secondCoeff, this.unit, second);
1042
+ this.som.addmul(firstCoeff, firstMonomial, first);
1043
+ this.som.addmul(secondCoeff, secondMonomial, second);
502
1044
  return this.som.mk();
503
1045
  }
504
1046
 
1047
+ addmul(first: Polynomial, secondCoeff: bigint, second: Polynomial) {
1048
+ return this.addmulTerms(1n, this.unit, first, secondCoeff, this.unit, second);
1049
+ }
1050
+
505
1051
  add(first: Polynomial, second: Polynomial) {
506
- return this.addmul(1n, first, 1n, second);
1052
+ return this.addmulTerms(1n, this.unit, first, 1n, this.unit, second);
507
1053
  }
508
1054
 
509
1055
  sub(first: Polynomial, second: Polynomial) {
510
- return this.addmul(1n, first, -1n, second);
1056
+ return this.addmulTerms(1n, this.unit, first, this.normalizeNumeral(-1n), this.unit, second);
511
1057
  }
512
1058
 
513
- mul(first: Polynomial, second: Polynomial) {
514
- 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);
515
1061
  this.som.reset();
516
- for (let index = 0; index < first.size; index++)
1062
+ for (let index = 0; index < first.size; index++) {
1063
+ this.limit.checkpoint();
517
1064
  this.som.addmul(first.as[index], first.ms[index], second);
1065
+ }
1066
+ this.som.addTerm(constant, this.unit);
518
1067
  return this.som.mk();
519
1068
  }
520
1069
 
1070
+ mul(first: Polynomial, second: Polynomial) {
1071
+ return this.muladd(first, second, 0n);
1072
+ }
1073
+
521
1074
  mulTerm(coeff: bigint, monomial: Monomial, polynomial: Polynomial) {
522
1075
  if (coeff === 0n) return this.zero;
523
1076
  if (coeff === 1n && monomial === this.unit) return polynomial;
@@ -529,25 +1082,39 @@ export class PolynomialManager {
529
1082
  return this.mulTerm(coeff, this.unit, polynomial);
530
1083
  }
531
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
+
532
1095
  neg(polynomial: Polynomial) {
533
1096
  for (let index = 0; index < polynomial.size; index++)
534
- this.cheap.add(-polynomial.as[index], polynomial.ms[index]);
1097
+ this.cheap.add(this.negNumeral(polynomial.as[index]), polynomial.ms[index]);
535
1098
  return this.cheap.mk();
536
1099
  }
537
1100
 
538
- pw(polynomial: Polynomial, power: number) {
539
- if (power === 0) return this.one;
540
- let result = polynomial;
541
- for (let index = 1; index < power; index++) result = this.mul(result, polynomial);
542
- 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();
543
1108
  }
544
1109
 
545
- coeff(polynomial: Polynomial, variable: number, power: number) {
1110
+ coeffWithReduct(polynomial: Polynomial, variable: number, power: number, reduct: PolynomialRef) {
546
1111
  for (let index = 0; index < polynomial.size; index++) {
547
1112
  const monomial = polynomial.ms[index];
548
1113
  if (monomial.degreeOf(variable) === power)
549
1114
  this.cheap.add(polynomial.as[index], this.divX(monomial, variable));
1115
+ else this.cheap2.add(polynomial.as[index], monomial);
550
1116
  }
1117
+ reduct.set(this.cheap2.mk());
551
1118
  return this.cheap.mk();
552
1119
  }
553
1120
 
@@ -562,6 +1129,17 @@ export class PolynomialManager {
562
1129
  return result;
563
1130
  }
564
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
+
565
1143
  lc(polynomial: Polynomial, variable: number) {
566
1144
  return this.coeff(polynomial, variable, this.degree(polynomial, variable));
567
1145
  }
@@ -571,7 +1149,10 @@ export class PolynomialManager {
571
1149
  const monomial = polynomial.ms[index];
572
1150
  const degree = monomial.degreeOf(variable);
573
1151
  if (degree > 0)
574
- 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
+ );
575
1156
  }
576
1157
  return this.cheap.mk();
577
1158
  }
@@ -592,24 +1173,43 @@ export class PolynomialManager {
592
1173
  return result;
593
1174
  }
594
1175
 
595
- private icWithContent(polynomial: Polynomial): [bigint, Polynomial] {
596
- if (polynomial.size === 0) return [0n, polynomial];
597
- if (this.isConst(polynomial)) return [polynomial.as[0], this.one];
598
- let content = 0n;
599
- for (const coeff of polynomial.as) content = getGcd(content, coeff);
600
- 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();
601
1191
  for (let index = 0; index < polynomial.size; index++)
602
- this.cheap.add(polynomial.as[index] / content, polynomial.ms[index]);
603
- 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;
604
1195
  }
605
1196
 
606
- iccp(polynomial: Polynomial, variable: number): [bigint, Polynomial, Polynomial] {
607
- if (polynomial.size === 0) return [0n, this.one, polynomial];
608
- 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
+ }
609
1208
  const degree = this.degree(polynomial, variable);
610
1209
  if (degree === 0) {
611
- const [integer, content] = this.icWithContent(polynomial);
612
- return [integer, content, this.one];
1210
+ const integer = this.icWithContent(polynomial, c);
1211
+ pp.set(this.one);
1212
+ return integer;
613
1213
  }
614
1214
  const filter = Array.from({ length: degree + 1 }, () => 0);
615
1215
  const powers: number[] = [];
@@ -618,160 +1218,597 @@ export class PolynomialManager {
618
1218
  if (filter[power] === 0) powers.push(power);
619
1219
  filter[power] += monomial.size === (power > 0 ? 1 : 0) ? 1 : 2;
620
1220
  }
621
- const [integer, primitive] = this.icWithContent(polynomial);
622
- for (const power of powers) if (filter[power] === 1) return [integer, this.one, primitive];
623
- 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]));
624
1230
  for (let index = 1; index < powers.length; index++) {
625
- content = this.gcd(content, this.coeff(primitive, variable, powers[index]));
626
- 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
+ }
627
1238
  }
628
- content = this.flipSignIfLmNeg(content);
629
- 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;
630
1243
  }
631
1244
 
632
1245
  pp(polynomial: Polynomial, variable: number) {
633
- return this.iccp(polynomial, variable)[2];
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;
634
1251
  }
635
1252
 
636
- squareFree(polynomial: Polynomial): Polynomial {
637
- if (this.isConst(polynomial)) return polynomial;
638
- const variable = this.maxVar(polynomial);
639
- const [integer, content, primitive] = this.iccp(polynomial, variable);
640
- const squareFreeContent = this.squareFree(content);
641
- const g = this.gcd(primitive, this.derivative(primitive, variable));
642
- if (this.isConst(g) && this.eq(squareFreeContent, content)) return polynomial;
643
- const squareFreePrimitive = this.isConst(g) ? primitive : this.exactDiv(primitive, g);
644
- return this.mul(this.mulConst(integer, squareFreeContent), squareFreePrimitive);
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;
645
1261
  }
646
1262
 
647
- normalize(polynomial: Polynomial) {
648
- if (polynomial.size === 0) return polynomial;
649
- let g = 0n;
650
- for (const coeff of polynomial.as) g = getGcd(g, coeff);
651
- if (g === 1n) return polynomial;
652
- for (let index = 0; index < polynomial.size; index++)
653
- this.cheap.add(polynomial.as[index] / g, polynomial.ms[index]);
654
- return this.cheap.mk();
655
- }
656
-
657
- isNonzeroConstCoeff(polynomial: Polynomial, variable: number, power: number) {
658
- const coeff = this.getConstCoeff(polynomial, variable, power);
659
- return coeff !== null && coeff !== 0n;
660
- }
661
-
662
- exactDiv(polynomial: Polynomial, divisor: Polynomial) {
663
- if (polynomial.size === 0) return polynomial;
664
- const remainder = this.som;
665
- const quotient = this.som2;
666
- remainder.reset();
667
- quotient.reset();
668
- remainder.add(polynomial);
669
- const maxPos = divisor.getGradedLexMaxPos();
670
- const divisorMonomial = divisor.ms[maxPos];
671
- 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);
672
1293
  while (true) {
673
- const remainderPos = remainder.getGradedLexMaxPos();
674
- if (remainderPos === -1) {
675
- remainder.reset();
676
- 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;
677
1303
  }
678
- const monomial = this.divMonomials(remainder.ms[remainderPos], divisorMonomial);
679
- if (monomial === null) throw new SmtInvariantError("exact_div: the divisor does not divide");
680
- const coeff = remainder.as[remainderPos] / divisorCoeff;
681
- quotient.addTerm(coeff, monomial);
682
- 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);
683
1319
  }
684
1320
  }
685
1321
 
686
- exactPseudoDivision(
687
- polynomial: Polynomial,
688
- divisor: Polynomial,
689
- variable: number,
690
- isQuotient = true,
691
- ) {
692
- 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();
693
1330
  }
694
1331
 
695
- pseudoRemainder(polynomial: Polynomial, divisor: Polynomial, variable: number) {
696
- 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);
697
1355
  }
698
1356
 
699
- private pseudoDivisionCore(
700
- polynomial: Polynomial,
701
- divisor: Polynomial,
702
- variable: number,
703
- isExact: boolean,
704
- isQuotient: boolean,
1357
+ private craCombineImages(
1358
+ c1: Polynomial,
1359
+ b1: bigint,
1360
+ c2: Polynomial,
1361
+ b2: bigint,
1362
+ r: PolynomialRef,
705
1363
  ) {
706
- const degA = this.degree(polynomial, variable);
707
- const degB = this.degree(divisor, variable);
708
- if (degB === 0) {
709
- const steps = isExact ? degA + 1 : 1;
710
- if (!isQuotient || !isExact || degA === 0)
711
- return { quotient: polynomial, remainder: this.zero, steps };
712
- return {
713
- quotient: this.mul(polynomial, this.pw(divisor, degA)),
714
- remainder: this.zero,
715
- steps,
716
- };
717
- }
718
- const lcB = this.coeff(divisor, variable, degB);
719
- const reductB = this.reduct(divisor, variable, degB);
720
- let remainder = polynomial;
721
- let quotient = this.zero;
722
- 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;
723
1380
  while (true) {
724
- const degR = this.degree(remainder, variable);
725
- if (degB > degR) {
726
- const exactSteps = degA - degB + 1;
727
- if (isExact && steps < exactSteps) {
728
- const power = this.pw(lcB, exactSteps - steps);
729
- if (isQuotient) quotient = this.mul(power, quotient);
730
- remainder = this.mul(power, remainder);
731
- }
732
- 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;
733
1384
  }
734
- this.som.reset();
735
- this.som2.reset();
736
- for (let index = 0; index < remainder.size; index++) {
737
- const monomial = remainder.ms[index];
738
- const coeff = remainder.as[index];
739
- if (monomial.degreeOf(variable) === degR) {
740
- const shifted = this.divXk(monomial, variable, degB);
741
- if (isQuotient) this.som2.addTerm(coeff, shifted);
742
- this.som.addmul(-coeff, shifted, reductB);
743
- } 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;
744
1388
  }
745
- remainder = this.som.mk();
746
- if (isQuotient) {
747
- for (let index = 0; index < quotient.size; index++)
748
- this.som2.addmul(quotient.as[index], quotient.ms[index], lcB);
749
- 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++;
750
1402
  }
751
- steps++;
752
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;
1472
+ }
1473
+ }
1474
+ this.gcdPrs(u, v, x, r);
1475
+ release();
753
1476
  }
754
1477
 
755
- exactPseudoRemainder(polynomial: Polynomial, divisor: Polynomial, variable: number) {
756
- 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;
757
1571
  }
758
1572
 
759
- reduct(polynomial: Polynomial, variable: number, power: number) {
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();
1588
+ }
1589
+
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;
760
1610
  for (let index = 0; index < polynomial.size; index++)
761
- if (polynomial.ms[index].degreeOf(variable) !== power)
762
- this.cheap.add(polynomial.as[index], polynomial.ms[index]);
763
- 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;
764
1619
  }
765
1620
 
766
- private getMaxDegrees(polynomial: Polynomial) {
767
- const degrees = new Map<number, number>();
768
- for (const monomial of polynomial.ms)
769
- for (let index = 0; index < monomial.size; index++) {
770
- const variable = monomial.vars[index];
771
- if (monomial.degrees[index] > (degrees.get(variable) ?? 0))
772
- 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;
773
1712
  }
774
- 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
+ }
775
1812
  }
776
1813
 
777
1814
  private getVarMaxDegrees(polynomial: Polynomial) {
@@ -780,207 +1817,666 @@ export class PolynomialManager {
780
1817
  );
781
1818
  }
782
1819
 
783
- // Deviation from Z3: subresultant PRS (gcd_prs), not mod_gcd, which can return 2 for coprime inputs (polynomial.cpp:4815).
784
- gcd(first: Polynomial, second: Polynomial): Polynomial {
785
- if (first.size === 0) return this.flipSignIfLmNeg(second);
786
- if (second.size === 0) return this.flipSignIfLmNeg(first);
787
- if (first === second) return this.flipSignIfLmNeg(first);
788
- if (this.isConst(first) || this.isConst(second))
789
- return this.mkConst(getGcd(this.getIc(second), this.getIc(first)));
790
- const firstDegrees = this.getVarMaxDegrees(first);
791
- const secondDegrees = this.getVarMaxDegrees(second);
792
- 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);
793
1845
  for (let index = 0; index < size; index++) {
794
- const firstVar = firstDegrees[index][0];
795
- const secondVar = secondDegrees[index][0];
796
- if (firstVar < secondVar) return this.gcdContent(first, firstVar, second);
797
- if (firstVar > secondVar) return this.gcdContent(second, secondVar, first);
798
- }
799
- if (size < firstDegrees.length) return this.gcdContent(first, firstDegrees[size][0], second);
800
- if (size < secondDegrees.length) return this.gcdContent(second, secondDegrees[size][0], first);
801
- return this.gcdPrs(first, second, firstDegrees[size - 1][0]);
802
- }
803
-
804
- private gcdContent(polynomial: Polynomial, variable: number, other: Polynomial) {
805
- const [integer, content] = this.iccp(polynomial, variable);
806
- return this.gcd(this.mulConst(integer, content), other);
807
- }
808
-
809
- private gcdPrs(first: Polynomial, second: Polynomial, variable: number) {
810
- const [u, v] =
811
- this.degree(first, variable) < this.degree(second, variable)
812
- ? [second, first]
813
- : [first, second];
814
- const [integerU, contentU, primitiveU] = this.iccp(u, variable);
815
- const [integerV, contentV, primitiveV] = this.iccp(v, variable);
816
- const contentGcd = this.gcd(contentU, contentV);
817
- const integerGcd = getGcd(integerU, integerV);
818
- let ppU = primitiveU;
819
- let ppV = primitiveV;
820
- let g = this.one;
821
- let h = this.one;
822
- while (true) {
823
- const delta = this.degree(ppU, variable) - this.degree(ppV, variable);
824
- const remainder = this.exactPseudoRemainder(ppU, ppV, variable);
825
- if (remainder.size === 0) {
826
- const result = this.pp(this.flipSignIfLmNeg(ppV), variable);
827
- 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;
828
1851
  }
829
- if (this.isConst(remainder)) return this.mulConst(integerGcd, contentGcd);
830
- ppU = ppV;
831
- ppV = this.exactDiv(remainder, g);
832
- for (let index = 0; index < delta; index++) ppV = this.exactDiv(ppV, h);
833
- g = this.lc(ppU, variable);
834
- let newH = this.one;
835
- for (let index = 0; index < delta; index++) newH = this.mul(newH, g);
836
- for (let index = 1; index < delta; index++) newH = this.exactDiv(newH, h);
837
- h = newH;
1852
+ if (xu > xv) {
1853
+ this.gcdContent(v, xv, u, r);
1854
+ return;
1855
+ }
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;
838
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);
839
1875
  }
840
1876
 
841
- private getMinDegreeVar(polynomial: Polynomial) {
842
- let result = NULL_VAR;
843
- let minDegree = Infinity;
844
- for (const [variable, degree] of this.getMaxDegrees(polynomial))
845
- if (degree < minDegree) {
846
- result = variable;
847
- 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;
848
1908
  }
849
- 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();
850
1913
  }
851
1914
 
852
- factor(polynomial: Polynomial): Factors {
853
- const result: Factors = { constant: 1n, factors: [], degrees: [] };
854
- if (polynomial.size === 0) result.constant = 0n;
855
- 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();
856
1939
  return result;
857
1940
  }
858
1941
 
859
- 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) {
860
1984
  if (this.isConst(polynomial)) {
861
- result.constant *= polynomial.as[0];
1985
+ r.set(polynomial);
862
1986
  return;
863
1987
  }
864
- const variable = this.getMinDegreeVar(polynomial);
865
- const [integer, content, primitive] = this.iccp(polynomial, variable);
866
- result.constant *= integer;
867
- this.factorCore(content, result);
868
- let square = this.gcd(primitive, this.derivative(primitive, variable));
869
- if (this.isConst(square)) {
870
- 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));
871
2008
  return;
872
2009
  }
873
- let product = this.exactDiv(primitive, square);
874
- for (let multiplicity = 1; !this.isConst(product); multiplicity++) {
875
- const next = this.gcd(product, square);
876
- const factor = this.exactDiv(product, next);
877
- if (!this.isConst(factor)) this.factorSqfPp(factor, variable, multiplicity, result);
878
- else if (factor.as[0] === -1n && multiplicity % 2 === 1) result.constant = -result.constant;
879
- square = this.exactDiv(square, next);
880
- 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++;
881
2096
  }
882
2097
  }
883
2098
 
884
- private factorSqfPp(polynomial: Polynomial, variable: number, k: number, result: Factors) {
885
- const degree = this.degree(polynomial, variable);
886
- if (degree === 1) this.pushFactor(result, polynomial, k);
887
- else if (this.isUnivariate(polynomial)) this.factorSqfPpUniv(polynomial, k, result);
888
- else if (degree === 2) this.factorQuadratic(polynomial, variable, k, result);
889
- else if (!this.factorMultivariate(polynomial, variable, k, result))
890
- 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();
891
2103
  }
892
2104
 
893
- private pushFactor(result: Factors, polynomial: Polynomial, k: number) {
894
- result.factors.push(polynomial);
895
- 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;
896
2110
  }
897
2111
 
898
- toCoeffs(polynomial: Polynomial) {
899
- const coeffs = Array.from({ length: this.totalDegree(polynomial) + 1 }, () => 0n);
900
- for (let index = 0; index < polynomial.size; index++)
901
- coeffs[polynomial.ms[index].totalDegree] = polynomial.as[index];
902
- 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);
903
2120
  }
904
2121
 
905
- fromCoeffs(coeffs: readonly bigint[], variable: number) {
906
- for (let power = coeffs.length - 1; power >= 0; power--)
907
- this.cheap.add(coeffs[power], this.mkPower(variable, power));
908
- 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
+ }
909
2145
  }
910
2146
 
911
- private factorSqfPpUniv(polynomial: Polynomial, k: number, result: Factors) {
912
- const variable = this.maxVar(polynomial);
913
- const fs: UpolynomialFactors = { constant: 1n, factors: [], degrees: [] };
914
- factorSquareFree(this.um, this.toCoeffs(polynomial), fs, 1, DEFAULT_FACTOR_PARAMS);
915
- if (fs.factors.length === 1 && fs.degrees[0] === 1) {
916
- this.pushFactor(result, polynomial, k);
917
- 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);
918
2165
  }
919
- for (let index = 0; index < fs.factors.length; index++)
920
- this.pushFactor(result, this.fromCoeffs(fs.factors[index], variable), k * fs.degrees[index]);
921
- if (fs.constant === -1n && k % 2 === 1) result.constant = -result.constant;
922
2166
  }
923
2167
 
924
- private factorQuadratic(polynomial: Polynomial, variable: number, k: number, result: Factors) {
925
- let a = this.coeff(polynomial, variable, 2);
926
- let b = this.coeff(polynomial, variable, 1);
927
- let c = this.coeff(polynomial, variable, 0);
928
- const isFlipped = a.as[a.getGradedLexMaxPos()] < 0n;
929
- if (isFlipped) {
930
- a = this.neg(a);
931
- b = this.neg(b);
932
- 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;
2185
+ }
2186
+ if (this.isConst(b.get())) {
2187
+ this.pw(b.get(), this.degree(a.get(), x), result);
2188
+ b.reset();
2189
+ a.reset();
2190
+ return;
933
2191
  }
934
- const root = this.sqrt(this.addmul(1n, this.mul(b, b), -4n, this.mul(a, c)));
935
- if (root === null) {
936
- this.pushFactor(result, polynomial, 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);
937
2266
  return;
938
2267
  }
939
- if (isFlipped && k % 2 === 1) result.constant = -result.constant;
940
- const linear = this.add(this.mulTerm(2n, this.mkPower(variable, 1), a), b);
941
- this.pushFactor(result, this.pp(this.sub(linear, root), variable), k);
942
- this.pushFactor(result, this.pp(this.add(linear, root), variable), k);
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();
943
2440
  }
944
2441
 
945
2442
  private getTermSquareRoot(polynomial: Polynomial, position: number) {
946
- const monomial = polynomial.ms[position];
947
- if (monomial.degrees.some((degree) => degree % 2 === 1)) return null;
2443
+ if (!polynomial.ms[position].isSquare()) return null;
948
2444
  return getExactSquareRoot(polynomial.as[position]);
949
2445
  }
950
2446
 
951
- sqrt(polynomial: Polynomial) {
952
- if (polynomial.size === 0) return polynomial;
953
- if (this.getTermSquareRoot(polynomial, this.getGradedLexMinPos(polynomial)) === null)
954
- 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;
955
2453
  const maxPos = polynomial.getGradedLexMaxPos();
956
2454
  const a = this.getTermSquareRoot(polynomial, maxPos);
957
- if (a === null) return null;
958
- const maxMonomial = polynomial.ms[maxPos];
959
- const m1 = this.mkMonomial(
960
- maxMonomial.vars,
961
- maxMonomial.degrees.map((degree) => degree / 2),
962
- );
2455
+ if (a === null) return false;
2456
+ const m1 = this.sqrtMonomial(polynomial.ms[maxPos]);
963
2457
  const root = this.som;
964
2458
  const rest = this.som2;
965
2459
  root.reset();
966
2460
  rest.reset();
967
- const twoA = 2n * a;
2461
+ const twoA = a * 2n;
968
2462
  root.addTerm(a, m1);
969
2463
  for (let index = 0; index < polynomial.size; index++)
970
2464
  if (index !== maxPos) rest.addTerm(polynomial.as[index], polynomial.ms[index]);
971
2465
  while (true) {
2466
+ this.limit.checkpoint();
972
2467
  const restMax = rest.getGradedLexMaxPos();
973
2468
  if (restMax === -1) {
2469
+ r.set(root.mk());
974
2470
  rest.reset();
975
- return root.mk();
2471
+ return true;
976
2472
  }
977
2473
  const monomial = this.divMonomials(rest.ms[restMax], m1);
978
- if (monomial === null || rest.as[restMax] % twoA !== 0n) {
979
- root.reset();
2474
+ if (monomial === null || !this.dividesNumeral(twoA, rest.as[restMax])) {
980
2475
  rest.reset();
981
- return null;
2476
+ root.reset();
2477
+ return false;
982
2478
  }
983
- const coeff = floorDiv(rest.as[restMax], twoA);
2479
+ const coeff = this.divNumeral(rest.as[restMax], twoA);
984
2480
  const rootSize = root.as.length;
985
2481
  for (let index = 0; index < rootSize; index++) {
986
2482
  if (root.as[index] === 0n) continue;
@@ -991,13 +2487,6 @@ export class PolynomialManager {
991
2487
  }
992
2488
  }
993
2489
 
994
- private getGradedLexMinPos(polynomial: Polynomial) {
995
- let minPos = 0;
996
- for (let index = 1; index < polynomial.size; index++)
997
- if (gradedLexCompare(polynomial.ms[index], polynomial.ms[minPos]) < 0) minPos = index;
998
- return minPos;
999
- }
1000
-
1001
2490
  getVars(polynomial: Polynomial) {
1002
2491
  const vars: number[] = [];
1003
2492
  for (const monomial of polynomial.ms)
@@ -1005,11 +2494,22 @@ export class PolynomialManager {
1005
2494
  return vars;
1006
2495
  }
1007
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
+
1008
2508
  substitute(polynomial: Polynomial, vars: readonly number[], values: readonly bigint[]) {
1009
2509
  this.som.reset();
1010
2510
  for (let index = 0; index < polynomial.size; index++) {
1011
2511
  const monomial = polynomial.ms[index];
1012
- let coeff = polynomial.as[index];
2512
+ let coeff = this.normalizeNumeral(polynomial.as[index]);
1013
2513
  const keptVars: number[] = [];
1014
2514
  const keptDegrees: number[] = [];
1015
2515
  for (let power = 0; power < monomial.size; power++) {
@@ -1017,7 +2517,11 @@ export class PolynomialManager {
1017
2517
  if (position === -1) {
1018
2518
  keptVars.push(monomial.vars[power]);
1019
2519
  keptDegrees.push(monomial.degrees[power]);
1020
- } 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
+ );
1021
2525
  }
1022
2526
  this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
1023
2527
  }
@@ -1035,9 +2539,11 @@ export class PolynomialManager {
1035
2539
  this.divX(monomial, variable),
1036
2540
  );
1037
2541
  }
1038
- for (let step = 1; step <= degree; step++)
2542
+ for (let step = 1; step <= degree; step++) {
2543
+ this.limit.checkpoint();
1039
2544
  for (let power = degree - step; power <= degree - 1; power++)
1040
2545
  coeffs[power].addmulBuffer(value, this.unit, coeffs[power + 1]);
2546
+ }
1041
2547
  this.som.reset();
1042
2548
  for (let power = 0; power <= degree; power++)
1043
2549
  this.som.addmulBuffer(1n, this.mkPower(variable, power), coeffs[power]);
@@ -1072,377 +2578,538 @@ export class PolynomialManager {
1072
2578
  if (value !== undefined && monomial.degreeOf(variable) === 0)
1073
2579
  coeff *= value.den ** BigInt(maxDegree);
1074
2580
  }
1075
- this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
2581
+ if (coeff !== 0n) this.som.addTerm(coeff, this.mkMonomial(keptVars, keptDegrees));
1076
2582
  }
1077
2583
  return this.som.mk(true);
1078
2584
  }
1079
2585
 
1080
- private muladd(first: Polynomial, second: Polynomial, constant: bigint) {
1081
- if (first.size === 0 || second.size === 0) return this.mkConst(constant);
1082
- this.som.reset();
1083
- for (let index = 0; index < first.size; index++)
1084
- this.som.addmul(first.as[index], first.ms[index], second);
1085
- this.som.addTerm(constant, this.unit);
1086
- 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();
1087
2595
  }
1088
2596
 
1089
- private compose(polynomial: Polynomial, inner: Polynomial) {
1090
- if (this.isConst(polynomial)) return polynomial;
1091
- const variable = this.maxVar(polynomial);
1092
- const degree = this.degree(polynomial, variable);
1093
- const coeffs = Array.from({ length: degree + 1 }, () => 0n);
1094
- for (let index = 0; index < polynomial.size; index++)
1095
- coeffs[polynomial.ms[index].degreeOf(variable)] = polynomial.as[index];
1096
- let result = this.mkConst(coeffs[degree]);
1097
- for (let power = degree - 1; power >= 0; power--)
1098
- 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
+ }
1099
2605
  return result;
1100
2606
  }
1101
2607
 
1102
- composeXMinusY(polynomial: Polynomial, variable: number) {
1103
- const x = this.maxVar(polynomial);
1104
- if (variable === x) return this.coeff(polynomial, x, 0);
1105
- 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);
1106
2619
  }
1107
2620
 
1108
- composeXDivY(polynomial: Polynomial, variable: number) {
1109
- if (this.isConst(polynomial)) return polynomial;
1110
- const x = this.maxVar(polynomial);
1111
- const degree = this.degree(polynomial, x);
1112
- for (let index = 0; index < polynomial.size; index++) {
1113
- const power = polynomial.ms[index].degreeOf(x);
1114
- const powers: [number, number][] =
1115
- x < variable
1116
- ? [
1117
- [x, power],
1118
- [variable, degree - power],
1119
- ]
1120
- : [
1121
- [variable, degree - power],
1122
- [x, power],
1123
- ];
1124
- const kept = powers.filter((entry) => entry[1] > 0);
1125
- this.cheap.add(
1126
- polynomial.as[index],
1127
- this.mkMonomial(
1128
- kept.map((entry) => entry[0]),
1129
- kept.map((entry) => entry[1]),
1130
- ),
1131
- );
2621
+ factor(polynomial: Polynomial, r: Factors) {
2622
+ if (polynomial.size === 0) {
2623
+ r.constant = 0n;
2624
+ return;
1132
2625
  }
1133
- return this.cheap.mk();
2626
+ this.factorCore(polynomial, r);
1134
2627
  }
1135
2628
 
1136
- resultant(first: Polynomial, second: Polynomial, variable: number) {
1137
- if (first.size === 0 || second.size === 0) return this.zero;
1138
- if (this.isConst(first))
1139
- return this.isConst(second) ? this.one : this.pw(first, this.degree(second, variable));
1140
- if (this.isConst(second)) return this.pw(second, this.degree(first, variable));
1141
- const [integerA, contentA, ppA] = this.iccp(first, variable);
1142
- const [integerB, contentB, ppB] = this.iccp(second, variable);
1143
- const scale = this.mul(
1144
- this.pw(this.mulConst(integerA, contentA), this.degree(second, variable)),
1145
- this.pw(this.mulConst(integerB, contentB), this.degree(first, variable)),
1146
- );
1147
- let a = ppA;
1148
- let b = ppB;
1149
- let sign = 1;
1150
- if (this.degree(a, variable) < this.degree(b, variable)) {
1151
- if (this.degree(a, variable) % 2 === 1 && this.degree(b, variable) % 2 === 1) sign = -1;
1152
- [a, b] = [b, a];
1153
- }
1154
- let g = this.one;
1155
- let h = this.one;
1156
- while (true) {
1157
- const degreeA = this.degree(a, variable);
1158
- const degreeB = this.degree(b, variable);
1159
- const delta = degreeA - degreeB;
1160
- if (degreeA % 2 === 1 && degreeB % 2 === 1) sign = -sign;
1161
- const remainder = this.exactPseudoRemainder(a, b, variable);
1162
- a = b;
1163
- b = this.exactDiv(remainder, g);
1164
- for (let index = 0; index < delta; index++) b = this.exactDiv(b, h);
1165
- g = this.lc(a, variable);
1166
- let nextH = this.pw(g, delta);
1167
- for (let index = 1; index < delta; index++) nextH = this.exactDiv(nextH, h);
1168
- h = nextH;
1169
- if (this.degree(b, variable) === 0) {
1170
- const degree = this.degree(a, variable);
1171
- let lastH = this.pw(this.lc(b, variable), degree);
1172
- for (let index = 1; index < degree; index++) lastH = this.exactDiv(lastH, h);
1173
- const result = this.mul(scale, lastH);
1174
- 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);
1175
2659
  }
1176
2660
  }
2661
+ d.reset();
2662
+ a.reset();
2663
+ b.reset();
2664
+ cPrime.reset();
2665
+ cPart.reset();
2666
+ pp.reset();
2667
+ c.reset();
1177
2668
  }
1178
2669
 
1179
- private isSquareFreeIn(polynomial: Polynomial, variable: number) {
1180
- if (this.isConst(polynomial)) return polynomial.size > 0;
1181
- 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);
1182
2753
  }
1183
2754
 
1184
- private isPrimitive(polynomial: Polynomial, variable: number) {
1185
- 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);
1186
2761
  }
1187
2762
 
1188
- private factorMultivariate(polynomial: Polynomial, x: number, k: number, result: Factors) {
2763
+ private tryMultivarFactor(polynomial: Polynomial, r: Factors, x: number, k: number) {
1189
2764
  const allVars = this.getVars(polynomial);
1190
- const mainVars = [
1191
- x,
1192
- ...allVars
1193
- .filter((variable) => variable !== x)
1194
- .map((variable) => [this.degree(polynomial, variable), variable])
1195
- .sort((first, second) => second[0] - first[0] || second[1] - first[1])
1196
- .filter((entry) => entry[0] > 1)
1197
- .map((entry) => entry[1]),
1198
- ];
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);
1199
2771
  for (const mainVar of mainVars) {
1200
2772
  const degMain = this.degree(polynomial, mainVar);
1201
2773
  if (degMain <= 1) continue;
1202
2774
  for (const liftVar of allVars) {
1203
2775
  if (liftVar === mainVar) continue;
1204
- const evalVars = allVars.filter((variable) => variable !== mainVar && variable !== liftVar);
1205
- 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);
1206
2782
  for (let combo = 0; combo < maxCombos; combo++) {
1207
- const bivariate =
1208
- evalVars.length === 0
1209
- ? polynomial
1210
- : this.substitute(
1211
- polynomial,
1212
- evalVars,
1213
- evalVars.map(
1214
- (_variable, index) =>
1215
- FACTOR_EVAL_VALUES[
1216
- Math.floor(combo / FACTOR_EVAL_VALUES.length ** index) %
1217
- FACTOR_EVAL_VALUES.length
1218
- ],
1219
- ),
1220
- );
1221
- if (this.degree(bivariate, mainVar) !== degMain) continue;
1222
- const degLift = this.degree(bivariate, liftVar);
1223
- if (degLift === 0) continue;
1224
- for (const point of FACTOR_EVAL_VALUES) {
1225
- const univariate = this.substitute(bivariate, [liftVar], [point]);
1226
- if (!this.isUnivariate(univariate)) continue;
1227
- if (this.degree(univariate, mainVar) !== degMain) continue;
1228
- if (!this.isSquareFreeIn(univariate, mainVar)) continue;
1229
- const univariateFs: UpolynomialFactors = { constant: 1n, factors: [], degrees: [] };
1230
- factorSquareFree(
1231
- this.um,
1232
- this.um.getPrimitive(this.toCoeffs(univariate)),
1233
- univariateFs,
1234
- 1,
1235
- DEFAULT_FACTOR_PARAMS,
1236
- );
1237
- const factorCount = univariateFs.factors.length;
1238
- if (factorCount <= 1) continue;
1239
- const translated = this.translate(bivariate, liftVar, point);
1240
- const lcPolynomial = this.coeff(translated, mainVar, degMain);
1241
- const lcAtZero = this.isConst(lcPolynomial)
1242
- ? (lcPolynomial.as[0] ?? 0n)
1243
- : this.getConstValue(this.substitute(lcPolynomial, [liftVar], [0n]));
1244
- if (lcAtZero === null) continue;
1245
- for (const prime of FACTOR_PRIMES) {
1246
- if (getGcd(prime, lcAtZero) !== 1n) continue;
1247
- for (let split = 1; split <= Math.floor(factorCount / 2); split++) {
1248
- let h1 = univariateFs.factors[0];
1249
- for (let index = 1; index < split; index++)
1250
- h1 = this.um.mul(h1, univariateFs.factors[index]);
1251
- let h2 = univariateFs.factors[split];
1252
- for (let index = split + 1; index < factorCount; index++)
1253
- h2 = this.um.mul(h2, univariateFs.factors[index]);
1254
- const lifted = this.liftBivariate(
1255
- translated,
1256
- mainVar,
1257
- liftVar,
1258
- degLift,
1259
- this.um.flipSignIfLmNeg(h1),
1260
- this.um.flipSignIfLmNeg(h2),
1261
- lcAtZero,
1262
- prime,
1263
- );
1264
- if (lifted === null) continue;
1265
- const candidates = lifted.map((factor) => this.translate(factor, liftVar, -point));
1266
- if (evalVars.length === 0) {
1267
- for (const candidate of candidates) {
1268
- if (this.isConst(candidate) || this.degree(candidate, x) === 0) continue;
1269
- this.pushSmallFactor(candidate, x, k, result);
1270
- }
1271
- return true;
1272
- }
1273
- for (const candidate of candidates) {
1274
- if (this.isConst(candidate)) continue;
1275
- const division = this.exactPseudoDivision(
1276
- polynomial,
1277
- candidate,
1278
- this.maxVar(candidate),
1279
- );
1280
- if (division.remainder.size !== 0) continue;
1281
- if (!this.eq(this.mul(candidate, division.quotient), polynomial)) continue;
1282
- for (const part of [candidate, division.quotient]) {
1283
- if (this.isConst(part)) result.constant *= part.as[0];
1284
- else if (this.degree(part, x) !== 0) this.pushSmallFactor(part, x, k, result);
1285
- }
1286
- return true;
1287
- }
1288
- }
1289
- }
1290
- }
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;
1291
2799
  }
1292
2800
  }
1293
2801
  }
1294
2802
  return false;
1295
2803
  }
1296
2804
 
1297
- private pushSmallFactor(polynomial: Polynomial, x: number, k: number, result: Factors) {
1298
- const degree = this.degree(polynomial, x);
1299
- if (degree === 2 && this.isPrimitive(polynomial, x) && this.isSquareFreeIn(polynomial, x))
1300
- this.factorQuadratic(polynomial, x, k, result);
1301
- 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;
1302
2938
  }
1303
2939
 
1304
- private getConstValue(polynomial: Polynomial) {
1305
- if (!this.isConst(polynomial)) return null;
1306
- 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;
1307
3006
  }
1308
3007
 
1309
- private liftBivariate(
3008
+ private tryBivarHenselLift(
1310
3009
  q: Polynomial,
1311
3010
  x: number,
1312
3011
  y: number,
1313
3012
  degY: number,
1314
3013
  h1: readonly bigint[],
1315
3014
  h2: readonly bigint[],
1316
- lc: bigint,
3015
+ lcValue: bigint,
1317
3016
  prime: bigint,
3017
+ f1Out: PolynomialRef,
3018
+ f2Out: PolynomialRef,
1318
3019
  ) {
1319
- const zp = new UpolynomialManager(prime);
3020
+ const zp = new UpolynomialManager(this.limit, prime);
1320
3021
  const f1 = zp.mkMonic(zp.set(h1));
1321
3022
  const f2 = zp.mkMonic(zp.set(h2));
1322
3023
  const ext = zp.extGcd(f1, f2);
1323
- if (ext.d.length !== 1 || ext.d[0] !== 1n) return null;
3024
+ if (ext.d.length !== 1 || ext.d[0] !== 1n) return false;
1324
3025
  const qCoeffs: bigint[][] = [];
1325
- for (let power = 0; power <= degY; power++) {
1326
- const coeff = this.coeff(q, y, power);
1327
- if (coeff.size !== 0 && !this.isUnivariate(coeff) && !this.isConst(coeff)) return null;
1328
- 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;
1329
3033
  }
1330
3034
  const f1Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
1331
3035
  const f2Coeffs: bigint[][] = Array.from({ length: degY + 1 }, () => []);
1332
3036
  f1Coeffs[0] = zp.set(f1);
1333
- f2Coeffs[0] = zp.mulConst(f2, zp.normalizeNumeral(lc));
1334
- const lcInv = zp.inv(lc);
1335
- for (let power = 1; power <= degY; power++) {
1336
- let error = zp.set(qCoeffs[power]);
1337
- for (let first = 0; first <= power; first++) {
1338
- const second = power - first;
1339
- 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;
1340
3047
  if (f1Coeffs[first].length === 0 || f2Coeffs[second].length === 0) continue;
1341
- error = zp.sub(error, zp.mul(f1Coeffs[first], f2Coeffs[second]));
1342
- }
1343
- if (error.length === 0) continue;
1344
- const a = zp.divRem(zp.mul(error, ext.v), f1).remainder;
1345
- const b = zp.divRem(zp.mul(error, ext.u), f2).remainder;
1346
- f1Coeffs[power] = zp.mulConst(a, lcInv);
1347
- f2Coeffs[power] = zp.set(b);
1348
- }
1349
- const toPolynomial = (coeffs: readonly bigint[][]) => {
1350
- let result = this.zero;
1351
- for (let power = 0; power <= degY; power++) {
1352
- if (coeffs[power].length === 0) continue;
1353
- const univariate = this.fromCoeffs(coeffs[power], x);
1354
- if (univariate.size === 0) continue;
1355
- result = this.add(result, this.mulTerm(1n, this.mkPower(y, power), univariate));
3048
+ e = zp.sub(e, zp.mul(f1Coeffs[first], f2Coeffs[second]));
1356
3049
  }
1357
- return result;
1358
- };
1359
- const first = toPolynomial(f1Coeffs);
1360
- const second = toPolynomial(f2Coeffs);
1361
- return this.eq(this.mul(first, second), q) ? [first, second] : null;
1362
- }
1363
-
1364
- pscChain(first: Polynomial, second: Polynomial, variable: number) {
1365
- const chain =
1366
- this.degree(first, variable) >= this.degree(second, variable)
1367
- ? this.pscChainCore(first, second, variable)
1368
- : this.pscChainCore(second, first, variable);
1369
- return chain.length === 0 ? [this.zero] : chain.reverse();
1370
- }
1371
-
1372
- private pscChainCore(p: Polynomial, q: Polynomial, x: number) {
1373
- const chain: Polynomial[] = [];
1374
- let s = this.pw(this.lc(q, x), this.degree(p, x) - this.degree(q, x));
1375
- let a = q;
1376
- let b = this.exactPseudoRemainder(p, this.neg(q), x);
1377
- while (b.size > 0) {
1378
- const d = this.degree(a, x);
1379
- const e = this.degree(b, x);
1380
- const principal = this.coeff(b, x, d - 1);
1381
- if (principal.size > 0) chain.push(principal);
1382
- let c = b;
1383
- if (d - e > 1) {
1384
- c = this.getSeLazard(d, s, b, x);
1385
- const principalE = this.coeff(c, x, e);
1386
- if (principalE.size > 0) chain.push(principalE);
1387
- }
1388
- if (e === 0) break;
1389
- b = this.getOptimizedSe1(d, e, a, b, c, s, x);
1390
- a = c;
1391
- 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);
1392
3055
  }
1393
- return chain;
3056
+ return this.reconstructLiftedFactors(q, x, y, degY, f1Coeffs, f2Coeffs, f1Out, f2Out);
1394
3057
  }
1395
3058
 
1396
- private getSeLazard(d: number, lcSd: Polynomial, sd1: Polynomial, x: number) {
1397
- let n = d - this.degree(sd1, x) - 1;
1398
- if (n === 0) return sd1;
1399
- const lcSd1 = this.lc(sd1, x);
1400
- let a = 1 << (31 - Math.clz32(n));
1401
- let c = lcSd1;
1402
- n -= a;
1403
- while (a !== 1) {
1404
- a /= 2;
1405
- c = this.exactDiv(this.mul(c, c), lcSd);
1406
- if (n >= a) {
1407
- c = this.exactDiv(this.mul(c, lcSd1), lcSd);
1408
- 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();
1409
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);
1410
3088
  }
1411
- 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;
1412
3100
  }
1413
3101
 
1414
- private getOptimizedSe1(
1415
- d: number,
1416
- e: number,
1417
- a: Polynomial,
1418
- sd1: Polynomial,
1419
- se: Polynomial,
1420
- s: Polynomial,
1421
- x: number,
1422
- ) {
1423
- const cd1 = this.lc(sd1, x);
1424
- const lcSe = this.lc(se, x);
1425
- const getPower = (power: number) => (power === 0 ? this.one : this.mkVar(x, power));
1426
- const h: Polynomial[] = [];
1427
- for (let j = 0; j < e; j++) h.push(this.mul(lcSe, getPower(j)));
1428
- h.push(this.sub(this.mul(lcSe, getPower(e)), se));
1429
- const xPolynomial = this.mkVar(x);
1430
- for (let j = e + 1; j < d; j++) {
1431
- const xh = this.mul(xPolynomial, h[j - 1]);
1432
- h.push(this.sub(xh, this.exactDiv(this.mul(this.coeff(xh, x, e), sd1), cd1)));
1433
- }
1434
- let sum = this.zero;
1435
- for (let j = 0; j < d; j++) sum = this.add(sum, this.mul(this.coeff(a, x, j), h[j]));
1436
- const dPolynomial = this.exactDiv(sum, this.lc(a, x));
1437
- const xh = this.mul(xPolynomial, h[d - 1]);
1438
- const result = this.exactDiv(
1439
- this.sub(this.mul(cd1, this.add(xh, dPolynomial)), this.mul(this.coeff(xh, x, e), sd1)),
1440
- s,
1441
- );
1442
- 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;
1443
3106
  }
1444
3107
 
1445
- 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
+ ) {
1446
3113
  if (polynomial.size === 0) return ops.fromInteger(0n);
1447
3114
  if (this.isConst(polynomial)) return ops.fromInteger(polynomial.as[0]);
1448
3115
  polynomial.lexSort();
@@ -1459,34 +3126,38 @@ export class PolynomialManager {
1459
3126
  private evaluateCore<T>(
1460
3127
  polynomial: Polynomial,
1461
3128
  ops: ValueOps<T>,
1462
- getValue: (variable: number) => T,
3129
+ getValue: (variable: number) => T | null,
1463
3130
  start: number,
1464
3131
  end: number,
1465
3132
  x: number,
1466
- ): T {
3133
+ ): T | null {
1467
3134
  if (end === start + 1) {
1468
3135
  let result = ops.fromInteger(polynomial.as[start]);
1469
3136
  const monomial = polynomial.ms[start];
1470
3137
  for (let index = 0; index < monomial.size; index++) {
1471
3138
  const variable = monomial.vars[index];
1472
3139
  if (variable > x) break;
1473
- 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]));
1474
3143
  }
1475
3144
  return result;
1476
3145
  }
1477
3146
  const value = getValue(x);
3147
+ if (value === null) return null;
1478
3148
  let result = ops.fromInteger(0n);
1479
3149
  let index = start;
1480
3150
  while (index < end) {
3151
+ this.limit.checkpoint();
1481
3152
  const degree = polynomial.ms[index].degreeOf(x);
1482
3153
  if (degree === 0) {
1483
3154
  const below = this.maxSmallerThan(polynomial, index, end, x);
1484
- result = ops.add(
1485
- result,
3155
+ const rest =
1486
3156
  below === NULL_VAR
1487
3157
  ? ops.fromInteger(polynomial.as[index])
1488
- : this.evaluateCore(polynomial, ops, getValue, index, end, below),
1489
- );
3158
+ : this.evaluateCore(polynomial, ops, getValue, index, end, below);
3159
+ if (rest === null) return null;
3160
+ result = ops.add(result, rest);
1490
3161
  break;
1491
3162
  }
1492
3163
  let next = index + 1;
@@ -1499,13 +3170,12 @@ export class PolynomialManager {
1499
3170
  }
1500
3171
  }
1501
3172
  const below = this.maxSmallerThan(polynomial, index, next, x);
1502
- result = ops.add(
1503
- result,
3173
+ const coeff =
1504
3174
  below === NULL_VAR
1505
3175
  ? ops.fromInteger(polynomial.as[index])
1506
- : this.evaluateCore(polynomial, ops, getValue, index, next, below),
1507
- );
1508
- 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));
1509
3179
  index = next;
1510
3180
  }
1511
3181
  return result;
@@ -1518,66 +3188,88 @@ export class PolynomialManager {
1518
3188
  return max;
1519
3189
  }
1520
3190
 
1521
- evaluate(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
1522
- return this.evaluateWith(polynomial, RATIONAL_OPS, (variable) => {
1523
- const value = values[variable];
1524
- if (value === undefined) throw new SmtInvariantError(`x${variable} is unassigned`);
1525
- return value;
1526
- });
1527
- }
1528
-
1529
- getSign(polynomial: Polynomial, values: readonly (Rational | undefined)[]) {
1530
- const value = this.evaluate(polynomial, values);
1531
- 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;
1532
3198
  }
1533
3199
  }
1534
3200
 
1535
3201
  export class PolynomialCache {
1536
3202
  private table = new Map<string, Polynomial>();
1537
- private inCache = new Set<number>();
3203
+ private cachedPolys: PolynomialRefVector;
3204
+ private inCache: boolean[] = [];
1538
3205
  private pscChains = new Map<string, Polynomial[]>();
1539
3206
  private factorizations = new Map<number, Polynomial[]>();
1540
3207
 
1541
- constructor(readonly pm: PolynomialManager) {}
3208
+ constructor(readonly pm: PolynomialManager) {
3209
+ this.cachedPolys = new PolynomialRefVector(pm);
3210
+ }
1542
3211
 
1543
3212
  reset() {
1544
3213
  this.table.clear();
1545
- this.inCache.clear();
1546
3214
  this.pscChains.clear();
1547
3215
  this.factorizations.clear();
3216
+ this.inCache = [];
3217
+ this.cachedPolys.reset();
1548
3218
  }
1549
3219
 
1550
3220
  mkUnique(polynomial: Polynomial) {
1551
- if (this.inCache.has(polynomial.id)) return polynomial;
3221
+ if (this.inCache[polynomial.id] === true) return polynomial;
1552
3222
  const key = this.pm.getKey(polynomial);
1553
3223
  const existing = this.table.get(key);
1554
3224
  if (existing !== undefined) return existing;
1555
3225
  this.table.set(key, polynomial);
1556
- this.inCache.add(polynomial.id);
3226
+ this.cachedPolys.push(polynomial);
3227
+ this.inCache[polynomial.id] = true;
1557
3228
  return polynomial;
1558
3229
  }
1559
3230
 
1560
3231
  contains(polynomial: Polynomial) {
1561
- return this.inCache.has(polynomial.id);
3232
+ return this.inCache[polynomial.id] === true;
1562
3233
  }
1563
3234
 
1564
- pscChain(first: Polynomial, second: Polynomial, variable: number) {
3235
+ pscChain(first: Polynomial, second: Polynomial, variable: number, chain: PolynomialRefVector) {
1565
3236
  const p = this.mkUnique(first);
1566
3237
  const q = this.mkUnique(second);
1567
3238
  const key = `${p.id},${q.id},${variable}`;
1568
3239
  const cached = this.pscChains.get(key);
1569
- if (cached !== undefined) return cached;
1570
- const chain = this.pm.pscChain(p, q, variable).map((element) => this.mkUnique(element));
1571
- this.pscChains.set(key, chain);
1572
- return chain;
1573
- }
1574
-
1575
- factor(polynomial: Polynomial) {
1576
- const unique = this.mkUnique(polynomial);
1577
- const cached = this.factorizations.get(unique.id);
1578
- if (cached !== undefined) return cached;
1579
- const factors = this.pm.factor(unique).factors.map((factor) => this.mkUnique(factor));
1580
- this.factorizations.set(unique.id, factors);
1581
- 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();
1582
3274
  }
1583
3275
  }