tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576

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 (252) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +56 -56
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +49 -44
  20. package/dist/transfer.js +48 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +14 -2
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +516 -280
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +18 -4
  33. package/src/cli/tlc.ts +18 -12
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +190 -1
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +123 -38
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +370 -99
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +179 -60
  49. package/src/liveness.ts +51 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  109. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  110. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  111. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  112. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  113. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  114. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  115. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  116. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  117. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  118. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  119. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  120. package/src/prover/smt/solver/maxcore.ts +2 -1
  121. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  122. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  123. package/src/prover/smt/solver/model-checker.ts +1 -1
  124. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  125. package/src/prover/smt/solver/model-generator.ts +85 -43
  126. package/src/prover/smt/solver/mpf.ts +2 -4
  127. package/src/prover/smt/solver/mus.ts +2 -3
  128. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  129. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  130. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  131. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  132. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  133. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  134. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  135. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  136. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  137. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  138. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  139. package/src/prover/smt/solver/nlqsat.ts +1 -1
  140. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  141. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  142. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  143. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  144. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  145. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  146. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  147. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  148. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  149. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  150. package/src/prover/smt/solver/nnf.ts +6 -2
  151. package/src/prover/smt/solver/opt-context.ts +21 -7
  152. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  153. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  154. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  155. package/src/prover/smt/solver/opt-solver.ts +10 -6
  156. package/src/prover/smt/solver/optsmt.ts +1 -1
  157. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  158. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  159. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  160. package/src/prover/smt/solver/probes.ts +88 -23
  161. package/src/prover/smt/solver/proto-model.ts +8 -8
  162. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  163. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  164. package/src/prover/smt/solver/qe-lite.ts +2 -2
  165. package/src/prover/smt/solver/qe.ts +3 -2
  166. package/src/prover/smt/solver/qsat.ts +23 -8
  167. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  168. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  169. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  170. package/src/prover/smt/solver/rewriter.ts +31 -25
  171. package/src/prover/smt/solver/rlimit.ts +7 -3
  172. package/src/prover/smt/solver/sat/config.ts +1 -1
  173. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  174. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  175. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  176. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  177. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  178. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  179. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  180. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  181. package/src/prover/smt/solver/sat/solver.ts +27 -47
  182. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  183. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  184. package/src/prover/smt/solver/seq-derive.ts +2 -2
  185. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  186. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  187. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  188. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  189. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  190. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  191. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  192. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  193. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  194. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  195. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  196. package/src/prover/smt/solver/smt-setup.ts +106 -13
  197. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  198. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  199. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  200. package/src/prover/smt/solver/solver.ts +18 -3
  201. package/src/prover/smt/solver/tactic.ts +350 -195
  202. package/src/prover/smt/solver/theory-bv.ts +13 -3
  203. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  204. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  205. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  206. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  207. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  208. package/src/prover/smt/solver/theory-lra.ts +1 -1
  209. package/src/prover/smt/solver/theory-pb.ts +24 -7
  210. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  211. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  212. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  213. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  214. package/src/prover/tlapm/cache.ts +8 -8
  215. package/src/prover/zenon/index-table.ts +5 -2
  216. package/src/prover/zenon/isar-case.ts +1 -1
  217. package/src/prover/zenon/isar.ts +2 -2
  218. package/src/prover/zenon/phrase.ts +1 -1
  219. package/src/resolve.ts +1274 -257
  220. package/src/runtime.ts +7 -1
  221. package/src/sany/builtins.ts +10 -10
  222. package/src/sany/generation.ts +5 -15
  223. package/src/sany/generator-def-entries.ts +123 -36
  224. package/src/sany/generator-definitions.ts +5 -3
  225. package/src/sany/generator-expressions.ts +60 -37
  226. package/src/sany/generator-proofs.ts +18 -12
  227. package/src/sany/generator.ts +12 -6
  228. package/src/sany/lexer.ts +15 -7
  229. package/src/sany/modules.ts +4 -2
  230. package/src/sany/nodes.ts +1 -1
  231. package/src/sany/selectors.ts +11 -6
  232. package/src/sany/xml.ts +2 -3
  233. package/src/search.ts +319 -135
  234. package/src/simulate.ts +235 -182
  235. package/src/spec-description.ts +8 -6
  236. package/src/standard-definitions.ts +1 -0
  237. package/src/standard-modules.ts +56 -22
  238. package/src/subexpressions.ts +564 -138
  239. package/src/successors.ts +37 -13
  240. package/src/symmetry.ts +2 -1
  241. package/src/tlc/jar-data.ts +10 -0
  242. package/src/tlc/messages.ts +3 -3
  243. package/src/tlc/order.ts +14 -3
  244. package/src/tlc/random.ts +2 -1
  245. package/src/tlc/replay.ts +67 -43
  246. package/src/tlc/tlc-operators.ts +10 -8
  247. package/src/tlc/tlcext-operators.ts +44 -15
  248. package/src/tlc/trace-spec.ts +9 -22
  249. package/src/trace-liveness.ts +529 -0
  250. package/src/typed-tier.ts +52 -31
  251. package/src/typescript/types.ts +2 -2
  252. package/src/values.ts +150 -79
@@ -1,6 +1,3 @@
1
- // Deviation from Z3: ties between polynomials break by creation-order id, where Z3 recycles ids of
2
- // freed polynomials (id_gen in polynomial.cpp), so a cell bound can be another polynomial with the
3
- // same root.
4
1
  import { NlsatUnsupportedError } from "../../../../errors";
5
2
  import { Rational } from "../rational";
6
3
  import { type AlgebraicManager, type Anum, mergeSortIndices } from "./algebraic";
@@ -9,14 +6,26 @@ import {
9
6
  type Polynomial,
10
7
  type PolynomialCache,
11
8
  type PolynomialManager,
9
+ PolynomialRef,
10
+ PolynomialRefVector,
12
11
  } from "./polynomial";
13
12
 
14
- interface CellInterval {
15
- isSection: boolean;
16
- lower: Polynomial | null;
17
- lowerIndex: number;
18
- upper: Polynomial | null;
19
- upperIndex: number;
13
+ export class CellInterval {
14
+ isSection = false;
15
+ readonly lower: PolynomialRef;
16
+ lowerIndex = 0;
17
+ readonly upper: PolynomialRef;
18
+ upperIndex = 0;
19
+
20
+ constructor(pm: PolynomialManager) {
21
+ this.lower = new PolynomialRef(pm);
22
+ this.upper = new PolynomialRef(pm);
23
+ }
24
+
25
+ release() {
26
+ this.upper.reset();
27
+ this.lower.reset();
28
+ }
20
29
  }
21
30
 
22
31
  interface RootFunction {
@@ -32,98 +41,119 @@ const UNSET = -1;
32
41
  const BOTH_SIDES = 3;
33
42
  const SPANNING_TREE_THRESHOLD = 4;
34
43
 
44
+ export const releaseIntervals = (intervals: readonly CellInterval[]) => {
45
+ for (let index = intervals.length; index-- > 0;) intervals[index].release();
46
+ };
47
+
35
48
  export class TodoSet {
36
- polynomials: Polynomial[] = [];
37
- private inSet = new Set<number>();
49
+ readonly set: PolynomialRefVector;
50
+ private inSet: boolean[] = [];
38
51
 
39
52
  constructor(
40
- private pm: PolynomialManager,
41
53
  private cache: PolynomialCache,
42
- ) {}
54
+ private isCanonicalizing: boolean,
55
+ ) {
56
+ this.set = new PolynomialRefVector(cache.pm);
57
+ }
43
58
 
44
59
  get isEmpty() {
45
- return this.polynomials.length === 0;
60
+ return this.set.size === 0;
46
61
  }
47
62
 
48
63
  reset() {
49
- this.polynomials = [];
50
- this.inSet.clear();
64
+ for (const polynomial of this.set.items) this.inSet[polynomial.id] = false;
65
+ this.set.reset();
51
66
  }
52
67
 
53
68
  insert(polynomial: Polynomial) {
54
- if (this.inSet.has(polynomial.id)) return polynomial;
69
+ const pm = this.cache.pm;
70
+ if (this.inSet[polynomial.id] === true) return polynomial;
55
71
  if (this.cache.contains(polynomial)) {
56
- this.inSet.add(polynomial.id);
57
- this.polynomials.push(polynomial);
72
+ this.inSet[polynomial.id] = true;
73
+ this.set.push(polynomial);
58
74
  return polynomial;
59
75
  }
60
- const primitive =
61
- this.pm.isZero(polynomial) || this.pm.isConst(polynomial)
62
- ? polynomial
63
- : this.pm.pp(polynomial, this.pm.maxVar(polynomial));
64
- const unique = this.cache.mkUnique(this.pm.flipSignIfLmNeg(primitive));
65
- if (!this.inSet.has(unique.id)) {
66
- this.inSet.add(unique.id);
67
- this.polynomials.push(unique);
76
+ const pinned = new PolynomialRef(pm);
77
+ let p = polynomial;
78
+ if (this.isCanonicalizing) {
79
+ if (!pm.isZero(p) && !pm.isConst(p)) {
80
+ pinned.move(pm.pp(p, pm.maxVar(p)));
81
+ p = pinned.get();
82
+ } else pinned.set(p);
83
+ p = pm.flipSignIfLmNeg(p);
84
+ pinned.set(p);
85
+ }
86
+ p = this.cache.mkUnique(p);
87
+ if (this.inSet[p.id] !== true) {
88
+ this.inSet[p.id] = true;
89
+ this.set.push(p);
68
90
  }
69
- return unique;
91
+ pinned.reset();
92
+ return p;
70
93
  }
71
94
 
72
95
  getMaxVar() {
73
- return this.pm.getMaxVarOfPolys(this.polynomials);
96
+ return this.cache.pm.getMaxVarOfPolys(this.set.items);
74
97
  }
75
98
 
76
- extractMaxPolys(out: Polynomial[]) {
77
- out.length = 0;
99
+ extractMaxPolys(out: PolynomialRefVector) {
100
+ out.reset();
78
101
  const variable = this.getMaxVar();
79
102
  this.extractPolysAtLevel(variable, out);
80
103
  return variable;
81
104
  }
82
105
 
83
- extractPolysAtLevel(variable: number, out: Polynomial[]) {
84
- const kept: Polynomial[] = [];
85
- for (const polynomial of this.polynomials) {
86
- if (this.pm.maxVar(polynomial) !== variable) {
87
- kept.push(polynomial);
88
- continue;
89
- }
90
- out.push(polynomial);
91
- this.inSet.delete(polynomial.id);
106
+ extractPolysAtLevel(variable: number, out: PolynomialRefVector) {
107
+ const pm = this.cache.pm;
108
+ let kept = 0;
109
+ for (let index = 0; index < this.set.size; index++) {
110
+ const polynomial = this.set.get(index);
111
+ if (pm.maxVar(polynomial) === variable) {
112
+ out.push(polynomial);
113
+ this.inSet[polynomial.id] = false;
114
+ } else this.set.set(kept++, polynomial);
92
115
  }
93
- this.polynomials = kept;
116
+ this.set.shrink(kept);
94
117
  }
95
118
  }
96
119
 
97
- class Levelwise {
98
- private intervals: CellInterval[];
99
- private todo: TodoSet;
120
+ export class Levelwise {
121
+ readonly intervals: CellInterval[] = [];
100
122
  private level = 0;
101
- private levelPolys: Polynomial[] = [];
102
- private witnesses: (Polynomial | null)[] = [];
103
- private hasRoots: boolean[] = [];
104
- private rootFunctions: RootFunction[] = [];
105
- private pairs = new Map<string, [number, number]>();
106
- private sideMask: number[] = [];
107
- private isLcOmitted: boolean[] = [];
108
123
  private lowerRf = UNSET;
109
124
  private upperRf = UNSET;
125
+ private todo: TodoSet;
126
+ private levelPs: PolynomialRefVector;
127
+ private witnesses: PolynomialRef[] = [];
128
+ private polyHasRoots: boolean[] = [];
129
+ private pscTmp: PolynomialRefVector;
130
+ private sideMask: number[] = [];
131
+ private isLcOmitted: boolean[] = [];
132
+ private degInOrderGraph: number[] = [];
133
+ private rootFunctions: RootFunction[] = [];
134
+ private pairs = new Map<string, [number, number]>();
110
135
 
111
136
  constructor(
112
137
  private pm: PolynomialManager,
113
138
  private am: AlgebraicManager,
114
139
  private cache: PolynomialCache,
115
- private sample: readonly (Anum | undefined)[],
140
+ private polynomials: PolynomialRefVector,
116
141
  private maxVar: number,
142
+ private sample: readonly (Anum | undefined)[],
117
143
  private isLinear: boolean,
118
144
  ) {
119
- this.todo = new TodoSet(pm, cache);
120
- this.intervals = Array.from({ length: maxVar }, () => ({
121
- isSection: false,
122
- lower: null,
123
- lowerIndex: 0,
124
- upper: null,
125
- upperIndex: 0,
126
- }));
145
+ this.todo = new TodoSet(cache, true);
146
+ this.levelPs = new PolynomialRefVector(pm);
147
+ this.pscTmp = new PolynomialRefVector(pm);
148
+ for (let index = 0; index < maxVar; index++) this.intervals.push(new CellInterval(pm));
149
+ }
150
+
151
+ release() {
152
+ this.pscTmp.reset();
153
+ this.clearWitnesses();
154
+ this.levelPs.reset();
155
+ this.todo.set.reset();
156
+ releaseIntervals(this.intervals);
127
157
  }
128
158
 
129
159
  private getSign(polynomial: Polynomial) {
@@ -134,93 +164,200 @@ class Levelwise {
134
164
  return this.sample.map((value, index) => (index === variable ? undefined : value));
135
165
  }
136
166
 
137
- private requestFactorized(polynomial: Polynomial | null) {
138
- if (polynomial === null || this.pm.isConst(polynomial)) return;
139
- for (const factor of this.cache.factor(polynomial))
140
- if (!this.pm.isConst(factor)) this.todo.insert(factor);
141
- }
142
-
143
- private getFirstPsc(first: Polynomial, second: Polynomial, variable: number) {
144
- for (const element of this.cache.pscChain(first, second, variable)) {
145
- if (this.pm.isZero(element)) continue;
146
- return this.pm.isConst(element) ? null : element;
147
- }
148
- return null;
149
- }
150
-
151
- private getPscDiscriminant(polynomial: Polynomial, variable: number) {
152
- if (this.pm.isConst(polynomial) || this.pm.degree(polynomial, variable) < 2) return null;
153
- return this.getFirstPsc(polynomial, this.pm.derivative(polynomial, variable), variable);
154
- }
155
-
156
- private handleNullifiedPoly(polynomial: Polynomial) {
157
- const degree = this.pm.degree(polynomial, this.level);
158
- for (let power = 0; power <= degree; power++)
159
- this.requestFactorized(this.pm.coeff(polynomial, this.level, power));
160
- let current = [{ polynomial, minVar: 0 }];
161
- while (current.length > 0) {
162
- const next: { polynomial: Polynomial; minVar: number }[] = [];
163
- for (const entry of current) {
164
- const maxVar = this.pm.maxVar(entry.polynomial);
165
- if (maxVar === NULL_VAR) continue;
166
- for (let variable = entry.minVar; variable <= maxVar; variable++) {
167
- if (this.pm.degree(entry.polynomial, variable) === 0) continue;
168
- const derivative = this.pm.derivative(entry.polynomial, variable);
169
- if (this.pm.isConst(derivative)) continue;
170
- if (this.getSign(derivative) !== 0) {
171
- this.requestFactorized(derivative);
167
+ private clearWitnesses() {
168
+ for (let index = this.witnesses.length; index-- > 0;) this.witnesses[index].reset();
169
+ this.witnesses = [];
170
+ }
171
+
172
+ private handleNullifiedPoly(p: Polynomial) {
173
+ const pm = this.pm;
174
+ const degree = pm.degree(p, this.level);
175
+ for (let power = 0; power <= degree; power++) {
176
+ const coeff = new PolynomialRef(pm);
177
+ coeff.set(pm.coeff(p, this.level, power));
178
+ if (!pm.isZero(coeff.get()) && !pm.isConst(coeff.get())) this.requestFactorized(coeff.get());
179
+ coeff.reset();
180
+ }
181
+ let curPolys = new PolynomialRefVector(pm);
182
+ let curMinVar: number[] = [];
183
+ curPolys.push(p);
184
+ curMinVar.push(0);
185
+ while (curPolys.size > 0) {
186
+ const nextPolys = new PolynomialRefVector(pm);
187
+ const nextMinVar: number[] = [];
188
+ for (let index = 0; index < curPolys.size; index++) {
189
+ const q = new PolynomialRef(pm);
190
+ q.set(curPolys.get(index));
191
+ const maxVar = pm.maxVar(q.get());
192
+ if (maxVar === NULL_VAR) {
193
+ q.reset();
194
+ continue;
195
+ }
196
+ for (let x = curMinVar[index]; x <= maxVar; x++) {
197
+ if (pm.degree(q.get(), x) === 0) continue;
198
+ const dq = new PolynomialRef(pm);
199
+ dq.set(pm.derivative(q.get(), x));
200
+ if (pm.isZero(dq.get()) || pm.isConst(dq.get())) {
201
+ dq.reset();
202
+ continue;
203
+ }
204
+ if (this.getSign(dq.get()) !== 0) {
205
+ this.requestFactorized(dq.get());
206
+ dq.reset();
207
+ q.reset();
208
+ nextPolys.reset();
209
+ curPolys.reset();
172
210
  return;
173
211
  }
174
- next.push({ polynomial: derivative, minVar: variable });
212
+ nextPolys.push(dq.get());
213
+ nextMinVar.push(x);
214
+ dq.reset();
175
215
  }
216
+ q.reset();
176
217
  }
177
- for (const entry of next) this.requestFactorized(entry.polynomial);
178
- current = next;
218
+ for (let index = 0; index < nextPolys.size; index++) {
219
+ const dq = new PolynomialRef(pm);
220
+ dq.set(nextPolys.get(index));
221
+ this.requestFactorized(dq.get());
222
+ dq.reset();
223
+ }
224
+ curPolys.reset();
225
+ curPolys = nextPolys;
226
+ curMinVar = nextMinVar;
227
+ }
228
+ }
229
+
230
+ private resetInterval(interval: CellInterval) {
231
+ interval.isSection = false;
232
+ interval.lower.reset();
233
+ interval.upper.reset();
234
+ interval.lowerIndex = 0;
235
+ interval.upperIndex = 0;
236
+ }
237
+
238
+ private getFirstPsc(chain: PolynomialRefVector) {
239
+ const r = new PolynomialRef(this.pm);
240
+ for (let index = 0; index < chain.size; index++) {
241
+ r.set(chain.get(index));
242
+ if (this.pm.isZero(r.get())) continue;
243
+ if (this.pm.isConst(r.get())) {
244
+ r.reset();
245
+ return r;
246
+ }
247
+ return r;
179
248
  }
249
+ r.reset();
250
+ return r;
251
+ }
252
+
253
+ private pscDiscriminant(pIn: Polynomial, x: number) {
254
+ const pm = this.pm;
255
+ if (pm.isZero(pIn) || pm.isConst(pIn) || pm.degree(pIn, x) < 2) return new PolynomialRef(pm);
256
+ const p = new PolynomialRef(pm);
257
+ p.set(pIn);
258
+ const d = new PolynomialRef(pm);
259
+ d.set(pm.derivative(p.get(), x));
260
+ const chain = this.pscTmp;
261
+ chain.reset();
262
+ this.cache.pscChain(p.get(), d.get(), x, chain);
263
+ const disc = this.getFirstPsc(chain);
264
+ d.reset();
265
+ p.reset();
266
+ return disc;
267
+ }
268
+
269
+ private pscResultant(a: Polynomial, b: Polynomial, x: number) {
270
+ const pa = new PolynomialRef(this.pm);
271
+ pa.set(a);
272
+ const pb = new PolynomialRef(this.pm);
273
+ pb.set(b);
274
+ const chain = this.pscTmp;
275
+ chain.reset();
276
+ this.cache.pscChain(pa.get(), pb.get(), x, chain);
277
+ const r = this.getFirstPsc(chain);
278
+ pb.reset();
279
+ pa.reset();
280
+ return r;
180
281
  }
181
282
 
182
- private chooseNonzeroCoeff(polynomial: Polynomial, variable: number) {
183
- const degree = this.pm.degree(polynomial, variable);
283
+ private requestFactorized(polynomial: Polynomial | null) {
284
+ const pm = this.pm;
285
+ if (polynomial === null || pm.isZero(polynomial) || pm.isConst(polynomial)) return;
286
+ const factors = new PolynomialRefVector(pm);
287
+ this.cache.factor(polynomial, factors);
288
+ for (let index = 0; index < factors.size; index++) {
289
+ const f = new PolynomialRef(pm);
290
+ f.set(factors.get(index));
291
+ if (!pm.isZero(f.get()) && !pm.isConst(f.get())) this.todo.insert(f.get());
292
+ f.reset();
293
+ }
294
+ factors.reset();
295
+ }
296
+
297
+ private chooseNonzeroCoeff(p: Polynomial, x: number) {
298
+ const pm = this.pm;
299
+ const degree = pm.degree(p, x);
300
+ const coeff = new PolynomialRef(pm);
184
301
  for (let power = 0; power <= degree; power++) {
185
- const coeff = this.pm.coeff(polynomial, variable, power);
186
- if (!this.pm.isZero(coeff) && this.pm.isConst(coeff)) return coeff;
302
+ coeff.set(pm.coeff(p, x, power));
303
+ if (pm.isZero(coeff.get())) continue;
304
+ if (pm.isConst(coeff.get())) return coeff;
187
305
  }
188
- let best: Polynomial | null = null;
306
+ const best = new PolynomialRef(pm);
307
+ let bestTotalDegree = 0;
308
+ let bestSize = 0;
309
+ let bestMaxVar = NULL_VAR;
189
310
  for (let power = 0; power <= degree; power++) {
190
- const coeff = this.pm.coeff(polynomial, variable, power);
191
- if (this.pm.isZero(coeff) || this.getSign(coeff) === 0) continue;
192
- const totalDegree = this.pm.totalDegree(coeff);
193
- const bestDegree = best === null ? 0 : this.pm.totalDegree(best);
311
+ coeff.set(pm.coeff(p, x, power));
312
+ const current = coeff.get();
313
+ if (pm.isZero(current) || this.getSign(current) === 0) continue;
314
+ const totalDegree = pm.totalDegree(current);
315
+ const size = current.size;
316
+ const maxVar = pm.maxVar(current);
194
317
  if (
195
- best === null ||
196
- totalDegree < bestDegree ||
197
- (totalDegree === bestDegree &&
198
- (coeff.size < best.size ||
199
- (coeff.size === best.size && this.pm.maxVar(coeff) < this.pm.maxVar(best))))
200
- )
201
- best = coeff;
318
+ best.getOrNull() === null ||
319
+ totalDegree < bestTotalDegree ||
320
+ (totalDegree === bestTotalDegree &&
321
+ (size < bestSize ||
322
+ (size === bestSize && (bestMaxVar === NULL_VAR || maxVar < bestMaxVar))))
323
+ ) {
324
+ best.copy(coeff);
325
+ bestTotalDegree = totalDegree;
326
+ bestSize = size;
327
+ bestMaxVar = maxVar;
328
+ }
202
329
  }
330
+ coeff.reset();
203
331
  return best;
204
332
  }
205
333
 
206
334
  private addProjectionForPoly(
207
- polynomial: Polynomial,
208
- variable: number,
209
- witness: Polynomial | null,
335
+ p: Polynomial,
336
+ x: number,
337
+ nonzeroCoeff: Polynomial | null,
210
338
  isLcAdded: boolean,
339
+ isDiscAdded: boolean,
211
340
  ) {
212
- let isWitnessAdded = witness !== null && !this.pm.isConst(witness);
341
+ const pm = this.pm;
342
+ let isNonzeroCoeffAdded = nonzeroCoeff !== null && !pm.isConst(nonzeroCoeff);
213
343
  if (isLcAdded) {
214
- const leadingCoeff = this.pm.lc(polynomial, variable);
215
- this.requestFactorized(leadingCoeff);
216
- if (isWitnessAdded && this.getSign(leadingCoeff) !== 0) isWitnessAdded = false;
344
+ const lc = new PolynomialRef(pm);
345
+ lc.set(pm.coeff(p, x, pm.degree(p, x)));
346
+ this.requestFactorized(lc.get());
347
+ if (isNonzeroCoeffAdded && this.getSign(lc.get()) !== 0) isNonzeroCoeffAdded = false;
348
+ lc.reset();
217
349
  }
218
- const discriminant = this.getPscDiscriminant(polynomial, variable);
219
- if (discriminant !== null) {
220
- this.requestFactorized(discriminant);
221
- if (isWitnessAdded && this.getSign(discriminant) !== 0) isWitnessAdded = false;
350
+ if (isDiscAdded) {
351
+ const disc = new PolynomialRef(pm);
352
+ disc.move(this.pscDiscriminant(p, x));
353
+ const value = disc.getOrNull();
354
+ if (value !== null) {
355
+ this.requestFactorized(value);
356
+ if (isNonzeroCoeffAdded && this.getSign(value) !== 0) isNonzeroCoeffAdded = false;
357
+ }
358
+ disc.reset();
222
359
  }
223
- if (isWitnessAdded) this.requestFactorized(witness);
360
+ if (isNonzeroCoeffAdded) this.requestFactorized(nonzeroCoeff);
224
361
  }
225
362
 
226
363
  private addPair(first: number, second: number) {
@@ -242,7 +379,7 @@ class Levelwise {
242
379
 
243
380
  private computeSideMask() {
244
381
  if (this.lowerRf === UNSET) return;
245
- while (this.sideMask.length < this.levelPolys.length) this.sideMask.push(0);
382
+ while (this.sideMask.length < this.levelPs.size) this.sideMask.push(0);
246
383
  this.rootFunctions.forEach((rootFunction, index) => {
247
384
  this.sideMask[rootFunction.psIndex] |= index <= this.lowerRf ? 1 : 2;
248
385
  });
@@ -252,20 +389,24 @@ class Levelwise {
252
389
  return rootFunctionIndex === UNSET ? UNSET : this.rootFunctions[rootFunctionIndex].psIndex;
253
390
  }
254
391
 
392
+ private computeResultantGraphDegree() {
393
+ this.degInOrderGraph = Array.from({ length: this.levelPs.size }, () => 0);
394
+ for (const pair of this.pairs.values()) {
395
+ this.degInOrderGraph[pair[0]]++;
396
+ this.degInOrderGraph[pair[1]]++;
397
+ }
398
+ }
399
+
255
400
  private computeOmitLcBothSides(isLeafRequired: boolean) {
256
- this.isLcOmitted = this.levelPolys.map(() => false);
401
+ this.isLcOmitted = Array.from({ length: this.levelPs.size }, () => false);
257
402
  if (this.rootFunctions.length === 0 || this.pairs.size === 0 || this.sideMask.length === 0)
258
403
  return;
259
- const degrees = this.levelPolys.map(() => 0);
260
- for (const pair of this.pairs.values()) {
261
- degrees[pair[0]]++;
262
- degrees[pair[1]]++;
263
- }
404
+ if (isLeafRequired) this.computeResultantGraphDegree();
264
405
  const lowerBound = this.getBoundIndex(this.lowerRf);
265
406
  const upperBound = this.getBoundIndex(this.upperRf);
266
- for (let index = 0; index < this.levelPolys.length; index++) {
407
+ for (let index = 0; index < this.levelPs.size; index++) {
267
408
  if (this.sideMask[index] !== BOTH_SIDES) continue;
268
- if (isLeafRequired && degrees[index] !== 1) continue;
409
+ if (isLeafRequired && this.degInOrderGraph[index] !== 1) continue;
269
410
  if (index === lowerBound || index === upperBound) continue;
270
411
  this.isLcOmitted[index] = true;
271
412
  }
@@ -281,26 +422,24 @@ class Levelwise {
281
422
  }
282
423
 
283
424
  private fillRelationSection() {
425
+ if (this.rootFunctions.length === 0) return;
284
426
  for (let index = 0; index < this.lowerRf; index++) this.addPair(index, this.lowerRf);
285
427
  for (let index = this.lowerRf + 1; index < this.rootFunctions.length; index++)
286
428
  this.addPair(this.lowerRf, index);
287
429
  }
288
430
 
289
431
  private buildBothSideSpanningTree() {
290
- const lowerRfs = this.levelPolys.map(() => UNSET);
291
- const upperRfs = this.levelPolys.map(() => UNSET);
432
+ const lowerRfs = Array.from({ length: this.levelPs.size }, () => UNSET);
433
+ const upperRfs = Array.from({ length: this.levelPs.size }, () => UNSET);
292
434
  for (let index = 0; index <= this.lowerRf; index++)
293
435
  lowerRfs[this.rootFunctions[index].psIndex] = index;
294
436
  for (let index = this.upperRf; index < this.rootFunctions.length; index++)
295
437
  upperRfs[this.rootFunctions[index].psIndex] = index;
296
- const both = this.levelPolys
297
- .map((_polynomial, psIndex) => ({
298
- psIndex,
299
- lowerRf: lowerRfs[psIndex],
300
- upperRf: upperRfs[psIndex],
301
- }))
302
- .filter((info) => this.sideMask[info.psIndex] === BOTH_SIDES)
303
- .sort((first, second) => first.lowerRf - second.lowerRf);
438
+ const both: { psIndex: number; lowerRf: number; upperRf: number }[] = [];
439
+ for (let psIndex = 0; psIndex < this.levelPs.size; psIndex++)
440
+ if (this.sideMask[psIndex] === BOTH_SIDES)
441
+ both.push({ psIndex, lowerRf: lowerRfs[psIndex], upperRf: upperRfs[psIndex] });
442
+ both.sort((first, second) => first.lowerRf - second.lowerRf);
304
443
  for (let first = 0; first < both.length - 1; first++) {
305
444
  let closest = first + 1;
306
445
  for (let index = first + 2; index < both.length; index++)
@@ -331,21 +470,21 @@ class Levelwise {
331
470
  }
332
471
 
333
472
  private isolateRootsAroundSample(
473
+ p: Polynomial,
334
474
  psIndex: number,
335
475
  value: Anum,
336
476
  lower: RootFunction[],
337
477
  upper: RootFunction[],
338
478
  ) {
339
- const polynomial = this.levelPolys[psIndex];
340
479
  const values = this.getValuesWithout(this.level);
341
480
  const mkRootFunction = (root: Anum, index: number) => ({
342
481
  value: this.am.copy(root),
343
- polynomial,
482
+ polynomial: p,
344
483
  index,
345
484
  psIndex,
346
485
  });
347
486
  if (value.value instanceof Rational) {
348
- const closest = this.am.isolateRootsClosest(this.pm, polynomial, values, value.value);
487
+ const closest = this.am.isolateRootsClosest(this.pm, p, values, value.value);
349
488
  closest.roots.forEach((root, index) => {
350
489
  (this.am.compare(root, value) <= 0 ? lower : upper).push(
351
490
  mkRootFunction(root, closest.indices[index]),
@@ -353,7 +492,7 @@ class Levelwise {
353
492
  });
354
493
  return closest.roots.length > 0;
355
494
  }
356
- const roots = this.am.isolateRoots(this.pm, polynomial, values);
495
+ const roots = this.am.isolateRoots(this.pm, p, values);
357
496
  let lowerIndex = UNSET;
358
497
  let upperIndex = UNSET;
359
498
  let isSection = false;
@@ -400,95 +539,115 @@ class Levelwise {
400
539
  if (middle === 0) {
401
540
  this.lowerRf = UNSET;
402
541
  this.upperRf = 0;
403
- interval.upper = rootFunctions[0].polynomial;
542
+ interval.upper.set(rootFunctions[0].polynomial);
404
543
  interval.upperIndex = rootFunctions[0].index;
405
544
  return;
406
545
  }
407
546
  this.lowerRf = middle - 1;
408
547
  const lower = rootFunctions[middle - 1];
409
- interval.lower = lower.polynomial;
410
- interval.lowerIndex = lower.index;
411
548
  if (this.am.compare(lower.value, value) === 0) {
412
549
  interval.isSection = true;
550
+ interval.lower.set(lower.polynomial);
551
+ interval.lowerIndex = lower.index;
413
552
  this.upperRf = this.lowerRf;
414
553
  return;
415
554
  }
555
+ interval.lower.set(lower.polynomial);
556
+ interval.lowerIndex = lower.index;
416
557
  if (middle < rootFunctions.length) {
417
558
  this.upperRf = this.lowerRf + 1;
418
- interval.upper = rootFunctions[middle].polynomial;
559
+ interval.upper.set(rootFunctions[middle].polynomial);
419
560
  interval.upperIndex = rootFunctions[middle].index;
420
561
  }
421
562
  }
422
563
 
423
- private addLinearPolyFromRoot(root: Anum, isLower: boolean) {
424
- const value = root.value as Rational;
425
- const polynomial = this.pm.sub(
426
- this.pm.mul(this.pm.mkConst(value.den), this.pm.mkVar(this.level)),
427
- this.pm.mkConst(value.num),
428
- );
564
+ private addLinearPolyFromRoot(root: Anum, isLower: boolean, p: PolynomialRef) {
565
+ const pm = this.pm;
566
+ const value = this.am.toRational(root);
567
+ p.set(pm.mkVar(this.level));
568
+ const scaled = new PolynomialRef(pm);
569
+ scaled.set(pm.mulConst(value.den, p.get()));
570
+ const constant = new PolynomialRef(pm);
571
+ constant.set(pm.mkConst(value.num));
572
+ const difference = new PolynomialRef(pm);
573
+ difference.set(pm.sub(scaled.get(), constant.get()));
574
+ constant.reset();
575
+ p.move(difference);
576
+ scaled.reset();
429
577
  const interval = this.intervals[this.level];
430
578
  if (isLower) {
431
- interval.lower = polynomial;
579
+ interval.lower.copy(p);
432
580
  interval.lowerIndex = 1;
433
581
  } else {
434
- interval.upper = polynomial;
582
+ interval.upper.copy(p);
435
583
  interval.upperIndex = 1;
436
584
  }
437
- this.levelPolys.push(polynomial);
438
- this.hasRoots.push(true);
439
- this.witnesses.push(this.chooseNonzeroCoeff(polynomial, this.level));
440
- return polynomial;
585
+ this.levelPs.push(p.get());
586
+ this.polyHasRoots.push(true);
587
+ const witness = this.chooseNonzeroCoeff(p.get(), this.level);
588
+ const copy = new PolynomialRef(pm);
589
+ copy.copy(witness);
590
+ this.witnesses.push(copy);
591
+ witness.reset();
441
592
  }
442
593
 
443
594
  private addLinearApproximations(value: Anum) {
595
+ const pLower = new PolynomialRef(this.pm);
596
+ const pUpper = new PolynomialRef(this.pm);
444
597
  const interval = this.intervals[this.level];
445
598
  const mkRootFunction = (polynomial: Polynomial, root: Anum) => ({
446
599
  value: this.am.copy(root),
447
600
  polynomial,
448
601
  index: 1,
449
- psIndex: this.levelPolys.length - 1,
602
+ psIndex: this.levelPs.size - 1,
450
603
  });
451
604
  if (interval.isSection) {
452
605
  if (!this.am.isRational(value))
453
606
  throw new NlsatUnsupportedError("a linear cell around an irrational section");
454
- if (this.pm.totalDegree(interval.lower!) > 1) {
455
- const polynomial = this.addLinearPolyFromRoot(value, true);
456
- this.rootFunctions.splice(this.lowerRf, 0, mkRootFunction(polynomial, value));
607
+ if (this.pm.totalDegree(interval.lower.get()) > 1) {
608
+ this.addLinearPolyFromRoot(value, true, pLower);
609
+ this.rootFunctions.splice(this.lowerRf, 0, mkRootFunction(pLower.get(), value));
457
610
  }
611
+ pUpper.reset();
612
+ pLower.reset();
458
613
  return;
459
614
  }
460
- if (interval.lower !== null && this.pm.totalDegree(interval.lower) > 1) {
615
+ const lower = interval.lower.getOrNull();
616
+ if (lower !== null && this.pm.totalDegree(lower) > 1) {
461
617
  const between = this.am.select(this.rootFunctions[this.lowerRf].value, value);
462
- const polynomial = this.addLinearPolyFromRoot(between, true);
463
- this.rootFunctions.splice(this.lowerRf + 1, 0, mkRootFunction(polynomial, between));
618
+ this.addLinearPolyFromRoot(between, true, pLower);
619
+ this.rootFunctions.splice(this.lowerRf + 1, 0, mkRootFunction(pLower.get(), between));
464
620
  this.lowerRf++;
465
621
  if (this.upperRf !== UNSET) this.upperRf++;
466
622
  }
467
- if (interval.upper !== null && this.pm.totalDegree(interval.upper) > 1) {
623
+ const upper = interval.upper.getOrNull();
624
+ if (upper !== null && this.pm.totalDegree(upper) > 1) {
468
625
  const between = this.am.select(value, this.rootFunctions[this.upperRf].value);
469
- const polynomial = this.addLinearPolyFromRoot(between, false);
470
- this.rootFunctions.splice(this.upperRf, 0, mkRootFunction(polynomial, between));
626
+ this.addLinearPolyFromRoot(between, false, pUpper);
627
+ this.rootFunctions.splice(this.upperRf, 0, mkRootFunction(pUpper.get(), between));
471
628
  }
629
+ pUpper.reset();
630
+ pLower.reset();
472
631
  }
473
632
 
474
633
  private buildInterval() {
475
634
  this.rootFunctions = [];
476
635
  this.pairs.clear();
477
- Object.assign(this.intervals[this.level], {
478
- isSection: false,
479
- lower: null,
480
- lowerIndex: 0,
481
- upper: null,
482
- upperIndex: 0,
483
- });
636
+ this.resetInterval(this.intervals[this.level]);
484
637
  this.lowerRf = UNSET;
485
638
  this.upperRf = UNSET;
486
639
  const value = this.sample[this.level]!;
640
+ this.polyHasRoots = Array.from({ length: this.levelPs.size }, () => false);
487
641
  const lower: RootFunction[] = [];
488
642
  const upper: RootFunction[] = [];
489
- this.hasRoots = this.levelPolys.map((_polynomial, psIndex) =>
490
- this.isolateRootsAroundSample(psIndex, value, lower, upper),
491
- );
643
+ for (let index = 0; index < this.levelPs.size; index++)
644
+ this.polyHasRoots[index] = this.isolateRootsAroundSample(
645
+ this.levelPs.get(index),
646
+ index,
647
+ value,
648
+ lower,
649
+ upper,
650
+ );
492
651
  if (lower.length === 0 && upper.length === 0) return false;
493
652
  this.rootFunctions = [
494
653
  ...this.sortRootFunctions(lower, true),
@@ -501,20 +660,27 @@ class Levelwise {
501
660
  }
502
661
 
503
662
  private addRelationResultants() {
504
- for (const pair of this.getSortedPairs())
505
- this.requestFactorized(
506
- this.getFirstPsc(this.levelPolys[pair[0]], this.levelPolys[pair[1]], this.level),
663
+ for (const pair of this.getSortedPairs()) {
664
+ const res = this.pscResultant(
665
+ this.levelPs.get(pair[0]),
666
+ this.levelPs.get(pair[1]),
667
+ this.level,
507
668
  );
669
+ this.requestFactorized(res.getOrNull());
670
+ res.reset();
671
+ }
508
672
  }
509
673
 
510
674
  private addAdjacentRootResultants() {
675
+ this.polyHasRoots = Array.from({ length: this.levelPs.size }, () => false);
511
676
  const rootValues: { root: Anum; polynomial: Polynomial }[] = [];
512
677
  const values = this.getValuesWithout(this.maxVar);
513
- this.hasRoots = this.levelPolys.map((polynomial) => {
678
+ for (let index = 0; index < this.levelPs.size; index++) {
679
+ const polynomial = this.levelPs.get(index);
514
680
  const roots = this.am.isolateRoots(this.pm, polynomial, values);
681
+ this.polyHasRoots[index] = roots.length > 0;
515
682
  for (const root of roots) rootValues.push({ root: this.am.copy(root), polynomial });
516
- return roots.length > 0;
517
- });
683
+ }
518
684
  if (rootValues.length < 2) return;
519
685
  const order = mergeSortIndices(
520
686
  rootValues.length,
@@ -529,32 +695,51 @@ class Levelwise {
529
695
  const key = `${low.id},${high.id}`;
530
696
  if (added.has(key)) continue;
531
697
  added.add(key);
532
- this.requestFactorized(this.getFirstPsc(low, high, this.maxVar));
698
+ const res = this.pscResultant(low, high, this.maxVar);
699
+ this.requestFactorized(res.getOrNull());
700
+ res.reset();
533
701
  }
534
702
  }
535
703
 
536
704
  private addSectionProjections() {
537
- const sectionPolynomial = this.intervals[this.level].lower;
705
+ const sectionPolynomial = this.intervals[this.level].lower.get();
538
706
  const withRoots = new Set(this.rootFunctions.map((rootFunction) => rootFunction.psIndex));
539
- this.levelPolys.forEach((polynomial, index) => {
540
- const isFull = polynomial === sectionPolynomial || !withRoots.has(index);
541
- this.addProjectionForPoly(polynomial, this.level, this.witnesses[index], isFull);
542
- });
707
+ for (let index = 0; index < this.levelPs.size; index++) {
708
+ const p = new PolynomialRef(this.pm);
709
+ p.set(this.levelPs.get(index));
710
+ const witness = new PolynomialRef(this.pm);
711
+ witness.copy(this.witnesses[index]);
712
+ const isFull = this.levelPs.get(index) === sectionPolynomial || !withRoots.has(index);
713
+ this.addProjectionForPoly(p.get(), this.level, witness.getOrNull(), isFull, true);
714
+ witness.reset();
715
+ p.reset();
716
+ }
543
717
  }
544
718
 
545
719
  private addSectorProjections() {
546
- this.levelPolys.forEach((polynomial, index) => {
720
+ const pm = this.pm;
721
+ for (let index = 0; index < this.levelPs.size; index++) {
722
+ const p = new PolynomialRef(pm);
723
+ p.set(this.levelPs.get(index));
724
+ const lc = new PolynomialRef(pm);
725
+ lc.set(pm.coeff(p.get(), this.level, pm.degree(p.get(), this.level)));
547
726
  const isLcAdded = !(this.isLcOmitted[index] ?? false);
548
- let witness = this.witnesses[index];
727
+ const witness = new PolynomialRef(pm);
728
+ witness.copy(this.witnesses[index]);
729
+ const value = witness.getOrNull();
549
730
  if (
550
731
  isLcAdded &&
551
- witness !== null &&
552
- !this.pm.isConst(witness) &&
553
- this.getSign(this.pm.lc(polynomial, this.level)) !== 0
732
+ value !== null &&
733
+ !pm.isConst(value) &&
734
+ !pm.isZero(lc.get()) &&
735
+ this.getSign(lc.get()) !== 0
554
736
  )
555
- witness = null;
556
- this.addProjectionForPoly(polynomial, this.level, witness, isLcAdded);
557
- });
737
+ witness.reset();
738
+ this.addProjectionForPoly(p.get(), this.level, witness.getOrNull(), isLcAdded, true);
739
+ witness.reset();
740
+ lc.reset();
741
+ p.reset();
742
+ }
558
743
  }
559
744
 
560
745
  private shouldUseSpanningTree() {
@@ -562,12 +747,19 @@ class Levelwise {
562
747
  if (this.lowerRf === UNSET || this.upperRf === UNSET) return false;
563
748
  if (this.getBoundIndex(this.lowerRf) === this.getBoundIndex(this.upperRf)) return false;
564
749
  let bothCount = 0;
565
- for (let index = 0; index < this.levelPolys.length; index++)
750
+ for (let index = 0; index < this.levelPs.size; index++)
566
751
  if (this.sideMask[index] === BOTH_SIDES && ++bothCount >= SPANNING_TREE_THRESHOLD)
567
752
  return true;
568
753
  return false;
569
754
  }
570
755
 
756
+ private clearLevelState() {
757
+ this.isLcOmitted = [];
758
+ this.pairs.clear();
759
+ this.sideMask = [];
760
+ this.degInOrderGraph = [];
761
+ }
762
+
571
763
  private processLevelWithMode(mode: ProjectionMode, hasInterval: boolean) {
572
764
  if (hasInterval) {
573
765
  if (mode === "section") this.fillRelationSection();
@@ -584,21 +776,23 @@ class Levelwise {
584
776
  }
585
777
 
586
778
  private collectNonNullWitnesses() {
587
- this.witnesses = [];
588
- for (let index = 0; index < this.levelPolys.length; index++) {
589
- const polynomial = this.levelPolys[index];
590
- const witness = this.chooseNonzeroCoeff(polynomial, this.level);
591
- if (witness === null) this.handleNullifiedPoly(polynomial);
592
- this.witnesses.push(witness);
593
- if (index + 1 === this.levelPolys.length)
594
- this.todo.extractPolysAtLevel(this.level, this.levelPolys);
779
+ this.clearWitnesses();
780
+ for (let index = 0; index < this.levelPs.size; index++) {
781
+ const p = new PolynomialRef(this.pm);
782
+ p.set(this.levelPs.get(index));
783
+ const witness = this.chooseNonzeroCoeff(p.get(), this.level);
784
+ if (witness.getOrNull() === null) this.handleNullifiedPoly(p.get());
785
+ const copy = new PolynomialRef(this.pm);
786
+ copy.copy(witness);
787
+ this.witnesses.push(copy);
788
+ if (index + 1 === this.levelPs.size) this.todo.extractPolysAtLevel(this.level, this.levelPs);
789
+ witness.reset();
790
+ p.reset();
595
791
  }
596
792
  }
597
793
 
598
794
  private processLevel() {
599
- this.isLcOmitted = [];
600
- this.pairs.clear();
601
- this.sideMask = [];
795
+ this.clearLevelState();
602
796
  this.collectNonNullWitnesses();
603
797
  const hasInterval = this.buildInterval();
604
798
  this.processLevelWithMode(
@@ -612,39 +806,65 @@ class Levelwise {
612
806
  }
613
807
 
614
808
  private processTopLevel() {
809
+ const pm = this.pm;
615
810
  this.collectNonNullWitnesses();
616
811
  this.addAdjacentRootResultants();
617
- this.levelPolys.forEach((polynomial, index) => {
618
- const leadingCoeff = this.pm.lc(polynomial, this.maxVar);
619
- const isLcAdded =
620
- this.hasRoots[index] || this.pm.isZero(leadingCoeff) || this.getSign(leadingCoeff) === 0;
621
- if (!isLcAdded) this.witnesses[index] = null;
622
- this.addProjectionForPoly(polynomial, this.maxVar, this.witnesses[index], isLcAdded);
812
+ for (let index = 0; index < this.levelPs.size; index++) {
813
+ const p = new PolynomialRef(pm);
814
+ p.set(this.levelPs.get(index));
815
+ const lc = new PolynomialRef(pm);
816
+ lc.set(pm.coeff(p.get(), this.maxVar, pm.degree(p.get(), this.maxVar)));
817
+ let isLcAdded = true;
818
+ if (
819
+ !(this.polyHasRoots[index] ?? false) &&
820
+ !pm.isZero(lc.get()) &&
821
+ this.getSign(lc.get()) !== 0
822
+ ) {
823
+ isLcAdded = false;
824
+ this.witnesses[index].reset();
825
+ }
826
+ this.addProjectionForPoly(
827
+ p.get(),
828
+ this.maxVar,
829
+ this.witnesses[index].getOrNull(),
830
+ isLcAdded,
831
+ true,
832
+ );
833
+ lc.reset();
834
+ p.reset();
835
+ }
836
+ }
837
+
838
+ private copyIntervals() {
839
+ return this.intervals.map((interval) => {
840
+ const copy = new CellInterval(this.pm);
841
+ copy.isSection = interval.isSection;
842
+ copy.lower.copy(interval.lower);
843
+ copy.lowerIndex = interval.lowerIndex;
844
+ copy.upper.copy(interval.upper);
845
+ copy.upperIndex = interval.upperIndex;
846
+ return copy;
623
847
  });
624
848
  }
625
849
 
626
- computeSingleCell(polynomials: readonly Polynomial[]) {
627
- if (this.maxVar === 0) return this.intervals;
628
- for (const polynomial of polynomials) this.requestFactorized(polynomial);
629
- if (this.todo.isEmpty) return this.intervals;
850
+ singleCell() {
851
+ if (this.maxVar === 0) return this.copyIntervals();
852
+ this.todo.reset();
853
+ for (let index = 0; index < this.polynomials.size; index++) {
854
+ const p = new PolynomialRef(this.pm);
855
+ p.set(this.polynomials.get(index));
856
+ this.requestFactorized(p.get());
857
+ p.reset();
858
+ }
859
+ if (this.todo.isEmpty) return this.copyIntervals();
630
860
  if (this.todo.getMaxVar() === this.maxVar) {
631
- this.level = this.todo.extractMaxPolys(this.levelPolys);
861
+ this.level = this.todo.extractMaxPolys(this.levelPs);
632
862
  this.processTopLevel();
633
863
  }
634
864
  while (!this.todo.isEmpty) {
635
- this.level = this.todo.extractMaxPolys(this.levelPolys);
865
+ this.level = this.todo.extractMaxPolys(this.levelPs);
636
866
  this.processLevel();
637
867
  }
638
- return this.intervals;
868
+ return this.copyIntervals();
639
869
  }
640
870
  }
641
-
642
- export const getSingleCell = (
643
- pm: PolynomialManager,
644
- am: AlgebraicManager,
645
- cache: PolynomialCache,
646
- polynomials: readonly Polynomial[],
647
- maxVar: number,
648
- sample: readonly (Anum | undefined)[],
649
- isLinear: boolean,
650
- ) => new Levelwise(pm, am, cache, sample, maxVar, isLinear).computeSingleCell(polynomials);