tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5
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 +33 -33
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +17 -3
- package/dist/index.d.ts +17 -3
- 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 +55 -55
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -42
- package/dist/run.js +42 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +96 -91
- package/dist/transfer.js +95 -90
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +12 -10
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +418 -246
- package/src/cli/tlc-output.ts +17 -2
- package/src/cli/tlc.ts +5 -4
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +93 -35
- package/src/environment.ts +106 -39
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +415 -132
- package/src/exit-codes.ts +28 -15
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +674 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +161 -60
- package/src/liveness.ts +55 -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/parser.ts +110 -111
- 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 +164 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +65 -13
- 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 +65 -14
- 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 +3 -9
- 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/fd-solver.ts +608 -141
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +4 -3
- 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-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- 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 +14 -42
- 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 +1 -4
- 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 +4 -5
- package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
- package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
- package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
- 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 +16 -7
- 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 +4 -3
- 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/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 +15 -6
- 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 +1 -1
- 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 +40 -6
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +579 -214
- package/src/prover/smt/solver/smtlib-script.ts +600 -170
- 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 +342 -196
- 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 +1226 -246
- package/src/runtime.ts +19 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +4 -2
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +4 -2
- package/src/sany/generator-expressions.ts +51 -20
- package/src/sany/generator-proofs.ts +17 -11
- package/src/sany/generator.ts +11 -5
- 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 +283 -126
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +563 -139
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +1 -3
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- 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
|
@@ -33,6 +33,13 @@ export abstract class Constraint {
|
|
|
33
33
|
return this.lits.length;
|
|
34
34
|
}
|
|
35
35
|
|
|
36
|
+
getMaxVar() {
|
|
37
|
+
let maxVar = this.lit === NULL_LITERAL ? 0 : this.lit >> 1;
|
|
38
|
+
for (let index = 0; index < this.lits.length; index++)
|
|
39
|
+
maxVar = Math.max(maxVar, this.lits[index] >> 1);
|
|
40
|
+
return maxVar;
|
|
41
|
+
}
|
|
42
|
+
|
|
36
43
|
getCoeff(_index: number) {
|
|
37
44
|
return 1;
|
|
38
45
|
}
|
|
@@ -832,6 +832,24 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
832
832
|
this.numPropagationsSincePop = 0;
|
|
833
833
|
}
|
|
834
834
|
|
|
835
|
+
gcVars(numVars: number) {
|
|
836
|
+
this.gcConstraintVars(numVars, this.constraints);
|
|
837
|
+
this.gcConstraintVars(numVars, this.learned);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
private gcConstraintVars(numVars: number, constraints: Constraint[]) {
|
|
841
|
+
let next = 0;
|
|
842
|
+
for (let index = 0; index < constraints.length; index++) {
|
|
843
|
+
const constraint = constraints[index];
|
|
844
|
+
if (constraint.getMaxVar() >= numVars) {
|
|
845
|
+
constraint.clearWatch(this);
|
|
846
|
+
constraint.nullifyTrackingLiteral(this);
|
|
847
|
+
this.deallocate(constraint);
|
|
848
|
+
} else constraints[next++] = constraint;
|
|
849
|
+
}
|
|
850
|
+
constraints.length = next;
|
|
851
|
+
}
|
|
852
|
+
|
|
835
853
|
popReinit() {
|
|
836
854
|
const toReinit = this.constraintToReinit;
|
|
837
855
|
let size = this.constraintToReinitLastSize;
|
|
@@ -1443,7 +1461,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1443
1461
|
private convertPbWlits(expr: number): WLits {
|
|
1444
1462
|
const manager = this.manager;
|
|
1445
1463
|
const lits = this.convertPbArgs(expr);
|
|
1446
|
-
const coeffs = lits.map((
|
|
1464
|
+
const coeffs = lits.map((_value, index) =>
|
|
1447
1465
|
this.checkUnsigned(getPbCoeff(manager, manager.decls[expr], index)),
|
|
1448
1466
|
);
|
|
1449
1467
|
return { coeffs, lits };
|
|
@@ -1470,7 +1488,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1470
1488
|
k = k.add(Rational.of(BigInt(wlits.coeffs[index])));
|
|
1471
1489
|
}
|
|
1472
1490
|
const bound = this.checkUnsigned(k);
|
|
1473
|
-
if (isRoot) {
|
|
1491
|
+
if (isRoot && this.solver.numUserScopes === 0) {
|
|
1474
1492
|
this.addRootPbGe(wlits, bound, isSign);
|
|
1475
1493
|
return NULL_LITERAL;
|
|
1476
1494
|
}
|
|
@@ -1482,7 +1500,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1482
1500
|
private convertPbGe(expr: number, isRoot: boolean, isSign: boolean) {
|
|
1483
1501
|
const bound = this.checkUnsigned(getPbK(this.manager, this.manager.decls[expr]));
|
|
1484
1502
|
const wlits = this.convertPbWlits(expr);
|
|
1485
|
-
if (isRoot) {
|
|
1503
|
+
if (isRoot && this.solver.numUserScopes === 0) {
|
|
1486
1504
|
this.addRootPbGe(wlits, bound, isSign);
|
|
1487
1505
|
return NULL_LITERAL;
|
|
1488
1506
|
}
|
|
@@ -1495,7 +1513,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1495
1513
|
const solver = this.solver;
|
|
1496
1514
|
let k = getPbK(this.manager, this.manager.decls[expr]);
|
|
1497
1515
|
const wlits = this.convertPbWlits(expr);
|
|
1498
|
-
const isBaseAssert = isRoot && !isSign;
|
|
1516
|
+
const isBaseAssert = isRoot && !isSign && solver.numUserScopes === 0;
|
|
1499
1517
|
const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
|
|
1500
1518
|
const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
|
|
1501
1519
|
this.addPbGe(lit1, wlits, Number(BigInt.asUintN(32, k.num)), false);
|
|
@@ -1528,7 +1546,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1528
1546
|
private convertAtLeastK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
|
|
1529
1547
|
const lits = this.convertPbArgs(expr);
|
|
1530
1548
|
let bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
|
|
1531
|
-
if (isRoot) {
|
|
1549
|
+
if (isRoot && this.solver.numUserScopes === 0) {
|
|
1532
1550
|
if (isSign) {
|
|
1533
1551
|
for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
|
|
1534
1552
|
bound = lits.length + 1 - bound;
|
|
@@ -1547,7 +1565,7 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1547
1565
|
for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
|
|
1548
1566
|
const bound1 = k.compare(Rational.of(BigInt(lits.length))) >= 0 ? lits.length : Number(k.num);
|
|
1549
1567
|
let bound = lits.length - bound1;
|
|
1550
|
-
if (isRoot) {
|
|
1568
|
+
if (isRoot && this.solver.numUserScopes === 0) {
|
|
1551
1569
|
if (isSign) {
|
|
1552
1570
|
for (let index = 0; index < lits.length; index++) lits[index] ^= 1;
|
|
1553
1571
|
bound = lits.length + 1 - bound;
|
|
@@ -1564,7 +1582,8 @@ export class PbSolver implements SatExtension, ConstraintHost {
|
|
|
1564
1582
|
private convertEqK(expr: number, k: Rational, isRoot: boolean, isSign: boolean) {
|
|
1565
1583
|
const solver = this.solver;
|
|
1566
1584
|
const lits = this.convertPbArgs(expr);
|
|
1567
|
-
|
|
1585
|
+
// Deviation from Z3: convert_eq_k asserts at the base level in a user scope too, so the constraint outlives the pop.
|
|
1586
|
+
const isBaseAssert = isRoot && !isSign && solver.numUserScopes === 0;
|
|
1568
1587
|
const lit1 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
|
|
1569
1588
|
const lit2 = isBaseAssert ? NULL_LITERAL : 2 * solver.mkVar(true);
|
|
1570
1589
|
const bound = k.compare(Rational.of(BigInt(lits.length))) > 0 ? lits.length + 1 : Number(k.num);
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { SmtTacticError } from "../../../../errors";
|
|
1
|
+
import { SmtCanceledError, SmtTacticError } from "../../../../errors";
|
|
2
2
|
import type { AstManager } from "../ast";
|
|
3
3
|
import type { ThSolverFactory } from "../euf/euf-solver";
|
|
4
4
|
import { OVER, type Goal } from "../goal";
|
|
@@ -6,7 +6,7 @@ import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
|
|
|
6
6
|
import { ProtoModel } from "../proto-model";
|
|
7
7
|
import type { SatParams } from "./config";
|
|
8
8
|
import { Goal2Sat } from "./goal2sat";
|
|
9
|
-
import { sat2goal } from "./sat2goal";
|
|
9
|
+
import { Sat2GoalConverter, sat2goal } from "./sat2goal";
|
|
10
10
|
import { Solver } from "./solver";
|
|
11
11
|
|
|
12
12
|
// With a theory factory, the sat solver runs the euf solver of sat.euf as its extension.
|
|
@@ -19,12 +19,19 @@ export const createSatTactic =
|
|
|
19
19
|
const goal2sat = new Goal2Sat(manager, solver, params.get("ite_extra") !== false, mkThSolver);
|
|
20
20
|
goal2sat.run(goal.forms.items);
|
|
21
21
|
goal.reset();
|
|
22
|
-
const result =
|
|
22
|
+
const result = (() => {
|
|
23
|
+
try {
|
|
24
|
+
return solver.check();
|
|
25
|
+
} catch (error) {
|
|
26
|
+
if (error instanceof SmtCanceledError) throw new SmtTacticError("canceled");
|
|
27
|
+
throw error;
|
|
28
|
+
}
|
|
29
|
+
})();
|
|
23
30
|
if (result === L_UNDEF) goal.reasonUnknown = solver.reasonUnknown;
|
|
24
31
|
const unhandledFuns = goal2sat.euf?.unhandledFunctions ?? goal2sat.unhandledFuns;
|
|
25
32
|
if (result === L_FALSE) goal.assert(manager.falseExpr);
|
|
26
33
|
else if (result === L_TRUE && unhandledFuns.length === 0) {
|
|
27
|
-
const model = new ProtoModel(manager);
|
|
34
|
+
const model = new ProtoModel(manager).mkModel();
|
|
28
35
|
for (const [expr, boolVar] of goal2sat.atoms) {
|
|
29
36
|
if (!manager.isUninterpretedConst(expr)) continue;
|
|
30
37
|
const value = solver.model[boolVar];
|
|
@@ -32,11 +39,13 @@ export const createSatTactic =
|
|
|
32
39
|
else if (value === L_FALSE) model.registerConst(manager.decls[expr], manager.falseExpr);
|
|
33
40
|
}
|
|
34
41
|
const euf = goal2sat.euf;
|
|
35
|
-
goal.model =
|
|
42
|
+
goal.model = euf?.updateModel(model) ?? model;
|
|
36
43
|
euf?.validateModel(goal.model);
|
|
37
44
|
} else {
|
|
38
45
|
solver.popToBaseLevel();
|
|
39
|
-
|
|
46
|
+
const converter = new Sat2GoalConverter(manager);
|
|
47
|
+
sat2goal(manager, solver, goal2sat.atoms, goal, converter);
|
|
48
|
+
goal.addDefinitions(converter.entries);
|
|
40
49
|
if (unhandledFuns.length > 0) goal.updatePrecision(OVER);
|
|
41
50
|
}
|
|
42
51
|
goal.depth++;
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { SmtCanceledError } from "../../../../errors";
|
|
2
2
|
import { type AstManager, SORT_BOOL } from "../ast";
|
|
3
3
|
import type { Definition, Goal } from "../goal";
|
|
4
|
+
import { RefVector } from "../ref-vector";
|
|
4
5
|
import { NULL_LITERAL } from "./clause";
|
|
5
6
|
import { ModelConverter } from "./model-converter";
|
|
6
7
|
import type { Solver } from "./solver";
|
|
@@ -12,28 +13,32 @@ export const isLiteral = (manager: AstManager, expr: number) =>
|
|
|
12
13
|
manager.isUninterpretedConst(expr) ||
|
|
13
14
|
(manager.isNot(expr) && manager.isUninterpretedConst(manager.getArg(expr, 0)));
|
|
14
15
|
|
|
15
|
-
class Sat2GoalConverter {
|
|
16
|
+
export class Sat2GoalConverter {
|
|
16
17
|
readonly smc = new ModelConverter();
|
|
17
|
-
var2expr:
|
|
18
|
-
|
|
18
|
+
readonly var2expr: RefVector;
|
|
19
|
+
entries: Definition[] = [];
|
|
19
20
|
|
|
20
|
-
constructor(private manager: AstManager) {
|
|
21
|
+
constructor(private manager: AstManager) {
|
|
22
|
+
this.var2expr = new RefVector(manager);
|
|
23
|
+
}
|
|
21
24
|
|
|
22
25
|
private add(expr: number, def: number) {
|
|
23
26
|
const manager = this.manager;
|
|
24
27
|
manager.incRef(def);
|
|
28
|
+
manager.incDeclRef(manager.decls[expr]);
|
|
25
29
|
this.entries.push({ decl: manager.decls[expr], def });
|
|
26
30
|
}
|
|
27
31
|
|
|
28
32
|
hide(expr: number) {
|
|
29
|
-
|
|
33
|
+
const manager = this.manager;
|
|
34
|
+
manager.incDeclRef(manager.decls[expr]);
|
|
35
|
+
this.entries.push({ decl: manager.decls[expr], def: -1 });
|
|
30
36
|
}
|
|
31
37
|
|
|
32
38
|
flushSmc(solver: Solver, atoms: Map<number, number>) {
|
|
33
39
|
this.smc.flush(solver.mc);
|
|
34
|
-
this.var2expr.
|
|
35
|
-
this.var2expr.
|
|
36
|
-
for (const [expr, boolVar] of atoms) this.var2expr[boolVar] = expr;
|
|
40
|
+
this.var2expr.resize(solver.numVars());
|
|
41
|
+
for (const [expr, boolVar] of atoms) this.var2expr.set(boolVar, expr);
|
|
37
42
|
this.flushGmc();
|
|
38
43
|
}
|
|
39
44
|
|
|
@@ -82,21 +87,39 @@ class Sat2GoalConverter {
|
|
|
82
87
|
}
|
|
83
88
|
|
|
84
89
|
insert(boolVar: number, atom: number) {
|
|
85
|
-
|
|
86
|
-
this.var2expr
|
|
90
|
+
if (this.var2expr.size <= boolVar) this.var2expr.resize(boolVar + 1);
|
|
91
|
+
this.var2expr.set(boolVar, atom);
|
|
87
92
|
if (this.manager.isUninterpretedConst(atom)) this.hide(atom);
|
|
88
93
|
}
|
|
89
94
|
|
|
95
|
+
copyEntries() {
|
|
96
|
+
const manager = this.manager;
|
|
97
|
+
for (const entry of this.entries) {
|
|
98
|
+
manager.incDeclRef(entry.decl);
|
|
99
|
+
if (entry.def !== -1) manager.incRef(entry.def);
|
|
100
|
+
}
|
|
101
|
+
return [...this.entries];
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
release() {
|
|
105
|
+
const manager = this.manager;
|
|
106
|
+
this.var2expr.reset();
|
|
107
|
+
for (const entry of this.entries) {
|
|
108
|
+
if (entry.def !== -1) manager.decRef(entry.def);
|
|
109
|
+
manager.decDeclRef(entry.decl);
|
|
110
|
+
}
|
|
111
|
+
this.entries = [];
|
|
112
|
+
}
|
|
113
|
+
|
|
90
114
|
private lit2expr(lit: number) {
|
|
91
115
|
const manager = this.manager;
|
|
92
116
|
const boolVar = lit >> 1;
|
|
93
|
-
if (this.var2expr[boolVar] === -1) {
|
|
117
|
+
if (this.var2expr.items[boolVar] === -1) {
|
|
94
118
|
const aux = manager.mkFreshConst(null, SORT_BOOL);
|
|
95
|
-
|
|
96
|
-
this.var2expr[boolVar] = aux;
|
|
119
|
+
this.var2expr.set(boolVar, aux);
|
|
97
120
|
this.hide(aux);
|
|
98
121
|
}
|
|
99
|
-
const expr = this.var2expr[boolVar];
|
|
122
|
+
const expr = this.var2expr.items[boolVar];
|
|
100
123
|
return (lit & 1) === 1 ? manager.mkNot(expr) : expr;
|
|
101
124
|
}
|
|
102
125
|
}
|
|
@@ -106,60 +129,61 @@ export const sat2goal = (
|
|
|
106
129
|
solver: Solver,
|
|
107
130
|
atoms: Map<number, number>,
|
|
108
131
|
goal: Goal,
|
|
132
|
+
converter: Sat2GoalConverter,
|
|
109
133
|
) => {
|
|
110
134
|
if (solver.atBaseLvl() && solver.isInconsistent) {
|
|
111
135
|
goal.assert(manager.falseExpr);
|
|
112
136
|
return;
|
|
113
137
|
}
|
|
114
|
-
const converter = new Sat2GoalConverter(manager);
|
|
115
138
|
converter.flushSmc(solver, atoms);
|
|
116
|
-
const lit2expr = new
|
|
139
|
+
const lit2expr = new RefVector(manager);
|
|
140
|
+
lit2expr.resize(2 * solver.numVars());
|
|
117
141
|
for (const [expr, boolVar] of atoms) {
|
|
118
|
-
lit2expr
|
|
119
|
-
lit2expr
|
|
120
|
-
manager.incRef(lit2expr[2 * boolVar + 1]);
|
|
142
|
+
lit2expr.set(2 * boolVar, expr);
|
|
143
|
+
lit2expr.set(2 * boolVar + 1, mkNot(manager, expr));
|
|
121
144
|
}
|
|
122
145
|
const getExpr = (lit: number) => {
|
|
123
|
-
if (lit2expr[lit] === -1) {
|
|
146
|
+
if (lit2expr.items[lit] === -1) {
|
|
124
147
|
const boolVar = lit >> 1;
|
|
125
|
-
let aux = converter.var2expr[boolVar] ?? -1;
|
|
148
|
+
let aux = converter.var2expr.items[boolVar] ?? -1;
|
|
126
149
|
if (aux === -1) {
|
|
127
150
|
aux = manager.mkFreshConst(null, SORT_BOOL);
|
|
128
|
-
manager.incRef(aux);
|
|
129
151
|
converter.insert(boolVar, aux);
|
|
130
152
|
}
|
|
131
|
-
lit2expr
|
|
132
|
-
lit2expr
|
|
133
|
-
manager.incRef(lit2expr[2 * boolVar + 1]);
|
|
153
|
+
lit2expr.set(2 * boolVar, aux);
|
|
154
|
+
lit2expr.set(2 * boolVar + 1, mkNot(manager, aux));
|
|
134
155
|
}
|
|
135
|
-
return lit2expr[lit];
|
|
156
|
+
return lit2expr.items[lit];
|
|
136
157
|
};
|
|
137
158
|
const checkpoint = () => {
|
|
138
159
|
if (!manager.limit.inc()) throw new SmtCanceledError();
|
|
139
160
|
};
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
goal.assert(getExpr(solver.trail[index]));
|
|
144
|
-
}
|
|
145
|
-
for (let index = 0; index < solver.watches.length; index++) {
|
|
146
|
-
const first = index ^ 1;
|
|
147
|
-
const wlist = solver.watches[index];
|
|
148
|
-
for (let position = 0; position < wlist.size; position++) {
|
|
149
|
-
if (!wlist.isBinary(position) || wlist.isLearned(position)) continue;
|
|
150
|
-
const second = wlist.getLiteral(position);
|
|
151
|
-
if (first > second) continue;
|
|
161
|
+
try {
|
|
162
|
+
const trailSize = solver.initTrailSize();
|
|
163
|
+
for (let index = 0; index < trailSize; index++) {
|
|
152
164
|
checkpoint();
|
|
153
|
-
goal.assert(
|
|
165
|
+
goal.assert(getExpr(solver.trail[index]));
|
|
154
166
|
}
|
|
167
|
+
for (let index = 0; index < solver.watches.length; index++) {
|
|
168
|
+
const first = index ^ 1;
|
|
169
|
+
const wlist = solver.watches[index];
|
|
170
|
+
for (let position = 0; position < wlist.size; position++) {
|
|
171
|
+
if (!wlist.isBinary(position) || wlist.isLearned(position)) continue;
|
|
172
|
+
const second = wlist.getLiteral(position);
|
|
173
|
+
if (first > second) continue;
|
|
174
|
+
checkpoint();
|
|
175
|
+
goal.assert(manager.mkOr([getExpr(first), getExpr(second)]));
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
const arena = solver.arena;
|
|
179
|
+
for (const clause of solver.clauses) {
|
|
180
|
+
checkpoint();
|
|
181
|
+
goal.assert(manager.mkOr(arena.getLits(clause).map(getExpr)));
|
|
182
|
+
}
|
|
183
|
+
const formulas: number[] = [];
|
|
184
|
+
solver.ext?.toFormulas(getExpr, formulas);
|
|
185
|
+
for (const formula of formulas) goal.assert(formula);
|
|
186
|
+
} finally {
|
|
187
|
+
lit2expr.reset();
|
|
155
188
|
}
|
|
156
|
-
const arena = solver.arena;
|
|
157
|
-
for (const clause of solver.clauses) {
|
|
158
|
-
checkpoint();
|
|
159
|
-
goal.assert(manager.mkOr(arena.getLits(clause).map(getExpr)));
|
|
160
|
-
}
|
|
161
|
-
const formulas: number[] = [];
|
|
162
|
-
solver.ext?.toFormulas(getExpr, formulas);
|
|
163
|
-
for (const formula of formulas) goal.assert(formula);
|
|
164
|
-
goal.addDefinitions(converter.entries);
|
|
165
189
|
};
|
|
@@ -1270,7 +1270,7 @@ export class Simplifier {
|
|
|
1270
1270
|
for (const wlist of solver.watches) {
|
|
1271
1271
|
solver.checkpoint();
|
|
1272
1272
|
const size = wlist.size;
|
|
1273
|
-
const order = Array.from({ length: size }, (
|
|
1273
|
+
const order = Array.from({ length: size }, (_value, index) => index);
|
|
1274
1274
|
const getRank = (index: number) =>
|
|
1275
1275
|
wlist.isBinary(index)
|
|
1276
1276
|
? 2 * wlist.getLiteral(index) + (wlist.isLearned(index) ? 1 : 0)
|
|
@@ -59,6 +59,7 @@ export interface SatExtension {
|
|
|
59
59
|
pop(numScopes: number): void;
|
|
60
60
|
userPush?(): void;
|
|
61
61
|
userPop?(numScopes: number): void;
|
|
62
|
+
gcVars?(numVars: number): void;
|
|
62
63
|
popReinit(): void;
|
|
63
64
|
simplify(): void;
|
|
64
65
|
gc(): void;
|
|
@@ -74,7 +75,7 @@ const RANDOM_MAX_VALUE = 0x7fff;
|
|
|
74
75
|
const S_SAT = 0;
|
|
75
76
|
const S_UNSAT = 1;
|
|
76
77
|
|
|
77
|
-
|
|
78
|
+
class Ema {
|
|
78
79
|
private beta = 1;
|
|
79
80
|
value = 0;
|
|
80
81
|
private period = 0;
|
|
@@ -139,7 +140,6 @@ export class Solver {
|
|
|
139
140
|
model = new Int8Array(0);
|
|
140
141
|
isModelCurrent = false;
|
|
141
142
|
isInconsistent = false;
|
|
142
|
-
isSearching = false;
|
|
143
143
|
conflictJustLevel = 0;
|
|
144
144
|
conflictLevel = 0;
|
|
145
145
|
conflictVal = 0;
|
|
@@ -147,7 +147,6 @@ export class Solver {
|
|
|
147
147
|
notL = NULL_LITERAL;
|
|
148
148
|
clauses: number[] = [];
|
|
149
149
|
learned: number[] = [];
|
|
150
|
-
numFrozen = 0;
|
|
151
150
|
watches: WatchList[] = [];
|
|
152
151
|
assignment = new Int8Array(16);
|
|
153
152
|
justLevel = new Uint32Array(8);
|
|
@@ -196,7 +195,6 @@ export class Solver {
|
|
|
196
195
|
scopes: Scope[] = [];
|
|
197
196
|
core: number[] = [];
|
|
198
197
|
conflicts = 0;
|
|
199
|
-
decisions = 0;
|
|
200
198
|
conflictsSinceInit = 0;
|
|
201
199
|
restarts = 0;
|
|
202
200
|
conflictsSinceRestart = 0;
|
|
@@ -392,7 +390,6 @@ export class Solver {
|
|
|
392
390
|
}
|
|
393
391
|
|
|
394
392
|
delClause(clause: number) {
|
|
395
|
-
if (this.arena.isFrozen(clause)) this.numFrozen--;
|
|
396
393
|
this.arena.delClause(clause);
|
|
397
394
|
}
|
|
398
395
|
|
|
@@ -879,38 +876,33 @@ export class Solver {
|
|
|
879
876
|
check(assumptions: readonly number[] = []) {
|
|
880
877
|
this.reasonUnknown = "no reason given";
|
|
881
878
|
this.popToBaseLevel();
|
|
882
|
-
this.isSearching = true;
|
|
883
879
|
this.isGivenUp = false;
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
880
|
+
this.initSearch();
|
|
881
|
+
if (this.checkInconsistent()) return L_FALSE;
|
|
882
|
+
this.propagate(false);
|
|
883
|
+
if (this.checkInconsistent()) return L_FALSE;
|
|
884
|
+
this.initAssumptions(assumptions);
|
|
885
|
+
this.propagate(false);
|
|
886
|
+
if (this.checkInconsistent()) return L_FALSE;
|
|
887
|
+
if (this.config.isForcingCleanup) this.doCleanup(true);
|
|
888
|
+
if (this.config.isGcBurst) {
|
|
889
|
+
this.conflictsSinceGc = this.gcThreshold + 1;
|
|
890
|
+
this.doGc();
|
|
891
|
+
}
|
|
892
|
+
if (this.config.isEnablingPreSimplify) {
|
|
893
|
+
this.doSimplify();
|
|
891
894
|
if (this.checkInconsistent()) return L_FALSE;
|
|
892
|
-
if (this.config.isForcingCleanup) this.doCleanup(true);
|
|
893
|
-
if (this.config.isGcBurst) {
|
|
894
|
-
this.conflictsSinceGc = this.gcThreshold + 1;
|
|
895
|
-
this.doGc();
|
|
896
|
-
}
|
|
897
|
-
if (this.config.isEnablingPreSimplify) {
|
|
898
|
-
this.doSimplify();
|
|
899
|
-
if (this.checkInconsistent()) return L_FALSE;
|
|
900
|
-
}
|
|
901
|
-
if (this.config.maxConflicts === 0) return L_UNDEF;
|
|
902
|
-
if (this.config.maxConflicts > 0 && this.config.burstSearch > 0) {
|
|
903
|
-
this.restartThreshold = this.config.burstSearch;
|
|
904
|
-
const result = this.boundedSearch();
|
|
905
|
-
if (result !== L_UNDEF || this.isGivenUp) return result;
|
|
906
|
-
this.popReinit(this.scopeLvl);
|
|
907
|
-
this.conflictsSinceRestart = 0;
|
|
908
|
-
this.restartThreshold = this.config.restartInitial;
|
|
909
|
-
}
|
|
910
|
-
return this.basicSearch();
|
|
911
|
-
} finally {
|
|
912
|
-
this.isSearching = false;
|
|
913
895
|
}
|
|
896
|
+
if (this.config.maxConflicts === 0) return L_UNDEF;
|
|
897
|
+
if (this.config.maxConflicts > 0 && this.config.burstSearch > 0) {
|
|
898
|
+
this.restartThreshold = this.config.burstSearch;
|
|
899
|
+
const result = this.boundedSearch();
|
|
900
|
+
if (result !== L_UNDEF || this.isGivenUp) return result;
|
|
901
|
+
this.popReinit(this.scopeLvl);
|
|
902
|
+
this.conflictsSinceRestart = 0;
|
|
903
|
+
this.restartThreshold = this.config.restartInitial;
|
|
904
|
+
}
|
|
905
|
+
return this.basicSearch();
|
|
914
906
|
}
|
|
915
907
|
|
|
916
908
|
checkInconsistent() {
|
|
@@ -1126,7 +1118,6 @@ export class Solver {
|
|
|
1126
1118
|
const next = this.nextVar();
|
|
1127
1119
|
if (next === -1) return false;
|
|
1128
1120
|
this.push();
|
|
1129
|
-
this.decisions++;
|
|
1130
1121
|
this.assignScoped(2 * next + (this.guess(next) ? 0 : 1));
|
|
1131
1122
|
return true;
|
|
1132
1123
|
}
|
|
@@ -1885,6 +1876,7 @@ export class Solver {
|
|
|
1885
1876
|
};
|
|
1886
1877
|
gcClauses(this.learned);
|
|
1887
1878
|
gcClauses(this.clauses);
|
|
1879
|
+
this.ext?.gcVars?.(maxVar);
|
|
1888
1880
|
let next = 0;
|
|
1889
1881
|
for (const lit of this.trail) if (lit >> 1 < maxVar) this.trail[next++] = lit;
|
|
1890
1882
|
this.trail.length = next;
|
|
@@ -1932,16 +1924,6 @@ export class Solver {
|
|
|
1932
1924
|
this.activityInc >>>= 14;
|
|
1933
1925
|
}
|
|
1934
1926
|
|
|
1935
|
-
numClauses() {
|
|
1936
|
-
let numClauses = this.trail.length;
|
|
1937
|
-
for (let lit = 0; lit < this.watches.length; lit++) {
|
|
1938
|
-
const wlist = this.watches[lit];
|
|
1939
|
-
for (let index = 0; index < wlist.size; index++)
|
|
1940
|
-
if (wlist.isBinary(index) && (lit ^ 1) < wlist.getLiteral(index)) numClauses++;
|
|
1941
|
-
}
|
|
1942
|
-
return numClauses + this.clauses.length + this.learned.length;
|
|
1943
|
-
}
|
|
1944
|
-
|
|
1945
1927
|
doCleanup(isForced: boolean) {
|
|
1946
1928
|
if (this.conflictsSinceInit === 0 && !isForced) return false;
|
|
1947
1929
|
return this.atBaseLvl() && !this.isInconsistent && this.cleaner.run(isForced);
|
|
@@ -2063,12 +2045,10 @@ export class Solver {
|
|
|
2063
2045
|
this.detachClause(clause);
|
|
2064
2046
|
arena.inactRounds[clause] = 0;
|
|
2065
2047
|
arena.setFrozen(clause, true);
|
|
2066
|
-
this.numFrozen++;
|
|
2067
2048
|
}
|
|
2068
2049
|
}
|
|
2069
2050
|
} else if (this.psm(clause) <= Math.trunc(arena.size[clause] * this.minDTk)) {
|
|
2070
2051
|
arena.setFrozen(clause, false);
|
|
2071
|
-
this.numFrozen--;
|
|
2072
2052
|
if (!this.activateFrozenClause(clause)) {
|
|
2073
2053
|
this.delClause(clause);
|
|
2074
2054
|
continue;
|
|
@@ -1,4 +1,3 @@
|
|
|
1
|
-
import { SmtUnsupportedError } from "../../../errors";
|
|
2
1
|
import {
|
|
3
2
|
type AstManager,
|
|
4
3
|
FAMILY_ARITH,
|
|
@@ -24,7 +23,6 @@ import {
|
|
|
24
23
|
OP_SEQ_PREFIX,
|
|
25
24
|
OP_SEQ_UNIT,
|
|
26
25
|
OP_STRING_FROM_CODE,
|
|
27
|
-
OP_STRING_ITOS,
|
|
28
26
|
OP_STRING_LT,
|
|
29
27
|
OP_STRING_STOI,
|
|
30
28
|
OP_STRING_TO_CODE,
|
|
@@ -36,7 +34,7 @@ import { FALSE_LITERAL, type Literal, TRUE_LITERAL, negate } from "./literal";
|
|
|
36
34
|
import { isBinaryApp, isEmptySeq, mkConcatOf, mkEmptySeq, mkSeqApp } from "./seq-decl-plugin";
|
|
37
35
|
import { SeqSkolem } from "./seq-skolem";
|
|
38
36
|
|
|
39
|
-
|
|
37
|
+
interface SeqAxiomsHost {
|
|
40
38
|
rewrite(expr: number): number;
|
|
41
39
|
mkEqLiteral(first: number, second: number): Literal;
|
|
42
40
|
ensureEnode(expr: number): void;
|
|
@@ -62,7 +60,7 @@ export const getMinLengthOf = (manager: AstManager, seq: number): number => {
|
|
|
62
60
|
|
|
63
61
|
const UINT_MAX = 0xffffffff;
|
|
64
62
|
|
|
65
|
-
|
|
63
|
+
const getMaxLengthOf = (manager: AstManager, seq: number): number => {
|
|
66
64
|
const getLength = (expr: number) => {
|
|
67
65
|
if (isEmptySeq(manager, expr)) return 0;
|
|
68
66
|
const op = manager.getOp(expr);
|
|
@@ -180,13 +178,8 @@ export class SeqAxioms {
|
|
|
180
178
|
return result;
|
|
181
179
|
}
|
|
182
180
|
|
|
183
|
-
|
|
184
|
-
return this.host.rewrite(this.mkSeq(OP_SEQ_LENGTH, [seq]));
|
|
185
|
-
}
|
|
186
|
-
|
|
187
|
-
private purify(expr: number | undefined) {
|
|
181
|
+
private purify(expr: number) {
|
|
188
182
|
const manager = this.manager;
|
|
189
|
-
if (expr === undefined) return undefined;
|
|
190
183
|
if (manager.depths[expr] === 1 || manager.isValue(expr)) return expr;
|
|
191
184
|
if (this.host.rewrite(expr) === expr) return expr;
|
|
192
185
|
let result = this.purified.get(expr);
|
|
@@ -256,9 +249,9 @@ export class SeqAxioms {
|
|
|
256
249
|
extractAxiom(expr: number) {
|
|
257
250
|
const manager = this.manager;
|
|
258
251
|
const [seqArg, indexArg, lengthArg] = manager.getArgs(expr);
|
|
259
|
-
const seq = this.purify(seqArg)
|
|
260
|
-
const index = this.purify(indexArg)
|
|
261
|
-
const length = this.purify(lengthArg)
|
|
252
|
+
const seq = this.purify(seqArg);
|
|
253
|
+
const index = this.purify(indexArg);
|
|
254
|
+
const length = this.purify(lengthArg);
|
|
262
255
|
if (this.smallSegmentAxiom(expr, seqArg, indexArg, lengthArg)) return;
|
|
263
256
|
if (this.isTail(seq, indexArg, lengthArg)) {
|
|
264
257
|
this.tailAxiom(expr, seq);
|
|
@@ -436,9 +429,9 @@ export class SeqAxioms {
|
|
|
436
429
|
const args = manager.getArgs(index);
|
|
437
430
|
const minusOne = this.mkInt(-1);
|
|
438
431
|
const zero = this.mkInt(0);
|
|
439
|
-
const offset = this.purify(args[2]);
|
|
440
|
-
const pattern = this.purify(args[1])
|
|
441
|
-
const text = this.purify(args[0])
|
|
432
|
+
const offset = args.length > 2 ? this.purify(args[2]) : undefined;
|
|
433
|
+
const pattern = this.purify(args[1]);
|
|
434
|
+
const text = this.purify(args[0]);
|
|
442
435
|
const contains = this.mkSeq(OP_SEQ_CONTAINS, [text, pattern]);
|
|
443
436
|
const isMinusOne = this.mkEq(index, minusOne);
|
|
444
437
|
const isZero = this.mkEq(index, zero);
|
|
@@ -511,8 +504,8 @@ export class SeqAxioms {
|
|
|
511
504
|
lastIndexofAxiom(index: number) {
|
|
512
505
|
const manager = this.manager;
|
|
513
506
|
const [textArg, patternArg] = manager.getArgs(index);
|
|
514
|
-
const text = this.purify(textArg)
|
|
515
|
-
const pattern = this.purify(patternArg)
|
|
507
|
+
const text = this.purify(textArg);
|
|
508
|
+
const pattern = this.purify(patternArg);
|
|
516
509
|
const minusOne = this.mkInt(-1);
|
|
517
510
|
const zero = this.mkInt(0);
|
|
518
511
|
const skolem = this.skolem;
|
|
@@ -539,9 +532,9 @@ export class SeqAxioms {
|
|
|
539
532
|
replaceAxiom(replace: number) {
|
|
540
533
|
const manager = this.manager;
|
|
541
534
|
const [source, patternArg, targetArg] = manager.getArgs(replace);
|
|
542
|
-
const text = this.purify(source)
|
|
543
|
-
const pattern = this.purify(patternArg)
|
|
544
|
-
const target = this.purify(targetArg)
|
|
535
|
+
const text = this.purify(source);
|
|
536
|
+
const pattern = this.purify(patternArg);
|
|
537
|
+
const target = this.purify(targetArg);
|
|
545
538
|
const skolem = this.skolem;
|
|
546
539
|
const left = skolem.mkIndexofLeft(text, pattern);
|
|
547
540
|
const right = skolem.mkIndexofRight(text, pattern);
|
|
@@ -565,8 +558,8 @@ export class SeqAxioms {
|
|
|
565
558
|
atAxiom(expr: number) {
|
|
566
559
|
const manager = this.manager;
|
|
567
560
|
const [seqArg, indexArg] = manager.getArgs(expr);
|
|
568
|
-
const seq = this.purify(seqArg)
|
|
569
|
-
const index = this.purify(indexArg)
|
|
561
|
+
const seq = this.purify(seqArg);
|
|
562
|
+
const index = this.purify(indexArg);
|
|
570
563
|
this.mkInt(0);
|
|
571
564
|
const one = this.mkInt(1);
|
|
572
565
|
const empty = this.mkEmpty(manager.sorts[expr]);
|
|
@@ -747,8 +740,8 @@ export class SeqAxioms {
|
|
|
747
740
|
ltAxiom(expr: number) {
|
|
748
741
|
const manager = this.manager;
|
|
749
742
|
const [firstArg, secondArg] = manager.getArgs(expr);
|
|
750
|
-
const first = this.purify(firstArg)
|
|
751
|
-
const second = this.purify(secondArg)
|
|
743
|
+
const first = this.purify(firstArg);
|
|
744
|
+
const second = this.purify(secondArg);
|
|
752
745
|
const charSort = manager.getSeqElementSort(manager.sorts[first]);
|
|
753
746
|
const lt = expr;
|
|
754
747
|
const gt = this.mkSeq(OP_STRING_LT, [second, first]);
|
|
@@ -895,8 +888,8 @@ export class SeqAxioms {
|
|
|
895
888
|
private affixAxiom(expr: number, name: string, isPrefix: boolean) {
|
|
896
889
|
const manager = this.manager;
|
|
897
890
|
const [firstArg, secondArg] = manager.getArgs(expr);
|
|
898
|
-
const first = this.purify(firstArg)
|
|
899
|
-
const second = this.purify(secondArg)
|
|
891
|
+
const first = this.purify(firstArg);
|
|
892
|
+
const second = this.purify(secondArg);
|
|
900
893
|
const firstLength = this.mkLenAxiom(first);
|
|
901
894
|
const secondLength = this.mkLenAxiom(second);
|
|
902
895
|
const isLonger = this.mkGe(this.mkSub(firstLength, secondLength), 1);
|
|
@@ -999,12 +992,4 @@ export class SeqAxioms {
|
|
|
999
992
|
this.addClause([this.mkNot(tracker), this.mkLe(this.mkLenAxiom(target), limit)]);
|
|
1000
993
|
return tracker;
|
|
1001
994
|
}
|
|
1002
|
-
|
|
1003
|
-
ubvAxiom(): never {
|
|
1004
|
-
throw new SmtUnsupportedError("str.from_ubv in the theory of sequences");
|
|
1005
|
-
}
|
|
1006
|
-
|
|
1007
|
-
isItos(expr: number) {
|
|
1008
|
-
return this.manager.getOp(expr) === OP_STRING_ITOS;
|
|
1009
|
-
}
|
|
1010
995
|
}
|
|
@@ -271,7 +271,7 @@ const SEQ_VARIANTS = new Map([
|
|
|
271
271
|
[OP_INTERNAL_STRING_SUBSTR, OP_SEQ_EXTRACT],
|
|
272
272
|
]);
|
|
273
273
|
|
|
274
|
-
const STRING_VARIANTS = new Map([...SEQ_VARIANTS].map((
|
|
274
|
+
const STRING_VARIANTS = new Map([...SEQ_VARIANTS].map((entry) => [entry[1], entry[0]]));
|
|
275
275
|
|
|
276
276
|
const getPsig = (op: number) => {
|
|
277
277
|
const sig = SIGS.get(op);
|
|
@@ -63,7 +63,7 @@ import {
|
|
|
63
63
|
import { type ReRewriter, getResultExpr } from "./seq-re-rewriter";
|
|
64
64
|
|
|
65
65
|
export const DERIVATIVE_ANTIMIROV = 0;
|
|
66
|
-
|
|
66
|
+
const DERIVATIVE_BRZOZOWSKI = 1;
|
|
67
67
|
export const TRANSITION_BRZOZOWSKI = 0;
|
|
68
68
|
export const TRANSITION_LIGHT_ANTIMIROV = 1;
|
|
69
69
|
|