tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.1ebc153bd

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 (214) 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 +2 -1
  7. package/dist/index.d.ts +2 -1
  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 +43 -43
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +33 -35
  16. package/dist/run.js +44 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +43 -43
  20. package/dist/transfer.js +38 -38
  21. package/dist/worker.cjs +6 -6
  22. package/dist/worker.js +6 -6
  23. package/package.json +1 -1
  24. package/src/ast.ts +1 -0
  25. package/src/bags.ts +46 -28
  26. package/src/check-trace.ts +2 -16
  27. package/src/check.ts +152 -64
  28. package/src/cli/runtime-invariants.ts +20 -56
  29. package/src/cli/tlc-arguments.ts +2 -2
  30. package/src/cli/tlc-output.ts +1 -2
  31. package/src/cli/tlc.ts +13 -8
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +9 -5
  34. package/src/dependencies.ts +49 -9
  35. package/src/dfid.ts +9 -2
  36. package/src/environment.ts +57 -33
  37. package/src/errors.ts +7 -0
  38. package/src/evaluate.ts +92 -32
  39. package/src/exit-codes.ts +4 -2
  40. package/src/instances.ts +5 -5
  41. package/src/java-overrides.ts +2 -2
  42. package/src/levels.ts +138 -90
  43. package/src/liveness-checker.ts +43 -4
  44. package/src/liveness.ts +1 -1
  45. package/src/obligations/index.ts +1 -1
  46. package/src/obligations/normalize.ts +1 -4
  47. package/src/obligations/printer.ts +5 -5
  48. package/src/parallel-worker.ts +8 -2
  49. package/src/parallel.ts +5 -0
  50. package/src/parser.ts +106 -144
  51. package/src/prover/isabelle/isar/attrib.ts +4 -4
  52. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  53. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  54. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  55. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  56. package/src/prover/isabelle/pure/term.ts +3 -3
  57. package/src/prover/prep/md5.ts +26 -29
  58. package/src/prover/smt/rewrite.ts +2 -7
  59. package/src/prover/smt/simplify.ts +1 -1
  60. package/src/prover/smt/solver/asserted-formulas.ts +66 -1
  61. package/src/prover/smt/solver/ast-lt.ts +1 -1
  62. package/src/prover/smt/solver/ast.ts +58 -11
  63. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  64. package/src/prover/smt/solver/bound-simplifier.ts +2 -3
  65. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  66. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  67. package/src/prover/smt/solver/card2bv.ts +3 -5
  68. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
  69. package/src/prover/smt/solver/context.ts +24 -3
  70. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  71. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  72. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  73. package/src/prover/smt/solver/diff-neq.ts +1 -2
  74. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  75. package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
  76. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  77. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  78. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  79. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  80. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  81. package/src/prover/smt/solver/euf/mam.ts +1 -5
  82. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  83. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  84. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  85. package/src/prover/smt/solver/factor.ts +36 -14
  86. package/src/prover/smt/solver/fd-solver.ts +2 -0
  87. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  88. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  89. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  90. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  91. package/src/prover/smt/solver/goal.ts +6 -3
  92. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  93. package/src/prover/smt/solver/hashtable.ts +4 -0
  94. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  95. package/src/prover/smt/solver/lp/containers.ts +7 -1
  96. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  97. package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
  98. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  99. package/src/prover/smt/solver/lp/nex.ts +2 -1
  100. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  101. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  102. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  103. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  104. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  105. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  106. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  107. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  108. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  109. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  110. package/src/prover/smt/solver/model-generator.ts +3 -1
  111. package/src/prover/smt/solver/mpf.ts +2 -4
  112. package/src/prover/smt/solver/mus.ts +2 -3
  113. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  114. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  115. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  116. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  117. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  118. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  119. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  120. package/src/prover/smt/solver/nlqsat.ts +1 -1
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  122. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  123. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  124. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  125. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  126. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  127. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  128. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  129. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  130. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  131. package/src/prover/smt/solver/nnf.ts +6 -2
  132. package/src/prover/smt/solver/opt-context.ts +9 -3
  133. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  134. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  135. package/src/prover/smt/solver/opt-solver.ts +6 -3
  136. package/src/prover/smt/solver/optsmt.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +74 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +4 -6
  141. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  142. package/src/prover/smt/solver/qe-lite.ts +2 -2
  143. package/src/prover/smt/solver/qe.ts +3 -2
  144. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  145. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  146. package/src/prover/smt/solver/rlimit.ts +4 -0
  147. package/src/prover/smt/solver/sat/config.ts +1 -1
  148. package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
  149. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  150. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  151. package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
  152. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  153. package/src/prover/smt/solver/sat/solver.ts +25 -47
  154. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  155. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  156. package/src/prover/smt/solver/seq-derive.ts +4 -7
  157. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  158. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  159. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  160. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  161. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  162. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  163. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  164. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  165. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  166. package/src/prover/smt/solver/smt-kernel.ts +9 -3
  167. package/src/prover/smt/solver/smt-setup.ts +68 -6
  168. package/src/prover/smt/solver/smtlib-parser.ts +558 -220
  169. package/src/prover/smt/solver/smtlib-script.ts +495 -153
  170. package/src/prover/smt/solver/solve-eqs.ts +13 -21
  171. package/src/prover/smt/solver/tactic.ts +219 -130
  172. package/src/prover/smt/solver/theory-bv.ts +2 -2
  173. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
  174. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
  175. package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
  176. package/src/prover/smt/solver/theory-lra.ts +0 -1
  177. package/src/prover/smt/solver/theory-pb.ts +24 -7
  178. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  179. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  180. package/src/prover/tlapm/cache.ts +8 -8
  181. package/src/prover/zenon/equality-rules.ts +24 -0
  182. package/src/prover/zenon/expr.ts +21 -0
  183. package/src/prover/zenon/index-table.ts +7 -2
  184. package/src/prover/zenon/isar-case.ts +1 -1
  185. package/src/prover/zenon/isar.ts +2 -2
  186. package/src/prover/zenon/phrase.ts +1 -1
  187. package/src/prover/zenon/rules.ts +2 -1
  188. package/src/resolve.ts +624 -187
  189. package/src/runtime.ts +3 -1
  190. package/src/sany/builtins.ts +10 -10
  191. package/src/sany/generation.ts +2 -13
  192. package/src/sany/generator-definitions.ts +3 -1
  193. package/src/sany/generator-expressions.ts +36 -30
  194. package/src/sany/generator-proofs.ts +5 -3
  195. package/src/sany/generator.ts +2 -1
  196. package/src/sany/lexer.ts +3 -3
  197. package/src/sany/modules.ts +4 -2
  198. package/src/sany/nodes.ts +1 -1
  199. package/src/sany/selectors.ts +11 -6
  200. package/src/sany/xml.ts +2 -3
  201. package/src/search.ts +51 -22
  202. package/src/spec-description.ts +2 -2
  203. package/src/subexpressions.ts +265 -94
  204. package/src/successors.ts +1 -0
  205. package/src/symmetry.ts +1 -1
  206. package/src/tlc/jar-data.ts +10 -0
  207. package/src/tlc/messages.ts +3 -3
  208. package/src/tlc/order.ts +14 -3
  209. package/src/tlc/tlc-operators.ts +3 -1
  210. package/src/tlc/tlcext-operators.ts +18 -5
  211. package/src/tlc/trace-spec.ts +5 -5
  212. package/src/typed-tier.ts +29 -23
  213. package/src/typescript/types.ts +2 -2
  214. package/src/values.ts +46 -27
@@ -223,8 +223,12 @@ export class Grobner {
223
223
  if (!poly.isOffset()) return false;
224
224
  const variable = poly.var();
225
225
  if (this.core.varIsFixed(variable)) return false;
226
- const coeff = poly.hi().val();
227
- const offset = poly.lo().val().neg();
226
+ const hi = poly.hi();
227
+ const coeff = hi.val();
228
+ hi.release();
229
+ const lo = poly.lo();
230
+ const offset = lo.val().neg();
231
+ lo.release();
228
232
  const lcm = getRationalLcm(getDenominator(coeff), getDenominator(offset));
229
233
  const ineq = mkIneq(new LarTerm([[variable, coeff.mul(lcm)]]), KIND_EQ, offset.mul(lcm));
230
234
  return this.addLemmaUnlessHolds(equation, ineq);
@@ -238,31 +242,49 @@ export class Grobner {
238
242
 
239
243
  private propagateFactorizationOf(equation: Equation) {
240
244
  const factors = equation.poly.varFactors();
241
- if (factors.vars.length === 0 || !factors.poly.isLinear()) return false;
245
+ if (factors.vars.length === 0 || !factors.poly.isLinear()) {
246
+ factors.poly.release();
247
+ return false;
248
+ }
242
249
  const linear = this.linearToTerm(factors.poly);
243
250
  const ineqs = factors.vars.map((variable) => mkIneq(variable, KIND_EQ, 0));
244
251
  ineqs.push(mkIneq(linear.term, KIND_EQ, linear.offset.neg()));
245
- if (ineqs.some((ineq) => this.core.ineqHolds(ineq))) return false;
252
+ if (ineqs.some((ineq) => this.core.ineqHolds(ineq))) {
253
+ factors.poly.release();
254
+ return false;
255
+ }
246
256
  const lemma = this.addDependencies(new LemmaBuilder(this.core), equation);
247
257
  for (const ineq of ineqs) lemma.addIneq(ineq);
258
+ factors.poly.release();
248
259
  return true;
249
260
  }
250
261
 
251
262
  private linearToTerm(poly: Pdd): LinearTerm {
263
+ const termPoly = poly.copy();
252
264
  let lcm = Rational.one;
253
- let current = poly;
254
- while (!current.isVal()) {
255
- lcm = getRationalLcm(lcm, getDenominator(current.hi().val()));
256
- current = current.lo();
257
- }
258
- lcm = getRationalLcm(getDenominator(current.val()), lcm);
265
+ const lcmPoly = termPoly.copy();
266
+ while (!lcmPoly.isVal()) {
267
+ const hi = lcmPoly.hi();
268
+ lcm = getRationalLcm(lcm, getDenominator(hi.val()));
269
+ hi.release();
270
+ const lo = lcmPoly.lo();
271
+ lcmPoly.assign(lo);
272
+ lo.release();
273
+ }
274
+ lcm = getRationalLcm(getDenominator(lcmPoly.val()), lcm);
259
275
  const term = new LarTerm();
260
- current = poly;
261
- while (!current.isVal()) {
262
- term.addMonomial(lcm.mul(current.hi().val()), current.var());
263
- current = current.lo();
276
+ while (!termPoly.isVal()) {
277
+ const hi = termPoly.hi();
278
+ term.addMonomial(lcm.mul(hi.val()), termPoly.var());
279
+ hi.release();
280
+ const lo = termPoly.lo();
281
+ termPoly.assign(lo);
282
+ lo.release();
264
283
  }
265
- return { term, offset: lcm.mul(current.val()) };
284
+ const offset = lcm.mul(termPoly.val());
285
+ lcmPoly.release();
286
+ termPoly.release();
287
+ return { term, offset };
266
288
  }
267
289
 
268
290
  private getValue(poly: Pdd) {
@@ -277,42 +299,61 @@ export class Grobner {
277
299
  }
278
300
 
279
301
  private propagateGcdTestOf(equation: Equation) {
280
- let poly = equation.poly;
281
- if (poly.isLinear() || poly.isVal() || !this.isIntPoly(poly)) return false;
282
- if (this.getValue(poly).isZero()) return false;
283
- const powers = poly.getPowers();
284
- if (powers.length === 0) return false;
285
- let lcm = Rational.one;
286
- for (const value of poly.coefficients()) lcm = getRationalLcm(lcm, getDenominator(value.coeff));
287
- if (!lcm.equals(Rational.one)) poly = poly.mul(lcm);
288
- const manager = this.manager;
289
- const failsGcdTest = (substituted: Pdd) => {
290
- let gcd = Rational.zero;
291
- let constant = Rational.zero;
292
- for (const value of substituted.coefficients()) {
293
- if (value.isConstant) {
294
- constant = constant.add(value.coeff);
295
- continue;
296
- }
297
- gcd = getRationalGcd(gcd, value.coeff);
298
- if (gcd.equals(Rational.one)) return false;
299
- }
300
- return !constant.isZero() && !divides(gcd, constant);
301
- };
302
- for (const entry of powers) {
303
- if (entry.degree > 4) continue;
304
- const scaled = manager.mkVar(entry.var).mul(manager.mkVal(Rational.fromNumber(entry.degree)));
305
- let isGcdFailing = true;
306
- for (let residue = 0; isGcdFailing && residue < entry.degree; residue++) {
307
- const replacement = scaled.add(manager.mkVal(Rational.fromNumber(residue)));
308
- if (!failsGcdTest(poly.substPdd(entry.var, replacement))) isGcdFailing = false;
302
+ const poly = equation.poly.copy();
303
+ try {
304
+ if (poly.isLinear() || poly.isVal() || !this.isIntPoly(poly)) return false;
305
+ if (this.getValue(poly).isZero()) return false;
306
+ const powers = poly.getPowers();
307
+ if (powers.length === 0) return false;
308
+ let lcm = Rational.one;
309
+ for (const value of poly.coefficients()) {
310
+ lcm = getRationalLcm(lcm, getDenominator(value.coeff));
309
311
  }
310
- if (isGcdFailing) {
311
- this.addDependencies(new LemmaBuilder(this.core), equation);
312
- return true;
312
+ if (!lcm.equals(Rational.one)) poly.mulAssign(lcm);
313
+ const manager = this.manager;
314
+ const failsGcdTest = (substituted: Pdd) => {
315
+ let gcd = Rational.zero;
316
+ let constant = Rational.zero;
317
+ for (const value of substituted.coefficients()) {
318
+ if (value.isConstant) {
319
+ constant = constant.add(value.coeff);
320
+ continue;
321
+ }
322
+ gcd = getRationalGcd(gcd, value.coeff);
323
+ if (gcd.equals(Rational.one)) return false;
324
+ }
325
+ return !constant.isZero() && !divides(gcd, constant);
326
+ };
327
+ for (const entry of powers) {
328
+ if (entry.degree > 4) continue;
329
+ const variable = manager.mkVar(entry.var);
330
+ const degree = manager.mkVal(Rational.fromNumber(entry.degree));
331
+ const scaled = variable.mul(degree);
332
+ degree.release();
333
+ variable.release();
334
+ try {
335
+ let isGcdFailing = true;
336
+ for (let residue = 0; isGcdFailing && residue < entry.degree; residue++) {
337
+ const residuePdd = manager.mkVal(Rational.fromNumber(residue));
338
+ const replacement = scaled.add(residuePdd);
339
+ residuePdd.release();
340
+ const substituted = poly.substPdd(entry.var, replacement);
341
+ if (!failsGcdTest(substituted)) isGcdFailing = false;
342
+ substituted.release();
343
+ replacement.release();
344
+ }
345
+ if (isGcdFailing) {
346
+ this.addDependencies(new LemmaBuilder(this.core), equation);
347
+ return true;
348
+ }
349
+ } finally {
350
+ scaled.release();
351
+ }
313
352
  }
353
+ return false;
354
+ } finally {
355
+ poly.release();
314
356
  }
315
- return false;
316
357
  }
317
358
 
318
359
  private propagateQuotientsOf(equation: Equation) {
@@ -329,11 +370,18 @@ export class Grobner {
329
370
  if (this.propagateModResidue(equation)) return true;
330
371
  let isLemmaFound = false;
331
372
  for (const variable of nlVars) {
332
- const factor = poly.factor(variable, 1);
333
- if (!factor.rest.isLinear()) continue;
334
- const lc = lcm.equals(Rational.one) ? factor.lc : factor.lc.mul(lcm);
335
- const rest = lcm.equals(Rational.one) ? factor.rest : factor.rest.mul(lcm);
336
- if (this.addQuotientLemma(equation, variable, lc, rest)) isLemmaFound = true;
373
+ const lc = this.manager.zero();
374
+ const rest = this.manager.zero();
375
+ poly.factor(variable, 1, lc, rest);
376
+ if (rest.isLinear()) {
377
+ if (!lcm.equals(Rational.one)) {
378
+ lc.mulAssign(lcm);
379
+ rest.mulAssign(lcm);
380
+ }
381
+ if (this.addQuotientLemma(equation, variable, lc, rest)) isLemmaFound = true;
382
+ }
383
+ rest.release();
384
+ lc.release();
337
385
  }
338
386
  return isLemmaFound;
339
387
  }
@@ -747,28 +795,38 @@ export class Grobner {
747
795
  }
748
796
 
749
797
  private getTermPdd(term: LarTerm, ref: DepRef) {
750
- let result = this.manager.mkVal(Rational.zero);
751
- for (const entry of term.coeffs) result = result.add(this.getPddExpr(entry[1], entry[0], ref));
798
+ const result = this.manager.mkVal(Rational.zero);
799
+ for (const entry of term.coeffs) {
800
+ const expr = this.getPddExpr(entry[1], entry[0], ref);
801
+ result.addAssign(expr);
802
+ expr.release();
803
+ }
752
804
  return result;
753
805
  }
754
806
 
755
807
  private getPddExpr(coeff: Rational, lpVar: number, ref: DepRef) {
756
808
  const core = this.core;
757
- let result = this.manager.mkVal(coeff);
809
+ const result = this.manager.mkVal(coeff);
758
810
  const vars = [lpVar];
759
811
  const zeroRef = { dep: ref.dep };
760
812
  for (let current = vars.pop(); current !== undefined; current = vars.pop()) {
761
813
  if (NLA_PARAMS.grobnerSubsFixed > 0 && core.varIsFixedToZero(current)) {
762
- result = this.manager.mkVal(this.getValOfFixedVarWithDeps(current, zeroRef));
814
+ const fixed = this.manager.mkVal(this.getValOfFixedVarWithDeps(current, zeroRef));
815
+ result.assign(fixed);
816
+ fixed.release();
763
817
  ref.dep = zeroRef.dep;
764
818
  return result;
765
819
  }
766
820
  if (NLA_PARAMS.grobnerSubsFixed === 1 && core.varIsFixed(current)) {
767
- result = result.mul(this.getValOfFixedVarWithDeps(current, ref));
821
+ result.mulAssign(this.getValOfFixedVarWithDeps(current, ref));
768
822
  } else if (this.expandsTerms && core.lra.hasTerm(current)) {
769
- result = result.mul(this.getTermPdd(core.lra.getTerm(current), ref));
823
+ const termPdd = this.getTermPdd(core.lra.getTerm(current), ref);
824
+ result.mulAssign(termPdd);
825
+ termPdd.release();
770
826
  } else if (!core.isMonicVar(current)) {
771
- result = result.mul(this.manager.mkVar(current));
827
+ const variable = this.manager.mkVar(current);
828
+ result.mulAssign(variable);
829
+ variable.release();
772
830
  } else {
773
831
  vars.push(...core.emons.get(current).vars);
774
832
  }
@@ -776,17 +834,20 @@ export class Grobner {
776
834
  return result;
777
835
  }
778
836
 
779
- private getSolvedForm(poly: Pdd) {
837
+ private getSolvedForm(poly: Pdd, solution: Pdd) {
780
838
  if (!poly.isLinear()) return null;
839
+ solution.assign(poly);
781
840
  let numLo = 0;
782
841
  let numHi = 0;
783
842
  let lo = 0;
784
843
  let hi = 0;
785
844
  let loCoeff = Rational.zero;
786
845
  let hiCoeff = Rational.zero;
787
- for (let current = poly; !current.isVal(); current = current.lo()) {
788
- const variable = current.var();
789
- const value = current.hi().val();
846
+ while (!solution.isVal()) {
847
+ const variable = solution.var();
848
+ const hiPoly = solution.hi();
849
+ const value = hiPoly.val();
850
+ hiPoly.release();
790
851
  const type = this.core.lra.core.getColumnType(variable);
791
852
  if (type === COLUMN_LOWER || type === COLUMN_UPPER) {
792
853
  if (value.isPositive() === (type === COLUMN_LOWER)) {
@@ -802,51 +863,68 @@ export class Grobner {
802
863
  return null;
803
864
  }
804
865
  if (numLo > 1 && numHi > 1) return null;
866
+ const loPoly = solution.lo();
867
+ solution.assign(loPoly);
868
+ loPoly.release();
805
869
  }
806
870
  const isLo = numLo === 1 && numHi > 1;
807
871
  if (!isLo && !(numHi === 1 && numLo > 1)) return null;
808
872
  const variable = isLo ? lo : hi;
809
873
  const coeff = isLo ? loCoeff : hiCoeff;
810
- const solution = this.manager.mkVar(variable).mul(coeff).sub(poly);
811
- return {
812
- variable,
813
- poly: coeff.equals(Rational.one) ? solution : solution.mul(Rational.one.div(coeff)),
814
- };
874
+ const variablePdd = this.manager.mkVar(variable);
875
+ const scaled = variablePdd.mul(coeff);
876
+ const difference = scaled.sub(poly);
877
+ solution.assign(difference);
878
+ difference.release();
879
+ scaled.release();
880
+ variablePdd.release();
881
+ if (!coeff.equals(Rational.one)) solution.mulAssign(Rational.one.div(coeff));
882
+ return variable;
815
883
  }
816
884
 
817
885
  private addEq(poly: Pdd, dep: Dependency) {
818
- const simplified = this.solver.simplify(poly, dep);
819
- const solved = this.getSolvedForm(simplified.poly);
820
- if (solved === null) this.solver.add(simplified.poly, simplified.dep);
821
- else this.solver.addSubst(solved.variable, solved.poly, simplified.dep);
886
+ const solution = this.manager.zero();
887
+ const simplifiedDep = this.solver.simplify(poly, dep);
888
+ const variable = this.getSolvedForm(poly, solution);
889
+ if (variable === null) this.solver.add(poly, simplifiedDep);
890
+ else this.solver.addSubst(variable, solution, simplifiedDep);
891
+ solution.release();
822
892
  }
823
893
 
824
894
  private addFixedMonic(lpVar: number) {
825
895
  const ref: DepRef = { dep: null };
826
- let product = this.manager.mkVal(Rational.one);
896
+ const product = this.manager.mkVal(Rational.one);
827
897
  for (const factor of this.core.emons.get(lpVar).vars) {
828
- product = product.mul(this.getPddExpr(Rational.one, factor, ref));
898
+ const expr = this.getPddExpr(Rational.one, factor, ref);
899
+ product.mulAssign(expr);
900
+ expr.release();
829
901
  }
830
- product = product.sub(this.getValOfFixedVarWithDeps(lpVar, ref));
902
+ product.subAssign(this.getValOfFixedVarWithDeps(lpVar, ref));
831
903
  this.addEq(product, ref.dep);
904
+ product.release();
832
905
  }
833
906
 
834
907
  private addRow(row: RowCell[]) {
835
908
  const ref: DepRef = { dep: null };
836
- let sum = this.manager.mkVal(Rational.zero);
837
- for (const cell of row) sum = sum.add(this.getPddExpr(cell.coeff, cell.column, ref));
909
+ const sum = this.manager.mkVal(Rational.zero);
910
+ for (const cell of row) {
911
+ const expr = this.getPddExpr(cell.coeff, cell.column, ref);
912
+ sum.addAssign(expr);
913
+ expr.release();
914
+ }
838
915
  this.addEq(sum, ref.dep);
916
+ sum.release();
839
917
  }
840
918
 
841
919
  private setLevel2var() {
842
920
  const core = this.core;
843
921
  const count = core.lra.getColumnCount();
844
- const weights = Array.from({ length: count }, (_, lpVar) => core.getVarWeight(lpVar));
922
+ const weights = Array.from({ length: count }, (_value, lpVar) => core.getVarWeight(lpVar));
845
923
  for (let lpVar = 0; lpVar < count; lpVar++) {
846
924
  if (!core.isMonicVar(lpVar) || !core.toRefine.has(lpVar)) continue;
847
925
  for (const factor of core.emons.get(lpVar).vars) weights[factor] += 6;
848
926
  }
849
- const level2var = Array.from({ length: count }, (_, lpVar) => lpVar).sort(
927
+ const level2var = Array.from({ length: count }, (_value, lpVar) => lpVar).sort(
850
928
  (first, second) => weights[first] - weights[second] || first - second,
851
929
  );
852
930
  this.manager.reset(level2var);
@@ -1,9 +1,9 @@
1
- import { NlsatUnsupportedError, SmtCanceledError, SmtInvariantError } from "../../../../errors";
1
+ import { SmtCanceledError, SmtInvariantError } from "../../../../errors";
2
2
  import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
3
3
  import { Rational, getLcm } from "../rational";
4
4
  import { Anum } from "../nlsat/algebraic";
5
5
  import { NlsatSolver } from "../nlsat/solver";
6
- import type { Polynomial } from "../nlsat/polynomial";
6
+ import { type Polynomial, PolynomialRef, PolynomialRefVector } from "../nlsat/polynomial";
7
7
  import { isIneqAtom } from "../nlsat/types";
8
8
  import {
9
9
  KIND_EQ,
@@ -92,13 +92,15 @@ const isDyadicArtifact = (lra: LarSolver, constraint: LarConstraint) =>
92
92
  getConstraintCoeffs(lra, constraint).some((entry) => hasLargeDyadicDenominator(entry[1])));
93
93
 
94
94
  export class NraSolver {
95
- private solver = new NlsatSolver();
95
+ private solver: NlsatSolver;
96
96
  private values: Anum[] = [];
97
97
  private lp2nl = new Map<number, number>();
98
98
  private literal2constraint = new Map<number, number>();
99
99
  private vars2mon = new Map<string, number>();
100
100
 
101
- constructor(private core: NlaCore) {}
101
+ constructor(private core: NlaCore) {
102
+ this.solver = new NlsatSolver(core.nraLimit);
103
+ }
102
104
 
103
105
  get am() {
104
106
  return this.solver.am;
@@ -115,53 +117,48 @@ export class NraSolver {
115
117
  const lra = core.lra;
116
118
  const solver = this.solver;
117
119
  const pm = solver.pm;
118
- const definitions: (Polynomial | null)[] = [];
120
+ const definitions = new PolynomialRefVector(pm);
119
121
  const denominators: bigint[] = [];
122
+ const p = new PolynomialRef(pm);
123
+ const constant = new PolynomialRef(pm);
124
+ const product = new PolynomialRef(pm);
120
125
  for (let lpVar = 0; lpVar < lra.columns.length; lpVar++) {
121
126
  if (!isIncluded(lpVar)) {
122
- definitions.push(null);
127
+ definitions.push(pm.zero);
123
128
  denominators.push(0n);
124
129
  continue;
125
130
  }
126
131
  const variable = solver.mkVar(lra.isInt(lpVar));
127
132
  this.lp2nl.set(lpVar, variable);
133
+ let denominator = 1n;
128
134
  if (core.emons.isMonicVar(lpVar)) {
129
- let definition: Polynomial | null = null;
130
- let denominator = 1n;
131
- for (const factor of core.emons.get(lpVar).vars) {
135
+ for (const [index, factor] of core.emons.get(lpVar).vars.entries()) {
132
136
  denominator = denominators[factor] * denominator;
133
- definition =
134
- definition === null ? definitions[factor] : pm.mul(definition, definitions[factor]!);
137
+ p.set(index === 0 ? definitions.get(factor) : pm.mul(p.get(), definitions.get(factor)));
135
138
  }
136
- definitions.push(definition ?? pm.mkVar(variable));
137
- denominators.push(denominator);
138
- continue;
139
- }
140
- if (lra.hasTerm(lpVar)) {
139
+ } else if (lra.hasTerm(lpVar)) {
141
140
  const term = [...lra.getTerm(lpVar).coeffs];
142
- const denominator = term.reduce(
143
- (result, entry) => getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, result),
144
- 1n,
145
- );
146
- let definition: Polynomial | null = null;
147
- for (const entry of term) {
141
+ for (const entry of term)
142
+ denominator = getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, denominator);
143
+ for (const [index, entry] of term.entries()) {
148
144
  const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
149
- const scaled = pm.mul(pm.mkConst(coeff.num), definitions[entry[0]]!);
150
- definition = definition === null ? scaled : pm.add(definition, scaled);
145
+ constant.set(pm.mkConst(coeff.num));
146
+ product.set(pm.mul(constant.get(), definitions.get(entry[0])));
147
+ p.set(index === 0 ? product.get() : pm.add(p.get(), product.get()));
148
+ product.reset();
149
+ constant.reset();
151
150
  }
152
- definitions.push(definition ?? pm.zero);
153
- denominators.push(denominator);
154
- continue;
155
- }
156
- definitions.push(pm.mkVar(variable));
157
- denominators.push(1n);
151
+ } else p.set(pm.mkVar(variable));
152
+ definitions.push(p.getOrNull() ?? pm.zero);
153
+ denominators.push(denominator);
154
+ p.reset();
158
155
  }
159
156
  return { definitions, denominators };
160
157
  }
161
158
 
162
159
  private addConstraint(
163
160
  constraintIndex: number,
164
- definitions: readonly (Polynomial | null)[],
161
+ definitions: PolynomialRefVector,
165
162
  denominators: readonly bigint[],
166
163
  ) {
167
164
  const lra = this.core.lra;
@@ -174,23 +171,32 @@ export class NraSolver {
174
171
  (result, entry) => getLcm(result, entry[1].div(Rational.of(denominators[entry[0]])).den),
175
172
  rhs.den,
176
173
  );
177
- let polynomial = pm.mkConst(-(rhs.num * denominator) / rhs.den);
174
+ const p = new PolynomialRef(pm);
175
+ const poly = new PolynomialRef(pm);
176
+ const constant = new PolynomialRef(pm);
177
+ p.set(pm.mkConst(-(rhs.num * denominator) / rhs.den));
178
178
  for (const entry of coeffs) {
179
179
  const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
180
- polynomial = pm.add(polynomial, pm.mul(definitions[entry[0]]!, pm.mkConst(coeff.num)));
180
+ poly.set(definitions.get(entry[0]));
181
+ constant.set(pm.mkConst(coeff.num));
182
+ poly.set(pm.mul(poly.get(), constant.get()));
183
+ constant.reset();
184
+ p.set(pm.add(p.get(), poly.get()));
185
+ poly.reset();
181
186
  }
182
187
  const kind = constraint.kind;
183
188
  const literal =
184
189
  kind === KIND_LE
185
- ? solver.mkIneqLiteral("GT", [polynomial], [false]) ^ 1
190
+ ? solver.mkIneqLiteral("GT", [p.get()], [false]) ^ 1
186
191
  : kind === KIND_GE
187
- ? solver.mkIneqLiteral("LT", [polynomial], [false]) ^ 1
192
+ ? solver.mkIneqLiteral("LT", [p.get()], [false]) ^ 1
188
193
  : solver.mkIneqLiteral(
189
194
  kind === KIND_LT ? "LT" : kind === KIND_GT ? "GT" : "EQ",
190
- [polynomial],
195
+ [p.get()],
191
196
  [false],
192
197
  );
193
198
  solver.mkExternalClause([literal], constraintIndex);
199
+ p.reset();
194
200
  return literal;
195
201
  }
196
202
 
@@ -234,6 +240,7 @@ export class NraSolver {
234
240
  }
235
241
  this.addConstraint(constraintIndex, definitions.definitions, definitions.denominators);
236
242
  }
243
+ definitions.definitions.reset();
237
244
  this.registerTranscendentals();
238
245
  const result = this.solver.check();
239
246
  if (result === L_TRUE) {
@@ -344,6 +351,7 @@ export class NraSolver {
344
351
  );
345
352
  this.literal2constraint.set(literal, constraintIndex);
346
353
  }
354
+ definitions.definitions.reset();
347
355
  this.registerTranscendentals();
348
356
  }
349
357
 
@@ -356,7 +364,7 @@ export class NraSolver {
356
364
  for (let index = 0; index < polynomial.size; index++) {
357
365
  const monomial = polynomial.ms[index];
358
366
  const coeff = Rational.of(polynomial.as[index]);
359
- // A linear cell leaves every new lemma polynomial linear, so like Z3 this ignores degrees.
367
+ // Like Z3, this drops degrees: only an axiom's ¬best can be nonlinear, and ¬cell is valid alone.
360
368
  if (monomial.size === 0) bound = bound.sub(coeff);
361
369
  else if (monomial.size === 1) term.addMonomial(coeff, nl2lp[monomial.vars[0]]);
362
370
  else {
@@ -377,8 +385,6 @@ export class NraSolver {
377
385
  try {
378
386
  return this.checkAssignmentCore();
379
387
  } catch (error) {
380
- // Deviation from Z3: a linear cell around an irrational section answers unknown, where Z3 exits.
381
- if (error instanceof NlsatUnsupportedError) return L_UNDEF;
382
388
  if (error instanceof SmtCanceledError && this.core.nraLimit.isExhausted()) return L_UNDEF;
383
389
  throw error;
384
390
  }
@@ -19,8 +19,12 @@ export const getPddInterval = (
19
19
  return result;
20
20
  }
21
21
  const varInterval = getVarInterval(poly.var(), mode);
22
- const hi = getPddInterval(poly.hi(), mode, getVarInterval);
23
- const lo = getPddInterval(poly.lo(), mode, getVarInterval);
22
+ const hiPoly = poly.hi();
23
+ const hi = getPddInterval(hiPoly, mode, getVarInterval);
24
+ hiPoly.release();
25
+ const loPoly = poly.lo();
26
+ const lo = getPddInterval(loPoly, mode, getVarInterval);
27
+ loPoly.release();
24
28
  const product = mkDepInterval();
25
29
  mul(hi, varInterval, product, mode);
26
30
  add(product, lo, result, mode);