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
|
@@ -182,7 +182,7 @@ const isDigit = (code: number) => code >= 48 && code <= 57;
|
|
|
182
182
|
const getCount = (bag: Map<number, number>, key: number) => bag.get(key) ?? 0;
|
|
183
183
|
|
|
184
184
|
const isSameBag = (first: Map<number, number>, second: Map<number, number>) =>
|
|
185
|
-
first.size === second.size && [...first].every((
|
|
185
|
+
first.size === second.size && [...first].every((entry) => second.get(entry[0]) === entry[1]);
|
|
186
186
|
|
|
187
187
|
export class SeqRewriter {
|
|
188
188
|
readonly re: ReRewriter;
|
|
@@ -499,8 +499,7 @@ export class SeqRewriter {
|
|
|
499
499
|
return manager.mkString([...firstChars, ...secondChars]);
|
|
500
500
|
const elements: number[] = [];
|
|
501
501
|
const todo = [second, first];
|
|
502
|
-
|
|
503
|
-
const expr = todo.pop()!;
|
|
502
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
504
503
|
if (this.isConcat2(expr)) {
|
|
505
504
|
todo.push(this.getArg(expr, 1), this.getArg(expr, 0));
|
|
506
505
|
continue;
|
|
@@ -510,7 +509,8 @@ export class SeqRewriter {
|
|
|
510
509
|
if (elements.length === 0) return this.mkEmpty(manager.sorts[first]);
|
|
511
510
|
const coalesced: number[] = [];
|
|
512
511
|
for (const element of elements) {
|
|
513
|
-
const previous =
|
|
512
|
+
const previous =
|
|
513
|
+
coalesced.length > 0 ? manager.getString(coalesced[coalesced.length - 1]) : undefined;
|
|
514
514
|
const chars = manager.getString(element);
|
|
515
515
|
if (this.isCoalescingChars && previous !== undefined && chars !== undefined)
|
|
516
516
|
coalesced[coalesced.length - 1] = manager.mkString([...previous, ...chars]);
|
|
@@ -518,7 +518,10 @@ export class SeqRewriter {
|
|
|
518
518
|
}
|
|
519
519
|
return coalesced
|
|
520
520
|
.slice(0, -1)
|
|
521
|
-
.reduceRight(
|
|
521
|
+
.reduceRight(
|
|
522
|
+
(tail, element) => this.mkConcat(element, tail),
|
|
523
|
+
coalesced[coalesced.length - 1],
|
|
524
|
+
);
|
|
522
525
|
}
|
|
523
526
|
|
|
524
527
|
private mkSeqLength(seq: number): Result {
|
|
@@ -765,8 +768,7 @@ export class SeqRewriter {
|
|
|
765
768
|
let isOtherFactorAtLeastOne = true;
|
|
766
769
|
const todo = [offset];
|
|
767
770
|
const visited = new Set<number>();
|
|
768
|
-
|
|
769
|
-
const arg = todo.pop()!;
|
|
771
|
+
for (let arg = todo.pop(); arg !== undefined; arg = todo.pop()) {
|
|
770
772
|
if (visited.has(arg)) continue;
|
|
771
773
|
visited.add(arg);
|
|
772
774
|
if (this.isOp(arg, OP_MUL)) todo.push(...manager.getArgs(arg));
|
|
@@ -956,7 +958,7 @@ export class SeqRewriter {
|
|
|
956
958
|
let start = 0;
|
|
957
959
|
let end = seqUnits.length;
|
|
958
960
|
const first = otherUnits[0];
|
|
959
|
-
const last = otherUnits.
|
|
961
|
+
const last = otherUnits[otherUnits.length - 1];
|
|
960
962
|
while (start < seqUnits.length && this.isNotContainingPrefix(seqUnits[start], first)) start++;
|
|
961
963
|
while (end > start && this.isNotContainingSuffix(seqUnits[end - 1], last)) end--;
|
|
962
964
|
if (start === end) return rewrite(this.mkIsEmpty(other), BR_REWRITE2);
|
|
@@ -1701,7 +1703,7 @@ export class SeqRewriter {
|
|
|
1701
1703
|
const seq = this.getArg(value, 0);
|
|
1702
1704
|
const maxLength = this.getMaxLength(seq);
|
|
1703
1705
|
if (!maxLength.isBounded || maxLength.length > 1n) return undefined;
|
|
1704
|
-
const eqs = Array.from({ length: 10 }, (
|
|
1706
|
+
const eqs = Array.from({ length: 10 }, (_value, digit) =>
|
|
1705
1707
|
this.mkEq(seq, manager.mkString([48 + digit])),
|
|
1706
1708
|
);
|
|
1707
1709
|
const isDigitString = manager.mkApp(OP_OR, eqs, SORT_BOOL);
|
|
@@ -1738,8 +1740,8 @@ export class SeqRewriter {
|
|
|
1738
1740
|
}
|
|
1739
1741
|
const units = getConcatUnits(manager, seq, []);
|
|
1740
1742
|
if (units.length === 0) return this.minusOne();
|
|
1741
|
-
if (this.isUnit(units.
|
|
1742
|
-
const tail = this.mkSeq(OP_STRING_STOI, [units.
|
|
1743
|
+
if (this.isUnit(units[units.length - 1])) {
|
|
1744
|
+
const tail = this.mkSeq(OP_STRING_STOI, [units[units.length - 1]]);
|
|
1743
1745
|
const head = this.mkConcatOf(units.slice(0, -1), manager.sorts[seq]);
|
|
1744
1746
|
const headValue = this.mkSeq(OP_STRING_STOI, [head]);
|
|
1745
1747
|
const isHeadValid = this.mkGe(headValue, this.zero());
|
|
@@ -1789,24 +1791,20 @@ export class SeqRewriter {
|
|
|
1789
1791
|
if (isVisited) cache.set(expr, { isBounded: isValid, length: count });
|
|
1790
1792
|
return isVisited;
|
|
1791
1793
|
} else if (this.isOp(expr, OP_ITE)) {
|
|
1792
|
-
const size = pending.length;
|
|
1793
1794
|
const thenLength = cache.get(this.getArg(expr, 1));
|
|
1794
1795
|
const elseLength = cache.get(this.getArg(expr, 2));
|
|
1795
1796
|
if (thenLength === undefined) pending.push(this.getArg(expr, 1));
|
|
1796
1797
|
if (elseLength === undefined) pending.push(this.getArg(expr, 2));
|
|
1797
|
-
if (
|
|
1798
|
+
if (thenLength === undefined || elseLength === undefined) return false;
|
|
1798
1799
|
cache.set(expr, {
|
|
1799
1800
|
isBounded:
|
|
1800
|
-
thenLength
|
|
1801
|
-
|
|
1802
|
-
thenLength!.length === elseLength!.length,
|
|
1803
|
-
length: Math.min(thenLength!.length, elseLength!.length),
|
|
1801
|
+
thenLength.isBounded && elseLength.isBounded && thenLength.length === elseLength.length,
|
|
1802
|
+
length: Math.min(thenLength.length, elseLength.length),
|
|
1804
1803
|
});
|
|
1805
1804
|
} else cache.set(expr, { isBounded: false, length: 0 });
|
|
1806
1805
|
return true;
|
|
1807
1806
|
};
|
|
1808
|
-
|
|
1809
|
-
const expr = todo.pop()!;
|
|
1807
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1810
1808
|
const chars = manager.getString(expr);
|
|
1811
1809
|
if (this.isUnit(expr)) length++;
|
|
1812
1810
|
else if (this.isEmpty(expr)) continue;
|
|
@@ -1816,7 +1814,7 @@ export class SeqRewriter {
|
|
|
1816
1814
|
const thenExpr = this.getArg(expr, 1);
|
|
1817
1815
|
const elseExpr = this.getArg(expr, 2);
|
|
1818
1816
|
pending.push(thenExpr, elseExpr);
|
|
1819
|
-
while (pending.length > 0) if (visit(pending.
|
|
1817
|
+
while (pending.length > 0) if (visit(pending[pending.length - 1])) pending.pop();
|
|
1820
1818
|
const thenLength = cache.get(thenExpr) ?? { isBounded: false, length: 0 };
|
|
1821
1819
|
const elseLength = cache.get(elseExpr) ?? { isBounded: false, length: 0 };
|
|
1822
1820
|
if (
|
|
@@ -1835,8 +1833,7 @@ export class SeqRewriter {
|
|
|
1835
1833
|
const manager = this.manager;
|
|
1836
1834
|
const todo = [seq];
|
|
1837
1835
|
let length = 0n;
|
|
1838
|
-
|
|
1839
|
-
const expr = todo.pop()!;
|
|
1836
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1840
1837
|
const chars = manager.getString(expr);
|
|
1841
1838
|
if (this.isUnit(expr) || this.isApp(expr, OP_SEQ_AT, 2)) length += 1n;
|
|
1842
1839
|
else if (chars !== undefined) length += BigInt(chars.length);
|
|
@@ -2036,8 +2033,7 @@ export class SeqRewriter {
|
|
|
2036
2033
|
const manager = this.manager;
|
|
2037
2034
|
const elements: number[] = [];
|
|
2038
2035
|
const todo = [seq];
|
|
2039
|
-
|
|
2040
|
-
const expr = todo.pop()!;
|
|
2036
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
2041
2037
|
if (this.isOp(expr, OP_SEQ_CONCAT)) {
|
|
2042
2038
|
todo.push(...manager.getArgs(expr));
|
|
2043
2039
|
continue;
|
|
@@ -2113,10 +2109,13 @@ export class SeqRewriter {
|
|
|
2113
2109
|
private reduceBack(pair: SeqPair, eqs: EqPair[]) {
|
|
2114
2110
|
const manager = this.manager;
|
|
2115
2111
|
while (pair.left.length > 0 && pair.right.length > 0) {
|
|
2116
|
-
if (
|
|
2112
|
+
if (
|
|
2113
|
+
this.isUnit(pair.right[pair.right.length - 1]) &&
|
|
2114
|
+
manager.getString(pair.left[pair.left.length - 1]) !== undefined
|
|
2115
|
+
)
|
|
2117
2116
|
this.swap(pair);
|
|
2118
|
-
const left = pair.left.
|
|
2119
|
-
const right = pair.right.
|
|
2117
|
+
const left = pair.left[pair.left.length - 1];
|
|
2118
|
+
const right = pair.right[pair.right.length - 1];
|
|
2120
2119
|
const rightChars = manager.getString(right);
|
|
2121
2120
|
const leftChars = manager.getString(left);
|
|
2122
2121
|
if (left === right) {
|
|
@@ -2128,7 +2127,10 @@ export class SeqRewriter {
|
|
|
2128
2127
|
pair.left.pop();
|
|
2129
2128
|
pair.right.pop();
|
|
2130
2129
|
} else if (this.isUnit(left) && rightChars !== undefined) {
|
|
2131
|
-
eqs.push({
|
|
2130
|
+
eqs.push({
|
|
2131
|
+
left: manager.mkChar(rightChars[rightChars.length - 1]),
|
|
2132
|
+
right: this.getArg(left, 0),
|
|
2133
|
+
});
|
|
2132
2134
|
pair.left.pop();
|
|
2133
2135
|
if (rightChars.length === 1) pair.right.pop();
|
|
2134
2136
|
else pair.right[pair.right.length - 1] = manager.mkString(rightChars.slice(0, -1));
|
|
@@ -2229,7 +2231,7 @@ export class SeqRewriter {
|
|
|
2229
2231
|
for (const expr of right) {
|
|
2230
2232
|
const index = remaining.indexOf(expr);
|
|
2231
2233
|
if (index !== -1) {
|
|
2232
|
-
remaining[index] = remaining.
|
|
2234
|
+
remaining[index] = remaining[remaining.length - 1];
|
|
2233
2235
|
remaining.pop();
|
|
2234
2236
|
continue;
|
|
2235
2237
|
}
|
|
@@ -48,10 +48,6 @@ export class SeqSkolem {
|
|
|
48
48
|
return this.manager.mkNumeral(BigInt(value));
|
|
49
49
|
}
|
|
50
50
|
|
|
51
|
-
mkAlign(args: number[]) {
|
|
52
|
-
return this.mk("seq.align", args);
|
|
53
|
-
}
|
|
54
|
-
|
|
55
51
|
mkAlignL(args: number[]) {
|
|
56
52
|
return this.mk("seq.align.l", args);
|
|
57
53
|
}
|
|
@@ -201,12 +197,6 @@ export class SeqSkolem {
|
|
|
201
197
|
return this.isNamed(expr, TAIL);
|
|
202
198
|
}
|
|
203
199
|
|
|
204
|
-
getTailIndex(expr: number) {
|
|
205
|
-
if (!this.isTail(expr)) return undefined;
|
|
206
|
-
const index = this.manager.getNumeral(this.manager.getArg(expr, 1));
|
|
207
|
-
return index !== undefined && index >= 0n && index <= 0xffffffffn ? Number(index) : undefined;
|
|
208
|
-
}
|
|
209
|
-
|
|
210
200
|
isSeqFirst(expr: number) {
|
|
211
201
|
return this.isNamed(expr, SEQ_FIRST);
|
|
212
202
|
}
|
|
@@ -231,10 +221,6 @@ export class SeqSkolem {
|
|
|
231
221
|
return this.isNamed(expr, EQ) && this.manager.getNumArgs(expr) === 2;
|
|
232
222
|
}
|
|
233
223
|
|
|
234
|
-
isDigit(expr: number) {
|
|
235
|
-
return this.isNamed(expr, "seq.is_digit");
|
|
236
|
-
}
|
|
237
|
-
|
|
238
224
|
isMaxUnfolding(expr: number) {
|
|
239
225
|
return this.isNamed(expr, MAX_UNFOLDING);
|
|
240
226
|
}
|
|
@@ -257,15 +243,6 @@ export class SeqSkolem {
|
|
|
257
243
|
return this.isNamed(expr, "seq.align.r");
|
|
258
244
|
}
|
|
259
245
|
|
|
260
|
-
isRegexSkolem(expr: number) {
|
|
261
|
-
return (
|
|
262
|
-
this.isNamed(expr, ACCEPT) ||
|
|
263
|
-
this.isNamed(expr, "re.is_empty") ||
|
|
264
|
-
this.isNamed(expr, "re.is_non_empty") ||
|
|
265
|
-
this.isNamed(expr, "aut.step")
|
|
266
|
-
);
|
|
267
|
-
}
|
|
268
|
-
|
|
269
246
|
decompose(input: number): Decomposition {
|
|
270
247
|
const manager = this.manager;
|
|
271
248
|
const mkNthUnit = (seq: number, index: number | bigint) =>
|
|
@@ -8,12 +8,12 @@ import type { ReRewriter } from "./seq-re-rewriter";
|
|
|
8
8
|
import { isReEmpty } from "./seq-re-util";
|
|
9
9
|
|
|
10
10
|
export const VIEW_FAILURE_NONE = 0;
|
|
11
|
-
|
|
11
|
+
const VIEW_FAILURE_UNSUPPORTED = 1;
|
|
12
12
|
export const VIEW_FAILURE_BUDGET = 2;
|
|
13
13
|
export const VIEW_FAILURE_RESOURCE = 3;
|
|
14
14
|
export const VIEW_FAILURE_STATE_EXPANSION = 4;
|
|
15
|
-
|
|
16
|
-
|
|
15
|
+
const VIEW_FAILURE_NULLABILITY = 5;
|
|
16
|
+
const VIEW_FAILURE_GUARD = 6;
|
|
17
17
|
|
|
18
18
|
const INNER_LIMIT = 1 << 16;
|
|
19
19
|
const RANGE_CACHE_CAP = 1 << 16;
|
|
@@ -24,7 +24,7 @@ interface IntervalList {
|
|
|
24
24
|
isOk: boolean;
|
|
25
25
|
}
|
|
26
26
|
|
|
27
|
-
|
|
27
|
+
interface ProductResult {
|
|
28
28
|
status: number;
|
|
29
29
|
word: number;
|
|
30
30
|
}
|
|
@@ -239,7 +239,7 @@ class ConsequenceFinder {
|
|
|
239
239
|
const result = kernel.check(assumptions);
|
|
240
240
|
if (result !== L_TRUE) return result;
|
|
241
241
|
if (context.qmanager.hasQuantifiers()) return L_UNDEF;
|
|
242
|
-
const model = context.
|
|
242
|
+
const model = context.getSatModel();
|
|
243
243
|
for (const variable of vars) {
|
|
244
244
|
const value = model.eval(variable, false);
|
|
245
245
|
trail.pushOwned(value);
|
|
@@ -1,15 +1,20 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { SmtDefaultError } from "../../../errors";
|
|
2
2
|
import { type AstManager } from "./ast";
|
|
3
3
|
import type { SmtSetup } from "./smt-setup";
|
|
4
4
|
import { AssertedFormulas } from "./asserted-formulas";
|
|
5
5
|
import { Context } from "./context";
|
|
6
|
+
import { L_TRUE } from "./lbool";
|
|
7
|
+
import { Mus } from "./mus";
|
|
8
|
+
import { RefVector } from "./ref-vector";
|
|
6
9
|
import type { KernelParams } from "./solver";
|
|
7
10
|
|
|
8
11
|
export class SmtKernel {
|
|
9
12
|
readonly context: Context;
|
|
10
13
|
private asserted: AssertedFormulas;
|
|
11
|
-
|
|
14
|
+
isSetUp = false;
|
|
12
15
|
private setup: SmtSetup | undefined;
|
|
16
|
+
private isCoreMinimizing: boolean;
|
|
17
|
+
private scopeCount = 0;
|
|
13
18
|
|
|
14
19
|
constructor(manager: AstManager, params: KernelParams) {
|
|
15
20
|
this.asserted = new AssertedFormulas(manager, params.isFindingMacros);
|
|
@@ -17,14 +22,23 @@ export class SmtKernel {
|
|
|
17
22
|
isMbqi: params.isMbqi,
|
|
18
23
|
mbqiMaxIterations: params.mbqiMaxIterations,
|
|
19
24
|
relevancyLevel: params.relevancyLevel ?? 2,
|
|
25
|
+
randomSeed: params.randomSeed,
|
|
20
26
|
});
|
|
21
27
|
this.setup = params.setup;
|
|
28
|
+
this.isCoreMinimizing = params.isCoreMinimizing ?? false;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
// As in Z3, a kernel not yet set up reads auto_config again.
|
|
32
|
+
updateParams(params: KernelParams) {
|
|
33
|
+
if (!this.isSetUp) this.setup = params.setup;
|
|
34
|
+
this.isCoreMinimizing = params.isCoreMinimizing ?? false;
|
|
35
|
+
this.context.updateParams(params);
|
|
36
|
+
this.asserted.updateParams(this.context.config);
|
|
22
37
|
}
|
|
23
38
|
|
|
24
39
|
private setupContext(isUsingStaticFeatures: boolean) {
|
|
25
40
|
if (this.isSetUp) return;
|
|
26
|
-
this.isSetUp =
|
|
27
|
-
this.context.setupContext(this.setup, isUsingStaticFeatures, this.asserted);
|
|
41
|
+
this.isSetUp = this.context.setupContext(this.setup, isUsingStaticFeatures, this.asserted);
|
|
28
42
|
}
|
|
29
43
|
|
|
30
44
|
// context::copy sets up and internalizes a copy as soon as it makes it.
|
|
@@ -37,7 +51,9 @@ export class SmtKernel {
|
|
|
37
51
|
this.asserted.isPreprocessing = isPreprocessing;
|
|
38
52
|
}
|
|
39
53
|
|
|
54
|
+
// context::assert_expr_core counts a step, and drops the formula once the limit is spent.
|
|
40
55
|
assertExpr(expr: number) {
|
|
56
|
+
if (this.context.checkCanceled()) return;
|
|
41
57
|
this.context.popToBaseLevel();
|
|
42
58
|
this.asserted.assertExpr(expr);
|
|
43
59
|
}
|
|
@@ -46,15 +62,19 @@ export class SmtKernel {
|
|
|
46
62
|
const context = this.context;
|
|
47
63
|
context.popToBaseLevel();
|
|
48
64
|
this.setupContext(false);
|
|
65
|
+
const wasConsistent = !context.isInconsistent();
|
|
49
66
|
context.internalizeAssertions(this.asserted);
|
|
50
67
|
const limit = context.manager.limit;
|
|
51
|
-
if (!limit.inc()) throw new
|
|
68
|
+
if (!limit.inc()) throw new SmtDefaultError("push canceled");
|
|
52
69
|
const wasSuspended = limit.isSuspended;
|
|
53
70
|
limit.isSuspended = true;
|
|
54
71
|
if (!context.isInconsistent()) context.propagate();
|
|
72
|
+
if (wasConsistent && context.isInconsistent() && !this.asserted.isInconsistent)
|
|
73
|
+
context.resolveConflict();
|
|
55
74
|
limit.isSuspended = wasSuspended;
|
|
56
75
|
context.push();
|
|
57
76
|
this.asserted.push();
|
|
77
|
+
this.scopeCount++;
|
|
58
78
|
}
|
|
59
79
|
|
|
60
80
|
getAssertions() {
|
|
@@ -62,8 +82,11 @@ export class SmtKernel {
|
|
|
62
82
|
}
|
|
63
83
|
|
|
64
84
|
pop(numScopes: number) {
|
|
65
|
-
|
|
66
|
-
|
|
85
|
+
const count = Math.min(numScopes, this.scopeCount);
|
|
86
|
+
if (count === 0) return;
|
|
87
|
+
this.context.pop(count);
|
|
88
|
+
for (let index = 0; index < count; index++) this.asserted.pop();
|
|
89
|
+
this.scopeCount -= count;
|
|
67
90
|
}
|
|
68
91
|
|
|
69
92
|
initAssumptions(assumptions: number[]) {
|
|
@@ -80,4 +103,22 @@ export class SmtKernel {
|
|
|
80
103
|
this.setupContext(true);
|
|
81
104
|
return this.check();
|
|
82
105
|
}
|
|
106
|
+
|
|
107
|
+
getUnsatCore(core: RefVector) {
|
|
108
|
+
for (const expr of this.context.unsatCore) core.push(expr);
|
|
109
|
+
if (!this.isCoreMinimizing) return;
|
|
110
|
+
const manager = this.context.manager;
|
|
111
|
+
const mus = new Mus(manager, {
|
|
112
|
+
checkSat: (assumptions) => this.check(assumptions),
|
|
113
|
+
getUnsatCore: () => this.context.unsatCore,
|
|
114
|
+
});
|
|
115
|
+
for (const literal of core.items) mus.addSoft(literal);
|
|
116
|
+
const minimized = new RefVector(manager);
|
|
117
|
+
if (mus.getMus(minimized) === L_TRUE) {
|
|
118
|
+
core.reset();
|
|
119
|
+
for (const literal of minimized.items) core.push(literal);
|
|
120
|
+
}
|
|
121
|
+
minimized.reset();
|
|
122
|
+
mus.reset();
|
|
123
|
+
}
|
|
83
124
|
}
|
|
@@ -7,14 +7,19 @@ import {
|
|
|
7
7
|
FAMILY_ARRAY,
|
|
8
8
|
FAMILY_BV,
|
|
9
9
|
FAMILY_CHAR,
|
|
10
|
+
FAMILY_DATALOG_RELATION,
|
|
10
11
|
FAMILY_DATATYPE,
|
|
12
|
+
FAMILY_FF,
|
|
11
13
|
FAMILY_FINITE_SET,
|
|
12
14
|
FAMILY_FPA,
|
|
13
15
|
FAMILY_POLY,
|
|
14
16
|
FAMILY_RECFUN,
|
|
15
17
|
FAMILY_SEQ,
|
|
18
|
+
FAMILY_SPECIAL_RELATIONS,
|
|
16
19
|
} from "./ast";
|
|
20
|
+
import { SmtDefaultError } from "../../../errors";
|
|
17
21
|
import { collectStaticFeatures, isDense, type StaticFeatures } from "./static-features";
|
|
22
|
+
import { Rational } from "./rational";
|
|
18
23
|
|
|
19
24
|
const AUFLIA_LOGICS = new Set([
|
|
20
25
|
"AUFLIA",
|
|
@@ -101,6 +106,12 @@ export interface SmtConfig {
|
|
|
101
106
|
isNnfCnf: boolean;
|
|
102
107
|
isEq2Ineq: boolean;
|
|
103
108
|
isFindingMacros: boolean;
|
|
109
|
+
isEliminatingTermIte: boolean;
|
|
110
|
+
isLiftingNonGroundIte: boolean;
|
|
111
|
+
isEliminatingBounds: boolean;
|
|
112
|
+
isArithPropagatingEqs: boolean;
|
|
113
|
+
arithPropagationThreshold: number;
|
|
114
|
+
isArithBoundPropagating: boolean;
|
|
104
115
|
}
|
|
105
116
|
|
|
106
117
|
const UNKNOWN_THEORIES = [
|
|
@@ -109,10 +120,13 @@ const UNKNOWN_THEORIES = [
|
|
|
109
120
|
FAMILY_BV,
|
|
110
121
|
FAMILY_DATATYPE,
|
|
111
122
|
FAMILY_RECFUN,
|
|
123
|
+
FAMILY_DATALOG_RELATION,
|
|
112
124
|
FAMILY_SEQ,
|
|
113
125
|
FAMILY_CHAR,
|
|
114
126
|
FAMILY_FPA,
|
|
127
|
+
FAMILY_FF,
|
|
115
128
|
FAMILY_FINITE_SET,
|
|
129
|
+
FAMILY_SPECIAL_RELATIONS,
|
|
116
130
|
FAMILY_POLY,
|
|
117
131
|
];
|
|
118
132
|
|
|
@@ -128,6 +142,12 @@ export const DEFAULT_CONFIG: SmtConfig = {
|
|
|
128
142
|
isNnfCnf: true,
|
|
129
143
|
isEq2Ineq: false,
|
|
130
144
|
isFindingMacros: false,
|
|
145
|
+
isEliminatingTermIte: false,
|
|
146
|
+
isLiftingNonGroundIte: false,
|
|
147
|
+
isEliminatingBounds: false,
|
|
148
|
+
isArithPropagatingEqs: true,
|
|
149
|
+
arithPropagationThreshold: Infinity,
|
|
150
|
+
isArithBoundPropagating: true,
|
|
131
151
|
};
|
|
132
152
|
|
|
133
153
|
// setup_unknown(), which closes with setup_relevancy.
|
|
@@ -144,15 +164,23 @@ const setupQfUf = (config: SmtConfig) => {
|
|
|
144
164
|
config.randomInitialActivity = IA_RANDOM;
|
|
145
165
|
};
|
|
146
166
|
|
|
167
|
+
const setupQfUfByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
168
|
+
if (isArith(features))
|
|
169
|
+
throw new SmtDefaultError(
|
|
170
|
+
"Benchmark constrains arithmetic, but specified logic does not support it.",
|
|
171
|
+
);
|
|
172
|
+
setupQfUf(config);
|
|
173
|
+
};
|
|
174
|
+
|
|
147
175
|
const setupQfDt = (config: SmtConfig) => {
|
|
148
176
|
setupQfUf(config);
|
|
149
177
|
config.theories.push(FAMILY_DATATYPE, FAMILY_RECFUN);
|
|
150
178
|
};
|
|
151
179
|
|
|
152
|
-
// The parameters smt_params::setup_QF_IDL, setup_QF_RDL and setup_QF_LIA share.
|
|
153
180
|
const setupDiffLogicParams = (config: SmtConfig) => {
|
|
154
181
|
config.relevancyLevel = 0;
|
|
155
182
|
config.isEq2Ineq = true;
|
|
183
|
+
config.isArithPropagatingEqs = false;
|
|
156
184
|
config.isNnfCnf = false;
|
|
157
185
|
};
|
|
158
186
|
|
|
@@ -161,27 +189,47 @@ const setupQfLia = (config: SmtConfig) => {
|
|
|
161
189
|
config.theories.push(FAMILY_ARITH);
|
|
162
190
|
};
|
|
163
191
|
|
|
192
|
+
const checkNoUninterpretedFunctions = (features: StaticFeatures) => {
|
|
193
|
+
if (features.numUninterpretedFunctions !== 0)
|
|
194
|
+
throw new SmtDefaultError(
|
|
195
|
+
"Benchmark contains uninterpreted function symbols, but specified logic does not support them.",
|
|
196
|
+
);
|
|
197
|
+
};
|
|
198
|
+
|
|
164
199
|
const setupQfLiaByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
200
|
+
checkNoUninterpretedFunctions(features);
|
|
165
201
|
setupDiffLogicParams(config);
|
|
166
202
|
if (features.maxIteTreeDepth > 50) {
|
|
167
203
|
config.isEq2Ineq = false;
|
|
204
|
+
config.isArithPropagatingEqs = true;
|
|
168
205
|
config.relevancyLevel = 2;
|
|
169
|
-
} else if (features.numClauses === features.numUnits)
|
|
170
|
-
|
|
206
|
+
} else if (features.numClauses === features.numUnits) {
|
|
207
|
+
config.relevancyLevel = 2;
|
|
208
|
+
config.isEliminatingTermIte = true;
|
|
209
|
+
} else {
|
|
210
|
+
config.isEliminatingTermIte = true;
|
|
171
211
|
config.isRestartAdaptive = false;
|
|
172
212
|
config.restartStrategy = RS_GEOMETRIC;
|
|
173
213
|
config.restartFactor = 1.5;
|
|
174
214
|
}
|
|
215
|
+
if (
|
|
216
|
+
features.numBinClauses + features.numUnits === features.numClauses &&
|
|
217
|
+
features.isCnf &&
|
|
218
|
+
features.arithKSum.compare(Rational.of(100000n)) > 0
|
|
219
|
+
)
|
|
220
|
+
config.isArithBoundPropagating = false;
|
|
175
221
|
config.theories.push(FAMILY_ARITH);
|
|
176
222
|
};
|
|
177
223
|
|
|
178
224
|
const setupQfLra = (config: SmtConfig) => {
|
|
179
225
|
setupDiffLogicParams(config);
|
|
226
|
+
config.isEliminatingTermIte = true;
|
|
180
227
|
config.phaseSelection = PS_THEORY;
|
|
181
228
|
config.theories.push(FAMILY_ARITH);
|
|
182
229
|
};
|
|
183
230
|
|
|
184
231
|
const setupQfLraByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
232
|
+
checkNoUninterpretedFunctions(features);
|
|
185
233
|
setupQfLra(config);
|
|
186
234
|
if (features.arithKSum.num > 2000000n && features.arithKSum.den > 500n) config.relevancyLevel = 2;
|
|
187
235
|
if (features.isCnf) return;
|
|
@@ -190,6 +238,13 @@ const setupQfLraByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
|
190
238
|
};
|
|
191
239
|
|
|
192
240
|
const setupQfRdlByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
241
|
+
if (!isInDiffLogic(features))
|
|
242
|
+
throw new SmtDefaultError("Benchmark is not in QF_RDL (real difference logic).");
|
|
243
|
+
if (features.hasInt)
|
|
244
|
+
throw new SmtDefaultError(
|
|
245
|
+
"Benchmark has integer variables but it is marked as QF_RDL (real difference logic).",
|
|
246
|
+
);
|
|
247
|
+
checkNoUninterpretedFunctions(features);
|
|
193
248
|
setupDiffLogicParams(config);
|
|
194
249
|
if (isDense(features)) {
|
|
195
250
|
config.restartStrategy = RS_GEOMETRIC;
|
|
@@ -200,6 +255,13 @@ const setupQfRdlByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
|
200
255
|
};
|
|
201
256
|
|
|
202
257
|
const setupQfIdlByFeatures = (config: SmtConfig, features: StaticFeatures, setup: SmtSetup) => {
|
|
258
|
+
if (!isInDiffLogic(features))
|
|
259
|
+
throw new SmtDefaultError("Benchmark is not in QF_IDL (integer difference logic).");
|
|
260
|
+
if (features.hasReal)
|
|
261
|
+
throw new SmtDefaultError(
|
|
262
|
+
"Benchmark has real variables but it is marked as QF_IDL (integer difference logic).",
|
|
263
|
+
);
|
|
264
|
+
checkNoUninterpretedFunctions(features);
|
|
203
265
|
setupDiffLogicParams(config);
|
|
204
266
|
if (features.numUninterpretedConstants > 5000) config.relevancyLevel = 2;
|
|
205
267
|
else if (features.isCnf && !isDense(features)) config.phaseSelection = PS_CACHING_CONSERVATIVE2;
|
|
@@ -216,7 +278,9 @@ const setupQfIdlByFeatures = (config: SmtConfig, features: StaticFeatures, setup
|
|
|
216
278
|
};
|
|
217
279
|
|
|
218
280
|
const setupQfUfIdl = (config: SmtConfig) => {
|
|
219
|
-
|
|
281
|
+
config.relevancyLevel = 0;
|
|
282
|
+
config.isNnfCnf = false;
|
|
283
|
+
config.isEq2Ineq = true;
|
|
220
284
|
config.restartStrategy = RS_GEOMETRIC;
|
|
221
285
|
config.restartFactor = 1.5;
|
|
222
286
|
config.isRestartAdaptive = false;
|
|
@@ -224,10 +288,15 @@ const setupQfUfIdl = (config: SmtConfig) => {
|
|
|
224
288
|
};
|
|
225
289
|
|
|
226
290
|
const setupQfUfIdlByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
291
|
+
if (features.hasReal)
|
|
292
|
+
throw new SmtDefaultError(
|
|
293
|
+
"Benchmark has real variables but it is marked as QF_UFIDL (uninterpreted functions and difference logic).",
|
|
294
|
+
);
|
|
227
295
|
config.relevancyLevel = 0;
|
|
228
296
|
config.isNnfCnf = false;
|
|
229
297
|
if (features.numUninterpretedFunctions === 0) {
|
|
230
298
|
config.isEq2Ineq = true;
|
|
299
|
+
config.isArithPropagatingEqs = false;
|
|
231
300
|
if (isDense(features)) {
|
|
232
301
|
config.restartStrategy = RS_GEOMETRIC;
|
|
233
302
|
config.theories.push(FAMILY_ARITH);
|
|
@@ -240,12 +309,17 @@ const setupQfUfIdlByFeatures = (config: SmtConfig, features: StaticFeatures) =>
|
|
|
240
309
|
config.theories.push(FAMILY_ARITH);
|
|
241
310
|
};
|
|
242
311
|
|
|
243
|
-
const
|
|
312
|
+
const setupQfUfLra = (config: SmtConfig) => {
|
|
244
313
|
config.theories.push(FAMILY_ARITH);
|
|
245
314
|
config.relevancyLevel = 0;
|
|
246
315
|
config.isNnfCnf = false;
|
|
247
316
|
};
|
|
248
317
|
|
|
318
|
+
const setupQfUfLia = (config: SmtConfig) => {
|
|
319
|
+
setupQfUfLra(config);
|
|
320
|
+
config.arithPropagationThreshold = 1000;
|
|
321
|
+
};
|
|
322
|
+
|
|
249
323
|
const setupQfBv = (config: SmtConfig) => {
|
|
250
324
|
config.relevancyLevel = 0;
|
|
251
325
|
config.isNnfCnf = false;
|
|
@@ -253,6 +327,10 @@ const setupQfBv = (config: SmtConfig) => {
|
|
|
253
327
|
};
|
|
254
328
|
|
|
255
329
|
const setupQfUfLiaByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
330
|
+
if (features.hasReal)
|
|
331
|
+
throw new SmtDefaultError(
|
|
332
|
+
"Benchmark has real variables but it is marked as QF_UFLIA (uninterpreted functions and linear integer arithmetic).",
|
|
333
|
+
);
|
|
256
334
|
setupQfUfLia(config);
|
|
257
335
|
if (features.hasBv) setupQfBv(config);
|
|
258
336
|
};
|
|
@@ -308,23 +386,36 @@ const setupAufLia = (config: SmtConfig) => {
|
|
|
308
386
|
config.phaseSelection = PS_ALWAYS_FALSE;
|
|
309
387
|
config.restartStrategy = RS_GEOMETRIC;
|
|
310
388
|
config.restartFactor = 1.5;
|
|
389
|
+
config.isEliminatingBounds = true;
|
|
390
|
+
config.isLiftingNonGroundIte = true;
|
|
311
391
|
config.theories.push(FAMILY_ARITH, FAMILY_ARRAY);
|
|
312
392
|
};
|
|
313
393
|
|
|
394
|
+
const setupAufLiaByFeatures = (config: SmtConfig, features: StaticFeatures) => {
|
|
395
|
+
if (features.hasReal)
|
|
396
|
+
throw new SmtDefaultError(
|
|
397
|
+
"Benchmark has real variables but it is marked as AUFLIA (arrays, uninterpreted functions and linear integer arithmetic).",
|
|
398
|
+
);
|
|
399
|
+
setupAufLia(config);
|
|
400
|
+
};
|
|
401
|
+
|
|
314
402
|
const setupAufLira = (config: SmtConfig) => {
|
|
315
403
|
config.phaseSelection = PS_ALWAYS_FALSE;
|
|
404
|
+
config.isEliminatingBounds = true;
|
|
316
405
|
config.isFindingMacros = true;
|
|
406
|
+
config.isLiftingNonGroundIte = true;
|
|
317
407
|
config.theories.push(FAMILY_ARITH, FAMILY_ARRAY);
|
|
318
408
|
};
|
|
319
409
|
|
|
320
410
|
const setupLra = (config: SmtConfig) => {
|
|
321
411
|
config.relevancyLevel = 0;
|
|
412
|
+
config.isArithPropagatingEqs = false;
|
|
413
|
+
config.isEliminatingTermIte = true;
|
|
322
414
|
config.theories.push(FAMILY_ARITH);
|
|
323
415
|
};
|
|
324
416
|
|
|
325
|
-
// setup_ff, without the finite field theory the port does not have.
|
|
326
417
|
const setupFf = (config: SmtConfig) => {
|
|
327
|
-
config.theories.push(FAMILY_BV);
|
|
418
|
+
config.theories.push(FAMILY_BV, FAMILY_FF);
|
|
328
419
|
};
|
|
329
420
|
|
|
330
421
|
const setupQfBvre = (config: SmtConfig) => {
|
|
@@ -341,7 +432,7 @@ const DEFAULT_SETUPS = new Map<string, (config: SmtConfig) => void>([
|
|
|
341
432
|
["QF_LRA", setupQfLra],
|
|
342
433
|
["QF_LIA", setupQfLia],
|
|
343
434
|
["QF_UFLIA", setupQfUfLia],
|
|
344
|
-
["QF_UFLRA",
|
|
435
|
+
["QF_UFLRA", setupQfUfLra],
|
|
345
436
|
["QF_AX", setupQfAx],
|
|
346
437
|
["QF_AUFLIA", setupQfAufLia],
|
|
347
438
|
["QF_BV", setupQfBv],
|
|
@@ -387,16 +478,18 @@ const setupQuantified = (config: SmtConfig, features: StaticFeatures) => {
|
|
|
387
478
|
config.theories.push(
|
|
388
479
|
FAMILY_DATATYPE,
|
|
389
480
|
FAMILY_BV,
|
|
481
|
+
FAMILY_DATALOG_RELATION,
|
|
390
482
|
FAMILY_SEQ,
|
|
391
483
|
FAMILY_CHAR,
|
|
392
484
|
FAMILY_FINITE_SET,
|
|
393
485
|
FAMILY_FPA,
|
|
486
|
+
FAMILY_FF,
|
|
394
487
|
FAMILY_RECFUN,
|
|
488
|
+
FAMILY_SPECIAL_RELATIONS,
|
|
395
489
|
FAMILY_POLY,
|
|
396
490
|
);
|
|
397
491
|
};
|
|
398
492
|
|
|
399
|
-
// setup_unknown(static_features&), without the finite fields the port does not have.
|
|
400
493
|
const setupUnknownByFeatures = (config: SmtConfig, features: StaticFeatures, setup: SmtSetup) => {
|
|
401
494
|
const hasUf = features.numUninterpretedFunctions > 0;
|
|
402
495
|
const numTheories = features.numTheories + (hasUf ? 1 : 0);
|
|
@@ -417,7 +510,7 @@ const setupUnknownByFeatures = (config: SmtConfig, features: StaticFeatures, set
|
|
|
417
510
|
else setupQfLiaByFeatures(config, features);
|
|
418
511
|
} else if (isTwoWithUf && isArith(features)) {
|
|
419
512
|
if (!features.hasReal && isLinear) setupQfUfLiaByFeatures(config, features);
|
|
420
|
-
else if (!features.hasInt && isLinear)
|
|
513
|
+
else if (!features.hasInt && isLinear) setupQfUfLra(config);
|
|
421
514
|
else setupUnknown(config, features);
|
|
422
515
|
} else if (numTheories === 1 && features.hasBv) setupQfBv(config);
|
|
423
516
|
else if (numTheories === 1 && features.hasFpa) setupQfFp(config);
|
|
@@ -434,20 +527,20 @@ const AUTO_SETUPS = new Map<
|
|
|
434
527
|
string,
|
|
435
528
|
(config: SmtConfig, features: StaticFeatures, setup: SmtSetup) => void
|
|
436
529
|
>([
|
|
437
|
-
["QF_UF",
|
|
530
|
+
["QF_UF", setupQfUfByFeatures],
|
|
438
531
|
["QF_RDL", setupQfRdlByFeatures],
|
|
439
532
|
["QF_IDL", setupQfIdlByFeatures],
|
|
440
533
|
["QF_UFIDL", setupQfUfIdlByFeatures],
|
|
441
534
|
["QF_LRA", setupQfLraByFeatures],
|
|
442
535
|
["QF_LIA", setupQfLiaByFeatures],
|
|
443
536
|
["QF_UFLIA", setupQfUfLiaByFeatures],
|
|
444
|
-
["QF_UFLRA",
|
|
537
|
+
["QF_UFLRA", setupQfUfLra],
|
|
445
538
|
["QF_AX", setupQfAxByFeatures],
|
|
446
539
|
["QF_BVRE", setupQfBvre],
|
|
447
540
|
["QF_AUFLIA", setupQfAufLiaByFeatures],
|
|
448
541
|
["QF_S", setupUnknown],
|
|
449
542
|
["QF_SLIA", setupUnknown],
|
|
450
|
-
["AUFLIA",
|
|
543
|
+
["AUFLIA", setupAufLiaByFeatures],
|
|
451
544
|
["AUFLIRA", setupAufLira],
|
|
452
545
|
["AUFNIRA", setupAufLira],
|
|
453
546
|
["AUFLIA+", setupAufLia],
|