tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

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 (235) 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 +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +13 -3
  7. package/dist/index.d.ts +13 -3
  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 +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -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 +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
@@ -8,12 +8,14 @@ import {
8
8
  TRUE_BOOL_VAR,
9
9
  TRUE_LITERAL,
10
10
  } from "./atoms";
11
- import { getSingleCell, TodoSet } from "./levelwise";
11
+ import { type CellInterval, Levelwise, releaseIntervals, TodoSet } from "./levelwise";
12
12
  import {
13
13
  NULL_VAR,
14
14
  type Polynomial,
15
15
  type PolynomialCache,
16
16
  type PolynomialManager,
17
+ PolynomialRef,
18
+ PolynomialRefVector,
17
19
  } from "./polynomial";
18
20
  import { type IneqAtom, type IneqKind, type RootKind, isIneqAtom } from "./types";
19
21
 
@@ -64,9 +66,13 @@ const getKindForSign = (sign: number): IneqKind => (sign === 0 ? "EQ" : sign < 0
64
66
  export class Explain {
65
67
  private result: ScopedLiterals | null = null;
66
68
  private added = new Set<number>();
69
+ private ps: PolynomialRefVector;
70
+ private factors: PolynomialRefVector;
71
+ private factorsSave: PolynomialRefVector;
67
72
  private todo: TodoSet;
68
- private lowerStagePolys: Polynomial[] = [];
69
73
  private core: ScopedLiterals;
74
+ private lowerStagePolys: PolynomialRefVector;
75
+ private lastLwsInputPolys: PolynomialRefVector;
70
76
  private isAddAllCoeffs = false;
71
77
 
72
78
  isFullDimensional = false;
@@ -78,8 +84,13 @@ export class Explain {
78
84
  private cache: PolynomialCache,
79
85
  private context: ExplainContext,
80
86
  ) {
81
- this.todo = new TodoSet(pm, cache);
87
+ this.ps = new PolynomialRefVector(pm);
88
+ this.factors = new PolynomialRefVector(pm);
89
+ this.factorsSave = new PolynomialRefVector(pm);
90
+ this.todo = new TodoSet(cache, true);
82
91
  this.core = new ScopedLiterals(context.atoms);
92
+ this.lowerStagePolys = new PolynomialRefVector(pm);
93
+ this.lastLwsInputPolys = new PolynomialRefVector(pm);
83
94
  }
84
95
 
85
96
  private getSign(polynomial: Polynomial) {
@@ -106,16 +117,13 @@ export class Explain {
106
117
  this.core.reset();
107
118
  }
108
119
 
109
- private collectPolys(literals: readonly number[]) {
110
- return literals.flatMap((literal) => {
120
+ private collectPolys(literals: readonly number[], ps: PolynomialRefVector) {
121
+ ps.reset();
122
+ for (const literal of literals) {
111
123
  const atom = this.getAtom(literal);
112
- return isIneqAtom(atom) ? atom.polynomials : [atom.polynomial];
113
- });
114
- }
115
-
116
- private addAssumption(kind: IneqKind, polynomial: Polynomial, isNeg = false) {
117
- const boolVar = this.context.atoms.mkIneqAtom(kind, [polynomial], [false]);
118
- this.addLiteral(2 * boolVar + (isNeg ? 0 : 1));
124
+ if (isIneqAtom(atom)) for (const polynomial of atom.polynomials) ps.push(polynomial);
125
+ else ps.push(atom.polynomial);
126
+ }
119
127
  }
120
128
 
121
129
  private findSectionRoot(polynomial: Polynomial, variable: number) {
@@ -133,104 +141,153 @@ export class Explain {
133
141
  }
134
142
 
135
143
  private addZeroAssumption(polynomial: Polynomial) {
136
- const squareFree = this.pm.squareFree(polynomial);
137
- if (this.pm.isConst(squareFree)) return;
138
- const variable = this.pm.maxVar(squareFree);
139
- const index = this.findSectionRoot(squareFree, variable);
140
- if (index !== null) this.addRootLiteral("ROOT_EQ", variable, index, squareFree);
144
+ const q = new PolynomialRef(this.pm);
145
+ try {
146
+ this.pm.squareFree(polynomial, q);
147
+ if (this.pm.isConst(q.get())) return;
148
+ const variable = this.pm.maxVar(q.get());
149
+ const index = this.findSectionRoot(q.get(), variable);
150
+ if (index !== null) this.addRootLiteral("ROOT_EQ", variable, index, q.get());
151
+ } finally {
152
+ q.reset();
153
+ }
141
154
  }
142
155
 
143
- private elimVanishing(polynomial: Polynomial) {
144
- let p = polynomial;
145
- let variable = this.pm.maxVar(p);
146
- let degree = this.pm.degree(p, variable);
147
- while (true) {
148
- if (this.pm.isConst(p)) return p;
149
- if (degree === 0) {
150
- variable = this.pm.maxVar(p);
151
- degree = this.pm.degree(p, variable);
152
- }
153
- if (this.pm.isNonzeroConstCoeff(p, variable, degree)) return p;
154
- // Z3's insert_fresh_factors_in_todo writes lc back without its vanishing coefficients.
155
- const lc = this.insertFreshFactorsInTodo(this.pm.coeff(p, variable, degree));
156
- const reduct = this.pm.reduct(p, variable, degree);
157
- if (!this.pm.isZero(lc) && this.getSign(lc) !== 0) return p;
158
- if (degree === 0) {
159
- if (this.isAddAllCoeffs) {
160
- this.addZeroAssumption(lc);
161
- return this.pm.zero;
156
+ private addAssumption(kind: IneqKind, polynomial: Polynomial, isNeg = false) {
157
+ const boolVar = this.context.atoms.mkIneqAtom(kind, [polynomial], [false]);
158
+ this.addLiteral(2 * boolVar + (isNeg ? 0 : 1));
159
+ }
160
+
161
+ private elimVanishing(p: PolynomialRef) {
162
+ const pm = this.pm;
163
+ let variable = pm.maxVar(p.get());
164
+ let degree = pm.degree(p.get(), variable);
165
+ const lc = new PolynomialRef(pm);
166
+ const reduct = new PolynomialRef(pm);
167
+ try {
168
+ while (true) {
169
+ if (pm.isConst(p.get())) return;
170
+ if (degree === 0) {
171
+ variable = pm.maxVar(p.get());
172
+ degree = pm.degree(p.get(), variable);
162
173
  }
163
- this.isAddAllCoeffs = true;
164
- throw new AddAllCoeffsRestart();
174
+ if (pm.isNonzeroConstCoeff(p.get(), variable, degree)) return;
175
+ lc.set(pm.coeffWithReduct(p.get(), variable, degree, reduct));
176
+ this.insertFreshFactorsInTodo(lc);
177
+ if (!pm.isZero(lc.get()) && this.getSign(lc.get()) !== 0) return;
178
+ if (degree === 0) {
179
+ p.set(pm.zero);
180
+ if (this.isAddAllCoeffs) {
181
+ this.addZeroAssumption(lc.get());
182
+ return;
183
+ }
184
+ this.isAddAllCoeffs = true;
185
+ throw new AddAllCoeffsRestart();
186
+ }
187
+ this.addZeroAssumption(lc.get());
188
+ degree--;
189
+ p.copy(reduct);
165
190
  }
166
- this.addZeroAssumption(lc);
167
- degree--;
168
- p = reduct;
191
+ } finally {
192
+ reduct.reset();
193
+ lc.reset();
169
194
  }
170
195
  }
171
196
 
172
- private elimVanishingAll(polynomials: readonly Polynomial[]) {
173
- return polynomials
174
- .map((polynomial) => this.elimVanishing(polynomial))
175
- .filter((polynomial) => !this.pm.isConst(polynomial));
197
+ private elimVanishingAll(ps: PolynomialRefVector) {
198
+ const size = ps.size;
199
+ const p = new PolynomialRef(this.pm);
200
+ try {
201
+ let kept = 0;
202
+ for (let index = 0; index < size; index++) {
203
+ p.set(ps.get(index));
204
+ this.elimVanishing(p);
205
+ if (!this.pm.isConst(p.get())) ps.set(kept++, p.get());
206
+ }
207
+ ps.shrink(kept);
208
+ } finally {
209
+ p.reset();
210
+ }
176
211
  }
177
212
 
178
- private insertFreshFactorsInTodo(polynomial: Polynomial) {
179
- if (this.pm.isConst(polynomial)) return polynomial;
180
- const p = this.elimVanishing(polynomial);
181
- if (this.pm.isConst(p)) return p;
213
+ private insertFreshFactorsInTodo(p: PolynomialRef) {
214
+ if (this.pm.isConst(p.get())) return;
215
+ this.elimVanishing(p);
216
+ if (this.pm.isConst(p.get())) return;
182
217
  if (!this.isFactoring) {
183
- this.todo.insert(p);
184
- return p;
218
+ this.todo.insert(p.get());
219
+ return;
185
220
  }
186
- for (const factor of this.cache.factor(p)) {
187
- const reduced = this.elimVanishing(factor);
188
- if (!this.pm.isConst(reduced)) this.todo.insert(reduced);
221
+ const saved = this.factorsSave.size;
222
+ this.factorsSave.append(this.factors);
223
+ const f = new PolynomialRef(this.pm);
224
+ try {
225
+ this.cache.factor(p.get(), this.factors);
226
+ for (let index = 0; index < this.factors.size; index++) {
227
+ f.set(this.factors.get(index));
228
+ this.elimVanishing(f);
229
+ if (!this.pm.isConst(f.get())) this.todo.insert(f.get());
230
+ }
231
+ } finally {
232
+ f.reset();
233
+ this.factors.reset();
234
+ for (let index = saved; index < this.factorsSave.size; index++)
235
+ this.factors.push(this.factorsSave.get(index));
236
+ this.factorsSave.shrink(saved);
189
237
  }
190
- return p;
191
238
  }
192
239
 
193
240
  private normalizeLiteral(literal: number, max: number) {
194
241
  if (literal >> 1 === TRUE_BOOL_VAR) return literal;
195
242
  const atom = this.getAtom(literal);
196
243
  if (!isIneqAtom(atom)) return literal;
244
+ const pm = this.pm;
197
245
  const isNeg = (literal & 1) === 1;
198
- const polynomials: Polynomial[] = [];
246
+ const ps = new PolynomialRefVector(pm);
199
247
  const isEven: boolean[] = [];
200
- let atomSign = 1;
201
- let isNormalized = false;
202
- for (const [index, factor] of atom.polynomials.entries()) {
203
- const p = this.pm.maxVar(factor) === max ? this.elimVanishing(factor) : factor;
204
- if (this.pm.isConst(p) || this.pm.maxVar(p) < max) {
205
- const sign = this.getSign(p);
206
- if (!this.pm.isConst(p)) {
207
- this.lowerStagePolys.push(p);
208
- if (sign === 0) this.addAssumption("EQ", p);
209
- else if (atom.isEven[index]) this.addAssumption("EQ", p, true);
210
- else this.addAssumption(getKindForSign(sign), p);
248
+ const p = new PolynomialRef(pm);
249
+ try {
250
+ let atomSign = 1;
251
+ let isNormalized = false;
252
+ for (let index = 0; index < atom.polynomials.length; index++) {
253
+ p.set(atom.polynomials[index]);
254
+ if (pm.maxVar(p.get()) === max) this.elimVanishing(p);
255
+ if (pm.isConst(p.get()) || pm.maxVar(p.get()) < max) {
256
+ const sign = this.getSign(p.get());
257
+ if (!pm.isConst(p.get())) {
258
+ this.lowerStagePolys.push(p.get());
259
+ if (sign === 0) this.addAssumption("EQ", p.get());
260
+ else if (atom.isEven[index]) this.addAssumption("EQ", p.get(), true);
261
+ else this.addAssumption(getKindForSign(sign), p.get());
262
+ }
263
+ if (sign === 0) return (atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
264
+ if (sign < 0 && !atom.isEven[index]) atomSign = -atomSign;
265
+ isNormalized = true;
266
+ continue;
211
267
  }
212
- if (sign === 0) return (atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
213
- if (sign < 0 && !atom.isEven[index]) atomSign = -atomSign;
214
- isNormalized = true;
215
- continue;
268
+ if (p.get() !== atom.polynomials[index]) isNormalized = true;
269
+ isEven.push(atom.isEven[index]);
270
+ ps.push(p.get());
216
271
  }
217
- if (p !== factor) isNormalized = true;
218
- isEven.push(atom.isEven[index]);
219
- polynomials.push(p);
220
- }
221
- if (polynomials.length === 0) {
222
- const isTrue = atom.kind === "EQ" ? false : atom.kind === "LT" ? atomSign < 0 : atomSign > 0;
223
- return isTrue !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
272
+ if (ps.size === 0) {
273
+ const isTrue =
274
+ atom.kind === "EQ" ? false : atom.kind === "LT" ? atomSign < 0 : atomSign > 0;
275
+ return isTrue !== isNeg ? TRUE_LITERAL : FALSE_LITERAL;
276
+ }
277
+ if (!isNormalized) return literal;
278
+ const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
279
+ return this.context.atoms.mkIneqLiteral(kind, ps.items, isEven) ^ (isNeg ? 1 : 0);
280
+ } finally {
281
+ p.reset();
282
+ ps.reset();
224
283
  }
225
- if (!isNormalized) return literal;
226
- const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
227
- return this.context.atoms.mkIneqLiteral(kind, polynomials, isEven) ^ (isNeg ? 1 : 0);
228
284
  }
229
285
 
230
286
  private normalizeCore(core: ScopedLiterals, max: number) {
287
+ const size = core.size;
231
288
  let kept = 0;
232
- for (const literal of core.literals) {
233
- const normalized = this.normalizeLiteral(literal, max);
289
+ for (let index = 0; index < size; index++) {
290
+ const normalized = this.normalizeLiteral(core.literals[index], max);
234
291
  if (normalized === TRUE_LITERAL) continue;
235
292
  if (normalized === FALSE_LITERAL) {
236
293
  core.reset();
@@ -247,81 +304,93 @@ export class Explain {
247
304
  newLiteral.set(literal);
248
305
  return;
249
306
  }
307
+ const pm = this.pm;
250
308
  const isNeg = (literal & 1) === 1;
251
- const factors: Polynomial[] = [];
252
- const isEven: boolean[] = [];
253
309
  let atomSign = 1;
254
310
  let isModified = false;
311
+ const newFactors = new PolynomialRefVector(pm);
312
+ const newFactorsEven: boolean[] = [];
313
+ const newFactor = new PolynomialRef(pm);
255
314
  const addLcCondition = (steps: number, isFactorEven: boolean) => {
256
315
  if (info.isLcConst) return;
257
316
  if (steps % 2 === 0 || isFactorEven || atom.kind === "EQ") addLcDiseq(info);
258
317
  else addLcIneq(info);
259
318
  };
260
- for (const [index, factor] of atom.polynomials.entries()) {
261
- const isFactorEven = atom.isEven[index];
262
- if (this.pm.degree(factor, info.variable) < info.degree) {
263
- factors.push(factor);
264
- isEven.push(isFactorEven);
265
- continue;
319
+ try {
320
+ for (let index = 0; index < atom.polynomials.length; index++) {
321
+ const factor = atom.polynomials[index];
322
+ const isFactorEven = atom.isEven[index];
323
+ if (pm.degree(factor, info.variable) < info.degree) {
324
+ newFactors.push(factor);
325
+ newFactorsEven.push(isFactorEven);
326
+ continue;
327
+ }
328
+ isModified = true;
329
+ const steps = pm.pseudoRemainder(factor, info.eq, info.variable, newFactor);
330
+ if (steps % 2 === 1 && !isFactorEven && info.lcSign < 0) atomSign = -atomSign;
331
+ if (pm.isConst(newFactor.get())) {
332
+ const sign = this.getSign(newFactor.get());
333
+ if (sign === 0) {
334
+ newLiteral.set((atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL);
335
+ if (!info.isLcConst) addLcDiseq(info);
336
+ return;
337
+ }
338
+ addLcCondition(steps, isFactorEven);
339
+ if (sign < 0 && !isFactorEven) atomSign = -atomSign;
340
+ continue;
341
+ }
342
+ newFactors.push(newFactor.get());
343
+ newFactorsEven.push(isFactorEven);
344
+ addLcCondition(steps, isFactorEven);
266
345
  }
267
- isModified = true;
268
- const division = this.pm.pseudoRemainder(factor, info.eq, info.variable);
269
- if (division.steps % 2 === 1 && !isFactorEven && info.lcSign < 0) atomSign = -atomSign;
270
- const remainder = division.remainder;
271
- if (!this.pm.isConst(remainder)) {
272
- factors.push(remainder);
273
- isEven.push(isFactorEven);
274
- addLcCondition(division.steps, isFactorEven);
275
- continue;
346
+ if (!isModified) {
347
+ newLiteral.set(literal);
348
+ return;
276
349
  }
277
- const sign = this.getSign(remainder);
278
- if (sign === 0) {
279
- newLiteral.set((atom.kind === "EQ") !== isNeg ? TRUE_LITERAL : FALSE_LITERAL);
280
- if (!info.isLcConst) addLcDiseq(info);
350
+ const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
351
+ newLiteral.set(
352
+ this.context.atoms.mkIneqLiteral(kind, newFactors.items, newFactorsEven) ^ (isNeg ? 1 : 0),
353
+ );
354
+ // Z3's null_var is the largest unsigned, so true and false never count as lower stage.
355
+ const maxVar = this.context.atoms.getMaxVar(newLiteral.literal);
356
+ if (maxVar === NULL_VAR || maxVar >= max) {
357
+ newLiteral.set(this.normalizeLiteral(newLiteral.literal, max));
281
358
  return;
282
359
  }
283
- addLcCondition(division.steps, isFactorEven);
284
- if (sign < 0 && !isFactorEven) atomSign = -atomSign;
285
- }
286
- if (!isModified) {
287
- newLiteral.set(literal);
288
- return;
289
- }
290
- const kind = atomSign < 0 ? flipKind(atom.kind) : atom.kind;
291
- newLiteral.set(this.context.atoms.mkIneqLiteral(kind, factors, isEven) ^ (isNeg ? 1 : 0));
292
- // Z3's null_var is the largest unsigned, so true and false never count as lower stage.
293
- const maxVar = this.context.atoms.getMaxVar(newLiteral.literal);
294
- if (maxVar === NULL_VAR || maxVar >= max) {
295
- newLiteral.set(this.normalizeLiteral(newLiteral.literal, max));
296
- return;
297
- }
298
- if (this.context.getValue(newLiteral.literal) === 1) {
299
- newLiteral.set(literal);
300
- return;
360
+ if (this.context.getValue(newLiteral.literal) === 1) {
361
+ newLiteral.set(literal);
362
+ return;
363
+ }
364
+ this.addLiteral(newLiteral.literal);
365
+ newLiteral.set(TRUE_LITERAL);
366
+ } finally {
367
+ newFactor.reset();
368
+ newFactors.reset();
301
369
  }
302
- this.addLiteral(newLiteral.literal);
303
- newLiteral.set(TRUE_LITERAL);
304
370
  }
305
371
 
306
372
  private simplifyWithEq(core: ScopedLiterals, eq: Polynomial, max: number) {
307
373
  const variable = this.pm.maxVar(eq);
308
374
  const degree = this.pm.degree(eq, variable);
309
- const lc = this.pm.coeff(eq, variable, degree);
310
- const info = {
311
- eq,
312
- variable,
313
- degree,
314
- lc,
315
- lcSign: this.getSign(lc),
316
- isLcConst: this.pm.isConst(lc),
317
- isLcAdded: false,
318
- isLcIneqAdded: false,
319
- };
375
+ const lcEq = new PolynomialRef(this.pm);
320
376
  const newLiteral = new ScopedLiteral(this.context.atoms);
321
377
  try {
378
+ lcEq.set(this.pm.coeff(eq, variable, degree));
379
+ const info = {
380
+ eq,
381
+ variable,
382
+ degree,
383
+ lc: lcEq.get(),
384
+ lcSign: this.getSign(lcEq.get()),
385
+ isLcConst: this.pm.isConst(lcEq.get()),
386
+ isLcAdded: false,
387
+ isLcIneqAdded: false,
388
+ };
389
+ const size = core.size;
322
390
  let isModified = false;
323
391
  let kept = 0;
324
- for (const literal of core.literals) {
392
+ for (let index = 0; index < size; index++) {
393
+ const literal = core.literals[index];
325
394
  newLiteral.set(TRUE_LITERAL);
326
395
  this.simplifyLiteral(literal, info, max, newLiteral);
327
396
  if (newLiteral.literal === literal) {
@@ -344,6 +413,7 @@ export class Explain {
344
413
  return isModified;
345
414
  } finally {
346
415
  newLiteral.set(TRUE_LITERAL);
416
+ lcEq.reset();
347
417
  }
348
418
  }
349
419
 
@@ -370,8 +440,7 @@ export class Explain {
370
440
  const atom = this.getAtom(literal);
371
441
  if (!isIneqAtom(atom)) continue;
372
442
  for (const factor of atom.polynomials) {
373
- const variables = new Set(factor.ms.flatMap((monomial) => [...monomial.vars]));
374
- for (const variable of variables) {
443
+ for (const variable of this.pm.getVars(factor)) {
375
444
  if (variable >= max) continue;
376
445
  const eq = this.context.var2eq[variable] ?? null;
377
446
  if (eq === null) continue;
@@ -399,122 +468,210 @@ export class Explain {
399
468
  }
400
469
 
401
470
  private addRootLiteral(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
402
- if (this.mkLinearRoot(kind, variable, polynomial)) return;
403
- if (this.mkQuadraticRoot(kind, variable, index, polynomial)) return;
404
- const boolVar = this.context.atoms.mkRootAtom(kind, variable, index, polynomial);
405
- this.addLiteral(2 * boolVar + 1);
471
+ const pr = new PolynomialRef(this.pm);
472
+ pr.set(polynomial);
473
+ try {
474
+ if (
475
+ this.mkLinearRoot(kind, variable, polynomial) ||
476
+ this.mkQuadraticRoot(kind, variable, index, polynomial)
477
+ )
478
+ return;
479
+ const boolVar = this.context.atoms.mkRootAtom(kind, variable, index, polynomial);
480
+ this.addLiteral(2 * boolVar + 1);
481
+ } finally {
482
+ pr.reset();
483
+ }
406
484
  }
407
485
 
408
486
  private mkLinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
487
+ if (this.pm.degree(polynomial, variable) !== 1) return false;
409
488
  const coeff = this.pm.getConstCoeff(polynomial, variable, 1);
410
- if (this.pm.degree(polynomial, variable) !== 1 || coeff === null) return false;
489
+ if (coeff === null) return false;
411
490
  this.addLinearRoot(kind, polynomial, coeff < 0n);
412
491
  return true;
413
492
  }
414
493
 
415
- private addLinearRoot(kind: RootKind, polynomial: Polynomial, isNegated: boolean) {
416
- const ineq = ROOT_TO_INEQ[kind];
417
- this.addAssumption(ineq.kind, isNegated ? this.pm.neg(polynomial) : polynomial, ineq.isNeg);
418
- }
419
-
420
494
  private mkPlinearRoot(kind: RootKind, variable: number, polynomial: Polynomial) {
421
495
  if (this.pm.degree(polynomial, variable) !== 1) return false;
422
- const coeff = this.pm.coeff(polynomial, variable, 1);
423
- const sign = this.getSign(coeff);
424
- if (sign === 0) return false;
425
- this.ensureSign(coeff);
426
- this.addLinearRoot(kind, polynomial, sign < 0);
427
- return true;
496
+ const c = new PolynomialRef(this.pm);
497
+ try {
498
+ c.set(this.pm.coeff(polynomial, variable, 1));
499
+ const sign = this.getSign(c.get());
500
+ if (sign === 0) return false;
501
+ this.ensureSign(c);
502
+ this.addLinearRoot(kind, polynomial, sign < 0);
503
+ return true;
504
+ } finally {
505
+ c.reset();
506
+ }
428
507
  }
429
508
 
430
509
  private mkQuadraticRoot(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
431
- if (this.pm.degree(polynomial, variable) !== 2 || (index !== 1 && index !== 2)) return false;
432
- const a = this.pm.coeff(polynomial, variable, 2);
433
- const b = this.pm.coeff(polynomial, variable, 1);
434
- const c = this.pm.coeff(polynomial, variable, 0);
435
- const discriminant = this.pm.sub(this.pm.mul(b, b), this.pm.mul(this.pm.mulConst(4n, a), c));
436
- const y = this.pm.mkVar(variable);
437
- const derivative = this.pm.normalize(this.pm.add(this.pm.mul(this.pm.mulConst(2n, a), y), b));
438
- if (this.ensureSignQuad(discriminant) < 0) return false;
439
- if (this.ensureSignQuad(a) === 0)
440
- return this.mkPlinearRoot(kind, variable, this.pm.add(this.pm.mul(b, y), c));
441
- this.ensureSign(derivative);
442
- if (this.getSign(discriminant) > 0) this.ensureSign(polynomial);
443
- return true;
510
+ const pm = this.pm;
511
+ if (pm.degree(polynomial, variable) !== 2) return false;
512
+ if (index !== 1 && index !== 2) return false;
513
+ const a = new PolynomialRef(pm);
514
+ const b = new PolynomialRef(pm);
515
+ const c = new PolynomialRef(pm);
516
+ const q = new PolynomialRef(pm);
517
+ const pDiff = new PolynomialRef(pm);
518
+ const yy = new PolynomialRef(pm);
519
+ const pr = new PolynomialRef(pm);
520
+ const first = new PolynomialRef(pm);
521
+ const second = new PolynomialRef(pm);
522
+ const third = new PolynomialRef(pm);
523
+ try {
524
+ a.set(pm.coeff(polynomial, variable, 2));
525
+ b.set(pm.coeff(polynomial, variable, 1));
526
+ c.set(pm.coeff(polynomial, variable, 0));
527
+ first.set(pm.mul(b.get(), b.get()));
528
+ second.set(pm.mulConst(4n, a.get()));
529
+ third.set(pm.mul(second.get(), c.get()));
530
+ q.set(pm.sub(first.get(), third.get()));
531
+ third.reset();
532
+ second.reset();
533
+ first.reset();
534
+ yy.set(pm.mkVar(variable));
535
+ first.set(pm.mulConst(2n, a.get()));
536
+ second.set(pm.mul(first.get(), yy.get()));
537
+ pDiff.set(pm.add(second.get(), b.get()));
538
+ second.reset();
539
+ first.reset();
540
+ pDiff.set(pm.normalize(pDiff.get()));
541
+ const discriminantSign = this.ensureSignQuad(q);
542
+ if (discriminantSign < 0) return false;
543
+ if (this.ensureSignQuad(a) === 0) {
544
+ first.set(pm.mul(b.get(), yy.get()));
545
+ q.set(pm.add(first.get(), c.get()));
546
+ first.reset();
547
+ return this.mkPlinearRoot(kind, variable, q.get());
548
+ }
549
+ this.ensureSign(pDiff);
550
+ if (discriminantSign > 0) {
551
+ pr.set(polynomial);
552
+ this.ensureSign(pr);
553
+ }
554
+ return true;
555
+ } finally {
556
+ third.reset();
557
+ second.reset();
558
+ first.reset();
559
+ pr.reset();
560
+ yy.reset();
561
+ pDiff.reset();
562
+ q.reset();
563
+ c.reset();
564
+ b.reset();
565
+ a.reset();
566
+ }
444
567
  }
445
568
 
446
- private ensureSign(polynomial: Polynomial) {
447
- if (this.pm.isConst(polynomial)) return;
448
- this.addAssumption(getKindForSign(this.getSign(polynomial)), polynomial);
449
- this.insertFreshFactorsInTodo(polynomial);
569
+ private ensureSign(p: PolynomialRef) {
570
+ if (this.pm.isConst(p.get())) return;
571
+ this.addAssumption(getKindForSign(this.getSign(p.get())), p.get());
572
+ this.insertFreshFactorsInTodo(p);
450
573
  }
451
574
 
452
- private ensureSignQuad(polynomial: Polynomial) {
453
- const sign = this.getSign(polynomial);
454
- if (!this.pm.isConst(polynomial)) {
455
- this.addAssumption(getKindForSign(sign), polynomial);
456
- this.insertFreshFactorsInTodo(polynomial);
575
+ private ensureSignQuad(p: PolynomialRef) {
576
+ const sign = this.getSign(p.get());
577
+ if (!this.pm.isConst(p.get())) {
578
+ this.addAssumption(getKindForSign(sign), p.get());
579
+ this.insertFreshFactorsInTodo(p);
457
580
  }
458
581
  return sign;
459
582
  }
460
583
 
461
- private addCellLiterals(polynomials: readonly Polynomial[], maxVar: number, isLinear: boolean) {
462
- const cell = getSingleCell(
584
+ private addLinearRoot(kind: RootKind, polynomial: Polynomial, isNegated: boolean) {
585
+ const pPrime = new PolynomialRef(this.pm);
586
+ pPrime.set(polynomial);
587
+ if (isNegated) pPrime.set(this.pm.neg(pPrime.get()));
588
+ const ineq = ROOT_TO_INEQ[kind];
589
+ this.addAssumption(ineq.kind, pPrime.get(), ineq.isNeg);
590
+ pPrime.reset();
591
+ }
592
+
593
+ private levelwiseSingleCell(ps: PolynomialRefVector, maxVar: number, isLinear: boolean) {
594
+ this.lastLwsInputPolys.reset();
595
+ for (let index = 0; index < ps.size; index++) this.lastLwsInputPolys.push(ps.get(index));
596
+ const levelwise = new Levelwise(
463
597
  this.pm,
464
598
  this.am,
465
599
  this.cache,
466
- polynomials,
600
+ ps,
467
601
  maxVar,
468
602
  this.context.sample,
469
603
  isLinear,
470
604
  );
471
- const isFull = this.isFullDimensional;
472
- for (const interval of cell) {
473
- if (interval.isSection) {
474
- const lower = interval.lower!;
475
- this.addRootLiteral("ROOT_EQ", this.pm.maxVar(lower), interval.lowerIndex, lower);
476
- continue;
605
+ let cell: CellInterval[] = [];
606
+ try {
607
+ cell = levelwise.singleCell();
608
+ const isFull = this.isFullDimensional;
609
+ for (const interval of cell) {
610
+ if (interval.isSection) {
611
+ const lower = interval.lower.get();
612
+ this.addRootLiteral("ROOT_EQ", this.pm.maxVar(lower), interval.lowerIndex, lower);
613
+ continue;
614
+ }
615
+ const lower = interval.lower.getOrNull();
616
+ const upper = interval.upper.getOrNull();
617
+ if (lower !== null)
618
+ this.addRootLiteral(
619
+ isFull ? "ROOT_GE" : "ROOT_GT",
620
+ this.pm.maxVar(lower),
621
+ interval.lowerIndex,
622
+ lower,
623
+ );
624
+ if (upper !== null)
625
+ this.addRootLiteral(
626
+ isFull ? "ROOT_LE" : "ROOT_LT",
627
+ this.pm.maxVar(upper),
628
+ interval.upperIndex,
629
+ upper,
630
+ );
477
631
  }
478
- if (interval.lower !== null)
479
- this.addRootLiteral(
480
- isFull ? "ROOT_GE" : "ROOT_GT",
481
- this.pm.maxVar(interval.lower),
482
- interval.lowerIndex,
483
- interval.lower,
484
- );
485
- if (interval.upper !== null)
486
- this.addRootLiteral(
487
- isFull ? "ROOT_LE" : "ROOT_LT",
488
- this.pm.maxVar(interval.upper),
489
- interval.upperIndex,
490
- interval.upper,
491
- );
632
+ } finally {
633
+ releaseIntervals(cell);
634
+ levelwise.release();
492
635
  }
493
636
  }
494
637
 
495
- private project(polynomials: readonly Polynomial[], maxVar: number) {
496
- if (polynomials.length === 0) return;
638
+ private project(ps: PolynomialRefVector, maxVar: number) {
639
+ if (ps.size === 0) return;
497
640
  this.todo.reset();
498
- for (const polynomial of polynomials) this.insertFreshFactorsInTodo(polynomial);
499
- this.addCellLiterals([...this.todo.polynomials], maxVar, false);
641
+ const p = new PolynomialRef(this.pm);
642
+ try {
643
+ for (let index = 0; index < ps.size; index++) {
644
+ p.set(ps.get(index));
645
+ this.insertFreshFactorsInTodo(p);
646
+ p.reset();
647
+ }
648
+ } finally {
649
+ p.reset();
650
+ }
651
+ ps.reset();
652
+ for (const polynomial of this.todo.set.items) ps.push(polynomial);
653
+ this.levelwiseSingleCell(ps, maxVar, false);
500
654
  }
501
655
 
502
- private explainCore(literals: readonly number[]) {
656
+ private main(literals: readonly number[]) {
503
657
  if (literals.length === 0) return;
504
- const polynomials = [...this.collectPolys(literals), ...this.lowerStagePolys];
505
- const maxVar = this.pm.getMaxVarOfPolys(polynomials);
506
- this.project(this.elimVanishingAll(polynomials), maxVar);
658
+ this.collectPolys(literals, this.ps);
659
+ for (let index = 0; index < this.lowerStagePolys.size; index++)
660
+ this.ps.push(this.lowerStagePolys.get(index));
661
+ const maxVar = this.pm.getMaxVarOfPolys(this.ps.items);
662
+ this.elimVanishingAll(this.ps);
663
+ this.project(this.ps, maxVar);
507
664
  }
508
665
 
509
666
  private process(literals: readonly number[]) {
510
- this.lowerStagePolys = [];
667
+ this.lowerStagePolys.reset();
511
668
  const core = this.core;
512
669
  core.reset();
513
670
  for (const literal of literals) core.push(literal);
514
671
  const max = this.context.atoms.getMaxVarOfLiterals(literals);
515
672
  this.normalizeCore(core, max);
516
673
  this.simplifyCore(core, max);
517
- this.explainCore(core.literals);
674
+ this.main(core.literals);
518
675
  core.reset();
519
676
  }
520
677
 
@@ -563,9 +720,9 @@ export class Explain {
563
720
  if (isContaining) kept.push(literal);
564
721
  else this.addLiteral(literal ^ 1);
565
722
  }
566
- const polynomials = this.collectPolys(kept);
567
- if (polynomials.length > 0) {
568
- const maxVar = this.pm.getMaxVarOfPolys(polynomials);
723
+ this.collectPolys(kept, this.ps);
724
+ if (this.ps.size > 0) {
725
+ const maxVar = this.pm.getMaxVarOfPolys(this.ps.items);
569
726
  if (maxVar !== variable) {
570
727
  const renaming = Array.from({ length: this.context.getNumVars() }, (_value, index) =>
571
728
  index === variable ? maxVar : index === maxVar ? variable : index,
@@ -573,7 +730,8 @@ export class Explain {
573
730
  this.context.reorder(renaming);
574
731
  isReordered = true;
575
732
  }
576
- this.project(this.elimVanishingAll(polynomials), maxVar);
733
+ this.elimVanishingAll(this.ps);
734
+ this.project(this.ps, maxVar);
577
735
  this.resetResult();
578
736
  if (isReordered) this.context.restoreOrder();
579
737
  }
@@ -591,11 +749,11 @@ export class Explain {
591
749
 
592
750
  computeLinearExplanation(literals: readonly number[], result: ScopedLiterals) {
593
751
  this.result = result;
594
- this.lowerStagePolys = [];
595
- const polynomials = this.collectPolys(literals);
596
752
  try {
597
- if (polynomials.length > 0)
598
- this.addCellLiterals(polynomials, this.pm.getMaxVarOfPolys(polynomials) + 1, true);
753
+ this.lowerStagePolys.reset();
754
+ this.collectPolys(literals, this.ps);
755
+ if (this.ps.size === 0) return;
756
+ this.levelwiseSingleCell(this.ps, this.pm.getMaxVarOfPolys(this.ps.items) + 1, true);
599
757
  } finally {
600
758
  this.resetResult();
601
759
  }