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.
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +2 -1
- package/dist/index.d.ts +2 -1
- 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 +43 -43
- package/dist/prove.js +78 -78
- package/dist/run.cjs +33 -35
- package/dist/run.js +44 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -43
- package/dist/transfer.js +38 -38
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +1 -0
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +152 -64
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +13 -8
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +9 -5
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +9 -2
- package/src/environment.ts +57 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +43 -4
- package/src/liveness.ts +1 -1
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +106 -144
- 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/asserted-formulas.ts +66 -1
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +58 -11
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +2 -3
- 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 +3 -5
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
- package/src/prover/smt/solver/context.ts +24 -3
- 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 +9 -4
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
- 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 -10
- 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 +2 -0
- 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/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/containers.ts +7 -1
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- 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/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-generator.ts +3 -1
- 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 +10 -4
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.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 +1 -1
- 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/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 +9 -3
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +6 -3
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +74 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +4 -6
- 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/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -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 +4 -7
- 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-kernel.ts +9 -3
- package/src/prover/smt/solver/smt-setup.ts +68 -6
- package/src/prover/smt/solver/smtlib-parser.ts +558 -220
- package/src/prover/smt/solver/smtlib-script.ts +495 -153
- package/src/prover/smt/solver/solve-eqs.ts +13 -21
- package/src/prover/smt/solver/tactic.ts +219 -130
- package/src/prover/smt/solver/theory-bv.ts +2 -2
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
- package/src/prover/smt/solver/theory-lra.ts +0 -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/tlapm/cache.ts +8 -8
- package/src/prover/zenon/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -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/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +624 -187
- package/src/runtime.ts +3 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- 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 +51 -22
- package/src/spec-description.ts +2 -2
- package/src/subexpressions.ts +265 -94
- package/src/successors.ts +1 -0
- package/src/symmetry.ts +1 -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/tlc-operators.ts +3 -1
- package/src/tlc/tlcext-operators.ts +18 -5
- package/src/tlc/trace-spec.ts +5 -5
- package/src/typed-tier.ts +29 -23
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +46 -27
|
@@ -1,7 +1,8 @@
|
|
|
1
|
-
import { SmtInvariantError } from "../../../../errors";
|
|
1
|
+
import { SmtCanceledError, SmtDefaultError, SmtInvariantError } from "../../../../errors";
|
|
2
2
|
import { Rational } from "../rational";
|
|
3
|
+
import type { ResourceLimit } from "../rlimit";
|
|
3
4
|
import { getLog2, Mpbq } from "./mpbq";
|
|
4
|
-
import { PolynomialManager, type Polynomial, type ValueOps } from "./polynomial";
|
|
5
|
+
import { PolynomialManager, type Polynomial, PolynomialRef, type ValueOps } from "./polynomial";
|
|
5
6
|
import { UpolynomialManager, type Upolynomial } from "./upolynomial";
|
|
6
7
|
import { factorUpolynomial, type FactorParams } from "./upolynomial-factorization";
|
|
7
8
|
|
|
@@ -224,8 +225,8 @@ export const mergeSortIndices = (
|
|
|
224
225
|
};
|
|
225
226
|
|
|
226
227
|
export class AlgebraicManager {
|
|
227
|
-
private um
|
|
228
|
-
private pm
|
|
228
|
+
private um: UpolynomialManager;
|
|
229
|
+
private pm: PolynomialManager;
|
|
229
230
|
private anumOps: ValueOps<Anum> = {
|
|
230
231
|
fromInteger: (value) => new Anum(Rational.of(value)),
|
|
231
232
|
add: (first, second) => this.add(first, second),
|
|
@@ -233,6 +234,11 @@ export class AlgebraicManager {
|
|
|
233
234
|
power: (base, exponent) => this.power(base, exponent),
|
|
234
235
|
};
|
|
235
236
|
|
|
237
|
+
constructor(private limit: ResourceLimit) {
|
|
238
|
+
this.um = new UpolynomialManager(limit);
|
|
239
|
+
this.pm = new PolynomialManager(limit);
|
|
240
|
+
}
|
|
241
|
+
|
|
236
242
|
isZero(anum: Anum) {
|
|
237
243
|
return anum.value instanceof Rational && anum.value.isZero();
|
|
238
244
|
}
|
|
@@ -421,7 +427,7 @@ export class AlgebraicManager {
|
|
|
421
427
|
}
|
|
422
428
|
|
|
423
429
|
private sortRoots(roots: Anum[]) {
|
|
424
|
-
if (roots.length < 2) return;
|
|
430
|
+
if (!this.limit.inc() || roots.length < 2) return;
|
|
425
431
|
const sorted = mergeSortIndices(
|
|
426
432
|
roots.length,
|
|
427
433
|
(first, second) => this.compare(roots[first], roots[second]) < 0,
|
|
@@ -458,6 +464,7 @@ export class AlgebraicManager {
|
|
|
458
464
|
let highVariations = isNonPositive ? atZero : this.um.signVariationsAtPlusInf(sequence);
|
|
459
465
|
let target = isNonPositive ? rootIndex : rootIndex - nonPositiveCount;
|
|
460
466
|
while (lowVariations > highVariations + 1) {
|
|
467
|
+
this.limit.checkpoint();
|
|
461
468
|
const middle = low.add(high).div2();
|
|
462
469
|
const middleVariations = this.um.signVariationsAt(sequence, middle);
|
|
463
470
|
const leftCount = lowVariations - middleVariations;
|
|
@@ -528,29 +535,43 @@ export class AlgebraicManager {
|
|
|
528
535
|
): Anum[] {
|
|
529
536
|
if (pm.isConst(polynomial)) return [];
|
|
530
537
|
if (pm.isUnivariate(polynomial)) return this.isolateUnivariateRoots(pm.toCoeffs(polynomial));
|
|
531
|
-
const
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
538
|
+
const pPrime = new PolynomialRef(pm);
|
|
539
|
+
const q = new PolynomialRef(pm);
|
|
540
|
+
const pY = new PolynomialRef(pm);
|
|
541
|
+
try {
|
|
542
|
+
pPrime.set(pm.substituteRational(polynomial, getRationalValues(values)));
|
|
543
|
+
const reduced = pPrime.get();
|
|
544
|
+
if (pm.isConst(reduced)) return [];
|
|
545
|
+
if (pm.isUnivariate(reduced)) {
|
|
546
|
+
if (values[pm.maxVar(reduced)] !== undefined) return [];
|
|
547
|
+
return this.isolateUnivariateRoots(pm.toCoeffs(reduced));
|
|
548
|
+
}
|
|
549
|
+
const xs = this.sortByDegree(pm.getVars(reduced), values);
|
|
550
|
+
const x = xs[xs.length - 1];
|
|
551
|
+
if (values[x] !== undefined) return [];
|
|
552
|
+
q.copy(pPrime);
|
|
553
|
+
for (let index = 0; index + 1 < xs.length; index++) {
|
|
554
|
+
this.limit.checkpoint();
|
|
555
|
+
const y = xs[index];
|
|
556
|
+
pY.set(pm.toPolynomial(getCell(values[y]).p, y));
|
|
557
|
+
pm.resultant(q.get(), pY.get(), y, q);
|
|
558
|
+
if (pm.isZero(q.get())) {
|
|
559
|
+
if (isNested)
|
|
560
|
+
throw new SmtInvariantError("resultant vanished during nested isolate_roots call");
|
|
561
|
+
break;
|
|
562
|
+
}
|
|
563
|
+
}
|
|
564
|
+
if (pm.isZero(q.get())) return this.isolateVanishedRoots(pm, reduced, values, xs, x);
|
|
565
|
+
if (pm.isConst(q.get())) return [];
|
|
566
|
+
return this.isolateUnivariateRoots(pm.toCoeffs(q.get())).filter((root) => {
|
|
567
|
+
this.limit.checkpoint();
|
|
568
|
+
return this.evalSignAt(pm, reduced, getExtended(values, x, root)) === 0;
|
|
569
|
+
});
|
|
570
|
+
} finally {
|
|
571
|
+
pY.reset();
|
|
572
|
+
q.reset();
|
|
573
|
+
pPrime.reset();
|
|
550
574
|
}
|
|
551
|
-
if (isNested)
|
|
552
|
-
throw new SmtInvariantError("resultant vanished during nested isolate_roots call");
|
|
553
|
-
return this.isolateVanishedRoots(pm, reduced, values, xs, x);
|
|
554
575
|
}
|
|
555
576
|
|
|
556
577
|
private isolateVanishedRoots(
|
|
@@ -564,26 +585,50 @@ export class AlgebraicManager {
|
|
|
564
585
|
pm.evaluateWith(polynomial, this.anumOps, (variable) => getAssigned(values, variable));
|
|
565
586
|
const degree = pm.degree(reduced, x);
|
|
566
587
|
if (degree === 1) {
|
|
567
|
-
const
|
|
568
|
-
const
|
|
588
|
+
const c0 = new PolynomialRef(pm);
|
|
589
|
+
const c1 = new PolynomialRef(pm);
|
|
590
|
+
c0.set(pm.coeff(reduced, x, 0));
|
|
591
|
+
c1.set(pm.coeff(reduced, x, 1));
|
|
592
|
+
const constant = evaluate(c0.get());
|
|
593
|
+
const leading = evaluate(c1.get());
|
|
594
|
+
c1.reset();
|
|
595
|
+
c0.reset();
|
|
569
596
|
if (this.isZero(leading)) return [];
|
|
570
597
|
const root = this.div(constant, leading);
|
|
571
598
|
this.neg(root);
|
|
572
599
|
return [root];
|
|
573
600
|
}
|
|
601
|
+
const c = new PolynomialRef(pm);
|
|
574
602
|
let power = degree;
|
|
575
603
|
let leading = new Anum(Rational.zero);
|
|
576
604
|
for (; power >= 1; power--) {
|
|
577
|
-
|
|
605
|
+
c.set(pm.coeff(reduced, x, power));
|
|
606
|
+
leading = evaluate(c.get());
|
|
578
607
|
if (!this.isZero(leading)) break;
|
|
579
608
|
}
|
|
580
|
-
if (power === 0)
|
|
609
|
+
if (power === 0) {
|
|
610
|
+
c.reset();
|
|
611
|
+
return [];
|
|
612
|
+
}
|
|
581
613
|
const z = Math.max(...xs) + 1;
|
|
582
|
-
const
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
);
|
|
586
|
-
|
|
614
|
+
const q2 = new PolynomialRef(this.pm);
|
|
615
|
+
const zP = new PolynomialRef(this.pm);
|
|
616
|
+
const xiP = new PolynomialRef(this.pm);
|
|
617
|
+
const product = new PolynomialRef(this.pm);
|
|
618
|
+
q2.set(this.convert(pm, reduced, x, power - 1));
|
|
619
|
+
xiP.set(this.pm.mkVar(x, power));
|
|
620
|
+
zP.set(this.pm.mkVar(z));
|
|
621
|
+
product.set(this.pm.mul(zP.get(), xiP.get()));
|
|
622
|
+
q2.set(this.pm.add(product.get(), q2.get()));
|
|
623
|
+
product.reset();
|
|
624
|
+
try {
|
|
625
|
+
return this.isolateRoots(this.pm, q2.get(), getExtended(values, z, leading), true);
|
|
626
|
+
} finally {
|
|
627
|
+
xiP.reset();
|
|
628
|
+
zP.reset();
|
|
629
|
+
q2.reset();
|
|
630
|
+
c.reset();
|
|
631
|
+
}
|
|
587
632
|
}
|
|
588
633
|
|
|
589
634
|
private convert(pm: PolynomialManager, polynomial: Polynomial, x = -1, maxDegree = Infinity) {
|
|
@@ -617,13 +662,20 @@ export class AlgebraicManager {
|
|
|
617
662
|
if (pm.isConst(polynomial)) return result;
|
|
618
663
|
if (pm.isUnivariate(polynomial))
|
|
619
664
|
return this.isolateRootsClosestUnivariate(pm, polynomial, sample);
|
|
620
|
-
const
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
665
|
+
const pPrime = new PolynomialRef(pm);
|
|
666
|
+
let all: Anum[];
|
|
667
|
+
try {
|
|
668
|
+
pPrime.set(pm.substituteRational(polynomial, getRationalValues(values)));
|
|
669
|
+
const reduced = pPrime.get();
|
|
670
|
+
if (pm.isConst(reduced)) return result;
|
|
671
|
+
if (pm.isUnivariate(reduced)) {
|
|
672
|
+
if (values[pm.maxVar(reduced)] !== undefined) return result;
|
|
673
|
+
return this.isolateRootsClosestUnivariate(pm, reduced, sample);
|
|
674
|
+
}
|
|
675
|
+
all = this.isolateRoots(pm, polynomial, values);
|
|
676
|
+
} finally {
|
|
677
|
+
pPrime.reset();
|
|
625
678
|
}
|
|
626
|
-
const all = this.isolateRoots(pm, polynomial, values);
|
|
627
679
|
const sampleAnum = new Anum(sample);
|
|
628
680
|
let lower = -1;
|
|
629
681
|
let upper = -1;
|
|
@@ -671,37 +723,47 @@ export class AlgebraicManager {
|
|
|
671
723
|
evalSignAt(pm: PolynomialManager, polynomial: Polynomial, values: readonly (Anum | undefined)[]) {
|
|
672
724
|
while (true) {
|
|
673
725
|
const rationalValues = getRationalValues(values);
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
const
|
|
677
|
-
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
let
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
if (!
|
|
694
|
-
|
|
695
|
-
|
|
726
|
+
const rationalSign = pm.getRationalSign(polynomial, rationalValues);
|
|
727
|
+
if (rationalSign !== null) return rationalSign;
|
|
728
|
+
const pPrime = new PolynomialRef(pm);
|
|
729
|
+
try {
|
|
730
|
+
pPrime.set(pm.substituteRational(polynomial, rationalValues));
|
|
731
|
+
const reduced = pPrime.get();
|
|
732
|
+
if (reduced.size === 0) return 0;
|
|
733
|
+
if (pm.isConst(reduced)) return reduced.as[0] > 0n ? 1 : -1;
|
|
734
|
+
const xs = pm.getVars(reduced);
|
|
735
|
+
const getInterval = (variable: number) => {
|
|
736
|
+
const cell = getCell(values[variable]);
|
|
737
|
+
return { lower: cell.lower, upper: cell.upper };
|
|
738
|
+
};
|
|
739
|
+
const evaluate = () => pm.evaluateWith(reduced, INTERVAL_OPS, getInterval);
|
|
740
|
+
let interval: BqInterval;
|
|
741
|
+
let isRestarted = false;
|
|
742
|
+
while (true) {
|
|
743
|
+
this.limit.checkpoint();
|
|
744
|
+
interval = evaluate();
|
|
745
|
+
if (!containsZero(interval)) return interval.lower.isNeg ? -1 : 1;
|
|
746
|
+
let isRefined = false;
|
|
747
|
+
for (const variable of xs) {
|
|
748
|
+
const value = getAssigned(values, variable);
|
|
749
|
+
if (this.getCellMagnitude(getCell(value)) <= MIN_MAGNITUDE) continue;
|
|
750
|
+
if (!this.refine(value)) {
|
|
751
|
+
isRestarted = true;
|
|
752
|
+
break;
|
|
753
|
+
}
|
|
754
|
+
isRefined = true;
|
|
696
755
|
}
|
|
697
|
-
isRefined
|
|
756
|
+
if (!isRefined || isRestarted) break;
|
|
757
|
+
}
|
|
758
|
+
if (isRestarted) {
|
|
759
|
+
this.limit.checkpoint();
|
|
760
|
+
continue;
|
|
698
761
|
}
|
|
699
|
-
|
|
700
|
-
|
|
762
|
+
const sign = this.evalSignByResultant(pm, reduced, values, xs, interval, evaluate);
|
|
763
|
+
if (sign !== null) return sign;
|
|
764
|
+
} finally {
|
|
765
|
+
pPrime.reset();
|
|
701
766
|
}
|
|
702
|
-
if (isRestarted) continue;
|
|
703
|
-
const sign = this.evalSignByResultant(pm, reduced, values, xs, interval, evaluate);
|
|
704
|
-
if (sign !== null) return sign;
|
|
705
767
|
}
|
|
706
768
|
}
|
|
707
769
|
|
|
@@ -714,14 +776,23 @@ export class AlgebraicManager {
|
|
|
714
776
|
evaluate: () => BqInterval,
|
|
715
777
|
) {
|
|
716
778
|
const sorted = this.sortByDegree(xs, values);
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
const
|
|
779
|
+
const yp = new PolynomialRef(this.pm);
|
|
780
|
+
const pPrimeAux = new PolynomialRef(this.pm);
|
|
781
|
+
const r = new PolynomialRef(this.pm);
|
|
782
|
+
const qi = new PolynomialRef(this.pm);
|
|
783
|
+
yp.set(this.pm.mkVar(Math.max(...xs) + 1));
|
|
784
|
+
pPrimeAux.set(this.convert(pm, reduced));
|
|
785
|
+
r.set(this.pm.sub(yp.get(), pPrimeAux.get()));
|
|
786
|
+
for (const variable of sorted) {
|
|
787
|
+
this.limit.checkpoint();
|
|
788
|
+
qi.set(this.pm.toPolynomial(getCell(values[variable]).p, variable));
|
|
789
|
+
this.pm.resultant(r.get(), qi.get(), variable, r);
|
|
790
|
+
}
|
|
791
|
+
const k = this.um.nonzeroRootLowerBound(this.pm.toCoeffs(r.get()));
|
|
792
|
+
qi.reset();
|
|
793
|
+
r.reset();
|
|
794
|
+
pPrimeAux.reset();
|
|
795
|
+
yp.reset();
|
|
725
796
|
const bound = Mpbq.of(1n, k);
|
|
726
797
|
const isInsideBound = (interval: BqInterval) =>
|
|
727
798
|
bound.neg().compare(interval.lower) < 0 && interval.upper.compare(bound) < 0;
|
|
@@ -729,6 +800,7 @@ export class AlgebraicManager {
|
|
|
729
800
|
const saved = sorted.map((variable) => this.saveInterval(getAssigned(values, variable)));
|
|
730
801
|
let sign: number | null = null;
|
|
731
802
|
while (sign === null) {
|
|
803
|
+
this.limit.checkpoint();
|
|
732
804
|
const interval = evaluate();
|
|
733
805
|
if (!containsZero(interval)) sign = interval.lower.isNeg ? -1 : 1;
|
|
734
806
|
else if (isInsideBound(interval)) sign = 0;
|
|
@@ -858,7 +930,7 @@ export class AlgebraicManager {
|
|
|
858
930
|
|
|
859
931
|
power(anum: Anum, exponent: number): Anum {
|
|
860
932
|
if (exponent === 0) {
|
|
861
|
-
if (this.isZero(anum)) throw new
|
|
933
|
+
if (this.isZero(anum)) throw new SmtDefaultError("0^0 is indeterminate");
|
|
862
934
|
return new Anum(Rational.one);
|
|
863
935
|
}
|
|
864
936
|
if (exponent === 1) return this.copy(anum);
|
|
@@ -867,10 +939,10 @@ export class AlgebraicManager {
|
|
|
867
939
|
}
|
|
868
940
|
|
|
869
941
|
root(anum: Anum, k: number): Anum {
|
|
870
|
-
if (k === 0) throw new
|
|
942
|
+
if (k === 0) throw new SmtDefaultError("0-th root is indeterminate");
|
|
871
943
|
if (k === 1 || this.isZero(anum)) return this.copy(anum);
|
|
872
944
|
if (this.isNeg(anum) && k % 2 === 0)
|
|
873
|
-
throw new
|
|
945
|
+
throw new SmtDefaultError("even root of negative number is not real");
|
|
874
946
|
if (anum.value instanceof Rational) return this.rootRational(anum.value, k);
|
|
875
947
|
return this.mkRoot(anum, k);
|
|
876
948
|
}
|
|
@@ -889,14 +961,12 @@ export class AlgebraicManager {
|
|
|
889
961
|
// Res_y(x^k - y, p(y)) has a^(1/k) as a root.
|
|
890
962
|
private mkRoot(anum: Anum, k: number): Anum {
|
|
891
963
|
const cell = getCell(anum);
|
|
892
|
-
const
|
|
893
|
-
const factored = this.factor(
|
|
894
|
-
this.pm.toCoeffs(this.pm.resultant(x, this.pm.fromCoeffs(cell.p, Y), Y)),
|
|
895
|
-
);
|
|
964
|
+
const factored = this.factor(this.getResultantCoeffs(this.getVarDifference(k, 1), cell.p));
|
|
896
965
|
const factors = factored.factors.factors;
|
|
897
966
|
const sequences: (Upolynomial[] | null)[] = factors.map((factor) => this.um.sturmSeq(factor));
|
|
898
967
|
const saved = this.saveInterval(anum);
|
|
899
968
|
while (true) {
|
|
969
|
+
this.limit.checkpoint();
|
|
900
970
|
const interval = { lower: cell.lower.rootLower(k), upper: cell.upper.rootUpper(k) };
|
|
901
971
|
const found = this.findIsolatingFactor(factors, sequences, interval);
|
|
902
972
|
if (found !== null) {
|
|
@@ -940,14 +1010,46 @@ export class AlgebraicManager {
|
|
|
940
1010
|
return (refined.isInterval ? refined.upper : refined.lower).toDecimal(precision);
|
|
941
1011
|
}
|
|
942
1012
|
|
|
1013
|
+
private getResultantCoeffs(first: PolynomialRef, p: Upolynomial) {
|
|
1014
|
+
const q = new PolynomialRef(this.pm);
|
|
1015
|
+
const r = new PolynomialRef(this.pm);
|
|
1016
|
+
q.set(this.pm.toPolynomial(p, Y));
|
|
1017
|
+
this.pm.resultant(first.get(), q.get(), Y, r);
|
|
1018
|
+
const coeffs = this.pm.toCoeffs(r.get());
|
|
1019
|
+
r.reset();
|
|
1020
|
+
q.reset();
|
|
1021
|
+
first.reset();
|
|
1022
|
+
return coeffs;
|
|
1023
|
+
}
|
|
1024
|
+
|
|
1025
|
+
private getVarDifference(xDegree: number, yDegree: number) {
|
|
1026
|
+
const x = new PolynomialRef(this.pm);
|
|
1027
|
+
const y = new PolynomialRef(this.pm);
|
|
1028
|
+
const difference = new PolynomialRef(this.pm);
|
|
1029
|
+
x.set(this.pm.mkVar(X, xDegree));
|
|
1030
|
+
y.set(this.pm.mkVar(Y, yDegree));
|
|
1031
|
+
difference.set(this.pm.sub(x.get(), y.get()));
|
|
1032
|
+
y.reset();
|
|
1033
|
+
x.reset();
|
|
1034
|
+
return difference;
|
|
1035
|
+
}
|
|
1036
|
+
|
|
943
1037
|
private getSumPolynomial(first: AlgebraicCell, second: AlgebraicCell) {
|
|
944
|
-
const
|
|
945
|
-
|
|
1038
|
+
const p = new PolynomialRef(this.pm);
|
|
1039
|
+
const composed = new PolynomialRef(this.pm);
|
|
1040
|
+
p.set(this.pm.toPolynomial(first.p, X));
|
|
1041
|
+
this.pm.composeXMinusY(p.get(), Y, composed);
|
|
1042
|
+
p.reset();
|
|
1043
|
+
return this.getResultantCoeffs(composed, second.p);
|
|
946
1044
|
}
|
|
947
1045
|
|
|
948
1046
|
private getProductPolynomial(first: AlgebraicCell, second: AlgebraicCell) {
|
|
949
|
-
const
|
|
950
|
-
|
|
1047
|
+
const p = new PolynomialRef(this.pm);
|
|
1048
|
+
const composed = new PolynomialRef(this.pm);
|
|
1049
|
+
p.set(this.pm.toPolynomial(first.p, X));
|
|
1050
|
+
composed.set(this.pm.composeXDivY(p.get(), Y));
|
|
1051
|
+
p.reset();
|
|
1052
|
+
return this.getResultantCoeffs(composed, second.p);
|
|
951
1053
|
}
|
|
952
1054
|
|
|
953
1055
|
private findIsolatingFactor(
|
|
@@ -990,6 +1092,7 @@ export class AlgebraicManager {
|
|
|
990
1092
|
const savedA = this.saveInterval(first);
|
|
991
1093
|
const savedB = this.saveInterval(second);
|
|
992
1094
|
while (true) {
|
|
1095
|
+
this.limit.checkpoint();
|
|
993
1096
|
const interval = isAdd ? INTERVAL_OPS.add(cellA, cellB) : INTERVAL_OPS.mul(cellA, cellB);
|
|
994
1097
|
const found = this.findIsolatingFactor(factors, sequences, interval);
|
|
995
1098
|
if (found !== null) {
|
|
@@ -1009,8 +1112,7 @@ export class AlgebraicManager {
|
|
|
1009
1112
|
}
|
|
1010
1113
|
|
|
1011
1114
|
private getPowerPolynomial(cell: AlgebraicCell, exponent: number) {
|
|
1012
|
-
|
|
1013
|
-
return this.pm.toCoeffs(this.pm.resultant(x, this.pm.fromCoeffs(cell.p, Y), Y));
|
|
1115
|
+
return this.getResultantCoeffs(this.getVarDifference(1, exponent), cell.p);
|
|
1014
1116
|
}
|
|
1015
1117
|
|
|
1016
1118
|
private mkPower(anum: Anum, exponent: number): Anum {
|
|
@@ -1020,6 +1122,7 @@ export class AlgebraicManager {
|
|
|
1020
1122
|
const sequences: (Upolynomial[] | null)[] = factors.map((factor) => this.um.sturmSeq(factor));
|
|
1021
1123
|
const saved = this.saveInterval(anum);
|
|
1022
1124
|
while (true) {
|
|
1125
|
+
this.limit.checkpoint();
|
|
1023
1126
|
const interval = getIntervalPower(cell, exponent);
|
|
1024
1127
|
const found = this.findIsolatingFactor(factors, sequences, interval);
|
|
1025
1128
|
if (found !== null) {
|
|
@@ -1074,12 +1177,13 @@ export class AlgebraicManager {
|
|
|
1074
1177
|
if (sign !== 0) return sign;
|
|
1075
1178
|
if (hasSameCoeffs(cellA.p, cellB.p)) return 0;
|
|
1076
1179
|
if (cellA.isMinimal && cellB.isMinimal)
|
|
1077
|
-
while (
|
|
1180
|
+
while (this.limit.inc()) {
|
|
1078
1181
|
this.refine(first);
|
|
1079
1182
|
this.refine(second);
|
|
1080
1183
|
sign = compareIntervals();
|
|
1081
1184
|
if (sign !== 0) return sign;
|
|
1082
1185
|
}
|
|
1186
|
+
if (!this.limit.inc()) throw new SmtCanceledError();
|
|
1083
1187
|
const magnitudeA = this.getCellMagnitude(cellA);
|
|
1084
1188
|
const magnitudeB = this.getCellMagnitude(cellB);
|
|
1085
1189
|
const target = Math.max(MIN_MAGNITUDE, Math.min(magnitudeA, magnitudeB));
|
|
@@ -3,9 +3,11 @@ import {
|
|
|
3
3
|
type Polynomial,
|
|
4
4
|
type PolynomialCache,
|
|
5
5
|
type PolynomialManager,
|
|
6
|
+
PolynomialRef,
|
|
6
7
|
} from "./polynomial";
|
|
7
8
|
import {
|
|
8
9
|
type Atom,
|
|
10
|
+
type Clause,
|
|
9
11
|
type IneqAtom,
|
|
10
12
|
type IneqKind,
|
|
11
13
|
type RootAtom,
|
|
@@ -60,21 +62,27 @@ export class AtomTable {
|
|
|
60
62
|
return max;
|
|
61
63
|
}
|
|
62
64
|
|
|
63
|
-
reinitCache() {
|
|
64
|
-
for (const
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
65
|
+
reinitCache(clauses: readonly Clause[], learned: readonly Clause[]) {
|
|
66
|
+
for (const clause of clauses)
|
|
67
|
+
for (const literal of clause.literals) this.reinitAtomCache(this.atoms[literal >> 1]);
|
|
68
|
+
for (const clause of learned)
|
|
69
|
+
for (const literal of clause.literals) this.reinitAtomCache(this.atoms[literal >> 1]);
|
|
70
|
+
for (const atom of this.atoms) this.reinitAtomCache(atom);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
private reinitAtomCache(atom: Atom | null) {
|
|
74
|
+
if (atom === null) return;
|
|
75
|
+
if (isIneqAtom(atom)) {
|
|
76
|
+
let max = 0;
|
|
77
|
+
for (const polynomial of atom.polynomials) {
|
|
78
|
+
this.cache.mkUnique(polynomial);
|
|
79
|
+
max = Math.max(max, this.pm.maxVar(polynomial));
|
|
74
80
|
}
|
|
75
|
-
|
|
76
|
-
|
|
81
|
+
atom.maxVar = max;
|
|
82
|
+
return;
|
|
77
83
|
}
|
|
84
|
+
this.cache.mkUnique(atom.polynomial);
|
|
85
|
+
atom.maxVar = this.pm.maxVar(atom.polynomial);
|
|
78
86
|
}
|
|
79
87
|
|
|
80
88
|
getAtom(literal: number) {
|
|
@@ -113,6 +121,8 @@ export class AtomTable {
|
|
|
113
121
|
this.atoms[boolVar] = null;
|
|
114
122
|
this.hooks?.onDelete(boolVar);
|
|
115
123
|
this.freeBoolVars.push(boolVar);
|
|
124
|
+
if (isIneqAtom(atom)) for (const polynomial of atom.polynomials) this.pm.decRef(polynomial);
|
|
125
|
+
else this.pm.decRef(atom.polynomial);
|
|
116
126
|
}
|
|
117
127
|
|
|
118
128
|
private getIneqKey(atom: Pick<IneqAtom, "kind" | "polynomials" | "isEven">) {
|
|
@@ -126,13 +136,15 @@ export class AtomTable {
|
|
|
126
136
|
mkIneqAtom(kind: IneqKind, polynomials: readonly Polynomial[], isEven: readonly boolean[]) {
|
|
127
137
|
let sign = 1;
|
|
128
138
|
let maxVar = NULL_VAR;
|
|
129
|
-
const
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
139
|
+
const p = new PolynomialRef(this.pm);
|
|
140
|
+
const unique: Polynomial[] = [];
|
|
141
|
+
for (let index = 0; index < polynomials.length; index++) {
|
|
142
|
+
p.set(this.pm.flipSignIfLmNeg(polynomials[index]));
|
|
143
|
+
if (p.get() !== polynomials[index] && !isEven[index]) sign = -sign;
|
|
144
|
+
const variable = this.pm.maxVar(p.get());
|
|
133
145
|
if (variable > maxVar || maxVar === NULL_VAR) maxVar = variable;
|
|
134
|
-
|
|
135
|
-
}
|
|
146
|
+
unique.push(this.cache.mkUnique(p.get()));
|
|
147
|
+
}
|
|
136
148
|
const atom = {
|
|
137
149
|
kind: sign < 0 ? flipKind(kind) : kind,
|
|
138
150
|
boolVar: 0,
|
|
@@ -142,7 +154,12 @@ export class AtomTable {
|
|
|
142
154
|
};
|
|
143
155
|
const key = this.getIneqKey(atom);
|
|
144
156
|
const existing = this.ineqAtoms.get(key);
|
|
145
|
-
if (existing !== undefined)
|
|
157
|
+
if (existing !== undefined) {
|
|
158
|
+
p.reset();
|
|
159
|
+
return existing.boolVar;
|
|
160
|
+
}
|
|
161
|
+
for (const polynomial of unique) this.pm.incRef(polynomial);
|
|
162
|
+
p.reset();
|
|
146
163
|
atom.boolVar = this.mkBoolVar();
|
|
147
164
|
this.atoms[atom.boolVar] = atom;
|
|
148
165
|
this.ineqAtoms.set(key, atom);
|
|
@@ -177,21 +194,23 @@ export class AtomTable {
|
|
|
177
194
|
}
|
|
178
195
|
|
|
179
196
|
mkRootAtom(kind: RootKind, variable: number, index: number, polynomial: Polynomial) {
|
|
180
|
-
const
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
polynomial: this.cache.mkUnique(this.pm.flipSignIfLmNeg(polynomial)),
|
|
186
|
-
};
|
|
197
|
+
const p1 = new PolynomialRef(this.pm);
|
|
198
|
+
const uniqP = new PolynomialRef(this.pm);
|
|
199
|
+
p1.set(this.pm.flipSignIfLmNeg(polynomial));
|
|
200
|
+
uniqP.set(this.cache.mkUnique(p1.get()));
|
|
201
|
+
const atom = { kind, boolVar: 0, maxVar: variable, index, polynomial: uniqP.get() };
|
|
187
202
|
const key = this.getRootKey(atom);
|
|
188
203
|
const existing = this.rootAtoms.get(key);
|
|
189
|
-
if (existing
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
204
|
+
if (existing === undefined) {
|
|
205
|
+
atom.boolVar = this.mkBoolVar();
|
|
206
|
+
this.atoms[atom.boolVar] = atom;
|
|
207
|
+
this.rootAtoms.set(key, atom);
|
|
208
|
+
this.rootKeys.set(atom.boolVar, key);
|
|
209
|
+
this.pm.incRef(atom.polynomial);
|
|
210
|
+
}
|
|
211
|
+
uniqP.reset();
|
|
212
|
+
p1.reset();
|
|
213
|
+
return existing === undefined ? atom.boolVar : existing.boolVar;
|
|
195
214
|
}
|
|
196
215
|
}
|
|
197
216
|
|