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.
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +56 -56
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +49 -44
- package/dist/transfer.js +48 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +14 -2
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +116 -64
- package/src/check.ts +516 -280
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +18 -4
- package/src/cli/tlc.ts +18 -12
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +190 -1
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +123 -38
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +370 -99
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +179 -60
- package/src/liveness.ts +51 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +84 -15
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -11
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +608 -139
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +2 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +713 -210
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +350 -195
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1274 -257
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +18 -12
- package/src/sany/generator.ts +12 -6
- package/src/sany/lexer.ts +15 -7
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +319 -135
- package/src/simulate.ts +235 -182
- package/src/spec-description.ts +8 -6
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +37 -13
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +67 -43
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- package/src/tlc/trace-spec.ts +9 -22
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
|
@@ -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
|
|
227
|
-
const
|
|
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())
|
|
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)))
|
|
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
|
-
|
|
254
|
-
while (!
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
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
|
-
|
|
261
|
-
|
|
262
|
-
term.addMonomial(lcm.mul(
|
|
263
|
-
|
|
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
|
-
|
|
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
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
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 (
|
|
311
|
-
|
|
312
|
-
|
|
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
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
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
|
-
|
|
751
|
-
for (const entry of term.coeffs)
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
821
|
+
result.mulAssign(this.getValOfFixedVarWithDeps(current, ref));
|
|
768
822
|
} else if (this.expandsTerms && core.lra.hasTerm(current)) {
|
|
769
|
-
|
|
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
|
-
|
|
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
|
-
|
|
788
|
-
const variable =
|
|
789
|
-
const
|
|
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
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
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
|
|
819
|
-
const
|
|
820
|
-
|
|
821
|
-
|
|
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
|
-
|
|
896
|
+
const product = this.manager.mkVal(Rational.one);
|
|
827
897
|
for (const factor of this.core.emons.get(lpVar).vars) {
|
|
828
|
-
|
|
898
|
+
const expr = this.getPddExpr(Rational.one, factor, ref);
|
|
899
|
+
product.mulAssign(expr);
|
|
900
|
+
expr.release();
|
|
829
901
|
}
|
|
830
|
-
product
|
|
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
|
-
|
|
837
|
-
for (const cell of row)
|
|
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 }, (
|
|
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 }, (
|
|
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 {
|
|
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
|
|
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
|
|
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
|
|
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(
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
143
|
-
|
|
144
|
-
|
|
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
|
-
|
|
150
|
-
|
|
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
|
-
|
|
153
|
-
|
|
154
|
-
|
|
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:
|
|
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
|
-
|
|
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
|
-
|
|
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", [
|
|
190
|
+
? solver.mkIneqLiteral("GT", [p.get()], [false]) ^ 1
|
|
186
191
|
: kind === KIND_GE
|
|
187
|
-
? solver.mkIneqLiteral("LT", [
|
|
192
|
+
? solver.mkIneqLiteral("LT", [p.get()], [false]) ^ 1
|
|
188
193
|
: solver.mkIneqLiteral(
|
|
189
194
|
kind === KIND_LT ? "LT" : kind === KIND_GT ? "GT" : "EQ",
|
|
190
|
-
[
|
|
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
|
-
//
|
|
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
|
|
23
|
-
const
|
|
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);
|