tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315
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 +97 -92
- package/dist/transfer.js +97 -92
- 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 +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +518 -281
- 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 +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +155 -66
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +152 -25
- 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 +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/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/ackermannize-bv-tactic.ts +3 -2
- 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 +28 -2
- 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/bv1-blast.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 +9 -4
- 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 +9 -8
- package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
- 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 +31 -28
- package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
- 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 +2 -3
- package/src/prover/smt/solver/fm-tactic.ts +9 -7
- 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/fpa2bv-tactic.ts +1 -1
- 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/lia2pb.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 +2 -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/normalize-bounds.ts +2 -2
- package/src/prover/smt/solver/occf.ts +1 -1
- 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/pb2bv-tactic.ts +9 -3
- 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/purify-arith.ts +51 -49
- 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/reduce-args.ts +2 -2
- 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 +75 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
- 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 +54 -25
- package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
- 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 +718 -213
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -4
- package/src/prover/smt/solver/tactic.ts +389 -199
- 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 +12 -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 +15 -5
- 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 +1311 -268
- package/src/runtime.ts +21 -2
- 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 +19 -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 +12 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +321 -135
- 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 +666 -147
- package/src/successors.ts +50 -20
- 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 +147 -46
- 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
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { SmtCanceledError } from "../../../errors";
|
|
1
|
+
import { SmtCanceledError, SmtTacticError } from "../../../errors";
|
|
2
2
|
import {
|
|
3
3
|
type AstManager,
|
|
4
4
|
KIND_APP,
|
|
@@ -7,27 +7,38 @@ import {
|
|
|
7
7
|
OP_AND,
|
|
8
8
|
OP_EQ,
|
|
9
9
|
OP_IMPLIES,
|
|
10
|
+
OP_OR,
|
|
10
11
|
OP_UBV2INT,
|
|
11
12
|
OP_ULEQ,
|
|
12
13
|
SORT_BOOL,
|
|
13
14
|
SORT_INT,
|
|
14
15
|
} from "./ast";
|
|
16
|
+
import { mkNot } from "./ast-util";
|
|
15
17
|
import { BoundManager } from "./bound-manager";
|
|
16
18
|
import { mkBvApp } from "./bv-decl-plugin";
|
|
17
19
|
import { Bv2IntContext, Bv2IntRewriter } from "./bv2int-rewriter";
|
|
18
|
-
import {
|
|
19
|
-
import {
|
|
20
|
+
import { createCard2Bv } from "./card2bv";
|
|
21
|
+
import { DependentExprState } from "./dependent-expr-state";
|
|
22
|
+
import { Enum2BvRewriter } from "./dt2bv-tactic";
|
|
23
|
+
import { assignOwned, release } from "./expr-ref";
|
|
20
24
|
import { ExprSafeReplace } from "./expr-safe-replace";
|
|
21
|
-
import {
|
|
22
|
-
|
|
23
|
-
|
|
25
|
+
import {
|
|
26
|
+
type Definition,
|
|
27
|
+
type Dependency,
|
|
28
|
+
getDependencyValues,
|
|
29
|
+
Goal,
|
|
30
|
+
mkDependencyLeaf,
|
|
31
|
+
} from "./goal";
|
|
32
|
+
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
33
|
+
import type { ProtoModel } from "./proto-model";
|
|
34
|
+
import type { Rational } from "./rational";
|
|
24
35
|
import { RefVector } from "./ref-vector";
|
|
25
36
|
import { Rewriter } from "./rewriter";
|
|
26
|
-
import {
|
|
37
|
+
import { RewriterTpl } from "./rewriter-tpl";
|
|
38
|
+
import { applyDefinitions, getRewriterOptions } from "./tactic";
|
|
27
39
|
import { UINT_MAX } from "./sat/clause";
|
|
28
40
|
import type { SatParams } from "./sat/config";
|
|
29
41
|
import { IncSatSolver } from "./sat/inc-sat-solver";
|
|
30
|
-
import { SubstReplacer } from "./solve-eqs";
|
|
31
42
|
|
|
32
43
|
const getNumBits = (value: bigint) => {
|
|
33
44
|
let bound = 1n;
|
|
@@ -47,77 +58,384 @@ const collectBounds = (manager: AstManager, bounds: BoundManager, form: number)
|
|
|
47
58
|
for (const arg of manager.getArgs(form)) collectBounds(manager, bounds, arg);
|
|
48
59
|
};
|
|
49
60
|
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
)
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
61
|
+
class SolverFormulas extends Goal {
|
|
62
|
+
override assert(form: number, dependency?: Dependency) {
|
|
63
|
+
if (this.manager.isFalse(form)) this.isInconsistent = true;
|
|
64
|
+
this.forms.push(form);
|
|
65
|
+
this.dependencies.push(dependency);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
override update(index: number, form: number, dependency?: Dependency) {
|
|
69
|
+
if (this.manager.isFalse(form)) this.isInconsistent = true;
|
|
70
|
+
this.forms.set(index, form);
|
|
71
|
+
this.dependencies[index] = dependency;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
flattenSuffix(qhead: number) {
|
|
75
|
+
const manager = this.manager;
|
|
76
|
+
const forms = this.forms;
|
|
77
|
+
const seen = new Set<number>();
|
|
78
|
+
const pinned = new RefVector(manager);
|
|
79
|
+
let kept = qhead;
|
|
80
|
+
for (let index = qhead; index < forms.size; index++) {
|
|
81
|
+
const form = forms.items[index];
|
|
82
|
+
const dependency = this.dependencies[index];
|
|
83
|
+
pinned.push(form);
|
|
84
|
+
if (seen.has(form)) continue;
|
|
85
|
+
seen.add(form);
|
|
86
|
+
if (manager.isTrue(form)) continue;
|
|
87
|
+
if (manager.getOp(form) === OP_AND) {
|
|
88
|
+
const numArgs = manager.getNumArgs(form);
|
|
89
|
+
for (let argIndex = 0; argIndex < numArgs; argIndex++)
|
|
90
|
+
this.assert(manager.getArg(form, argIndex), dependency);
|
|
91
|
+
continue;
|
|
92
|
+
}
|
|
93
|
+
if (manager.isNot(form) && manager.getOp(manager.getArg(form, 0)) === OP_OR) {
|
|
94
|
+
const disjunction = manager.getArg(form, 0);
|
|
95
|
+
const numArgs = manager.getNumArgs(disjunction);
|
|
96
|
+
for (let argIndex = 0; argIndex < numArgs; argIndex++)
|
|
97
|
+
this.assert(mkNot(manager, manager.getArg(disjunction, argIndex)), dependency);
|
|
98
|
+
continue;
|
|
99
|
+
}
|
|
100
|
+
if (index !== kept) {
|
|
101
|
+
forms.set(kept, form);
|
|
102
|
+
this.dependencies[kept] = dependency;
|
|
103
|
+
}
|
|
104
|
+
kept++;
|
|
105
|
+
}
|
|
106
|
+
this.shrinkTo(kept);
|
|
107
|
+
pinned.reset();
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
shrinkTo(size: number) {
|
|
111
|
+
this.forms.shrink(size);
|
|
112
|
+
this.dependencies.length = size;
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
// Z3's dep_expr_state reads the formulas in place, without holding one.
|
|
117
|
+
class FdState extends DependentExprState {
|
|
118
|
+
declare readonly goal: SolverFormulas;
|
|
119
|
+
|
|
120
|
+
override get(index: number) {
|
|
121
|
+
return this.goal.forms.items[index];
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
class MacroReplacer extends RewriterTpl {
|
|
126
|
+
constructor(
|
|
127
|
+
manager: AstManager,
|
|
128
|
+
private readonly decl: number,
|
|
129
|
+
private readonly def: number,
|
|
130
|
+
) {
|
|
131
|
+
super(manager);
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
override isRewritingPatterns() {
|
|
135
|
+
return false;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
override getSubst(expr: number) {
|
|
139
|
+
return this.manager.kinds[expr] === KIND_APP && this.manager.decls[expr] === this.decl
|
|
140
|
+
? this.def
|
|
141
|
+
: undefined;
|
|
142
|
+
}
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
const addVars = (manager: AstManager, expr: number, freeVars: Set<number>) => {
|
|
146
|
+
const visited = new Set<number>();
|
|
147
|
+
const todo = [expr];
|
|
148
|
+
for (let current = todo.pop(); current !== undefined; current = todo.pop()) {
|
|
149
|
+
if (visited.has(current)) continue;
|
|
150
|
+
visited.add(current);
|
|
151
|
+
if (manager.kinds[current] === KIND_QUANTIFIER) todo.push(manager.getQuantifier(current).body);
|
|
152
|
+
else if (manager.kinds[current] === KIND_APP) {
|
|
153
|
+
if (manager.isUninterpreted(current)) freeVars.add(manager.decls[current]);
|
|
154
|
+
manager.pushArgs(current, todo);
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
};
|
|
158
|
+
|
|
159
|
+
const retainDefinitions = (manager: AstManager, definitions: readonly Definition[]) => {
|
|
160
|
+
for (const definition of definitions) {
|
|
161
|
+
manager.incDeclRef(definition.decl);
|
|
162
|
+
if (definition.def !== -1) manager.incRef(definition.def);
|
|
163
|
+
}
|
|
164
|
+
return [...definitions];
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
const releaseDefinitions = (manager: AstManager, definitions: readonly Definition[]) => {
|
|
168
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
169
|
+
const definition = definitions[index];
|
|
170
|
+
if (definition.def !== -1) manager.decRef(definition.def);
|
|
171
|
+
manager.decDeclRef(definition.decl);
|
|
172
|
+
}
|
|
173
|
+
};
|
|
174
|
+
|
|
175
|
+
class ModelTrail {
|
|
176
|
+
readonly entries: Definition[] = [];
|
|
177
|
+
|
|
178
|
+
constructor(private readonly manager: AstManager) {}
|
|
179
|
+
|
|
180
|
+
hide(decl: number) {
|
|
181
|
+
this.manager.incDeclRef(decl);
|
|
182
|
+
this.entries.push({ decl, def: -1 });
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
define(decl: number, def: number) {
|
|
186
|
+
this.manager.incDeclRef(decl);
|
|
187
|
+
this.manager.incRef(def);
|
|
188
|
+
this.entries.push({ decl, def });
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
shrink(size: number) {
|
|
192
|
+
releaseDefinitions(this.manager, this.entries.splice(size));
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
replay(qhead: number, assumptions: RefVector, fmls: SolverFormulas) {
|
|
196
|
+
const manager = this.manager;
|
|
197
|
+
if (this.entries.length === 0) return;
|
|
198
|
+
if (qhead === fmls.forms.size && assumptions.size === 0) return;
|
|
199
|
+
const freeVars = new Set<number>();
|
|
200
|
+
for (let index = qhead; index < fmls.forms.size; index++)
|
|
201
|
+
addVars(manager, fmls.forms.items[index], freeVars);
|
|
202
|
+
for (const assumption of assumptions.items) addVars(manager, assumption, freeVars);
|
|
203
|
+
if (!this.entries.some((entry) => entry.def !== -1 && freeVars.has(entry.decl))) return;
|
|
204
|
+
for (const entry of this.entries) {
|
|
205
|
+
if (entry.def === -1 || !freeVars.has(entry.decl)) continue;
|
|
206
|
+
addVars(manager, entry.def, freeVars);
|
|
207
|
+
const replacer = new MacroReplacer(manager, entry.decl, entry.def);
|
|
208
|
+
// Deviation from Z3: macro_replacer returns the rewrite of a named formula's last name, which drops the formula.
|
|
209
|
+
for (let index = qhead; index < fmls.forms.size; index++) {
|
|
210
|
+
const form = fmls.forms.items[index];
|
|
211
|
+
const replaced = replacer.rewrite(form);
|
|
212
|
+
replacer.reset();
|
|
213
|
+
if (replaced !== form) fmls.update(index, replaced, fmls.getDependency(index));
|
|
214
|
+
manager.decRef(replaced);
|
|
215
|
+
}
|
|
216
|
+
for (let index = 0; index < assumptions.size; index++) {
|
|
217
|
+
assumptions.setOwned(index, replacer.rewrite(assumptions.items[index]));
|
|
218
|
+
replacer.reset();
|
|
219
|
+
}
|
|
220
|
+
replacer.release();
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
class BoundedInt2BvSimplifier {
|
|
226
|
+
private readonly bounds: BoundManager[];
|
|
227
|
+
private readonly bvFns: number[] = [];
|
|
228
|
+
private readonly intFns: number[] = [];
|
|
229
|
+
private readonly fnLimits: number[] = [];
|
|
230
|
+
private readonly int2bv = new Map<number, number>();
|
|
231
|
+
private readonly bv2offset = new Map<number, Rational>();
|
|
232
|
+
private readonly context: Bv2IntContext;
|
|
233
|
+
private readonly rewriter: Bv2IntRewriter;
|
|
234
|
+
private readonly sideConditions: RefVector;
|
|
235
|
+
|
|
236
|
+
constructor(private readonly manager: AstManager) {
|
|
237
|
+
this.bounds = [new BoundManager(manager)];
|
|
238
|
+
this.context = new Bv2IntContext(manager, UINT_MAX);
|
|
239
|
+
this.rewriter = new Bv2IntRewriter(manager, this.context);
|
|
240
|
+
this.sideConditions = new RefVector(manager);
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
private accumulateSubstitution(
|
|
244
|
+
substitution: ExprSafeReplace,
|
|
245
|
+
bounds: BoundManager,
|
|
246
|
+
trail: ModelTrail,
|
|
247
|
+
) {
|
|
248
|
+
const manager = this.manager;
|
|
249
|
+
for (const expr of bounds.boundedVars) {
|
|
250
|
+
const lower = bounds.lowers.get(expr);
|
|
251
|
+
const upper = bounds.uppers.get(expr);
|
|
252
|
+
if (
|
|
253
|
+
lower === undefined ||
|
|
254
|
+
upper === undefined ||
|
|
255
|
+
lower.value.compare(upper.value) > 0 ||
|
|
256
|
+
lower.isStrict ||
|
|
257
|
+
upper.isStrict ||
|
|
258
|
+
manager.sorts[expr] !== SORT_INT
|
|
259
|
+
)
|
|
260
|
+
continue;
|
|
261
|
+
const decl = manager.decls[expr];
|
|
262
|
+
const bvDecl =
|
|
263
|
+
this.int2bv.get(decl) ?? this.addBitVector(decl, lower.value, upper.value, trail);
|
|
264
|
+
const offset = this.bv2offset.get(bvDecl) ?? lower.value;
|
|
265
|
+
substitution.insert(expr, this.mkValue(bvDecl, offset));
|
|
266
|
+
}
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
private mkValue(bvDecl: number, offset: Rational) {
|
|
270
|
+
const manager = this.manager;
|
|
271
|
+
const unsigned = mkBvApp(manager, OP_UBV2INT, [
|
|
272
|
+
manager.mkApp(bvDecl, [], manager.funcDecls[bvDecl].range),
|
|
273
|
+
]);
|
|
274
|
+
return offset.isZero()
|
|
78
275
|
? unsigned
|
|
79
276
|
: manager.mkApp(OP_ADD, [unsigned, manager.mkNumeral(offset.num)], SORT_INT);
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
);
|
|
85
|
-
|
|
86
|
-
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
private addBitVector(decl: number, lower: Rational, upper: Rational, trail: ModelTrail) {
|
|
280
|
+
const manager = this.manager;
|
|
281
|
+
const domainSize = upper.sub(lower).num + 1n;
|
|
282
|
+
const numBits = getNumBits(domainSize);
|
|
283
|
+
const bits = manager.mkFreshConst("b", manager.mkBvSort(numBits));
|
|
284
|
+
manager.incRef(bits);
|
|
285
|
+
const bvDecl = manager.decls[bits];
|
|
286
|
+
this.int2bv.set(decl, bvDecl);
|
|
287
|
+
this.bv2offset.set(bvDecl, lower);
|
|
288
|
+
manager.incDeclRef(bvDecl);
|
|
289
|
+
this.bvFns.push(bvDecl);
|
|
290
|
+
manager.incDeclRef(decl);
|
|
291
|
+
this.intFns.push(decl);
|
|
292
|
+
trail.hide(bvDecl);
|
|
293
|
+
trail.define(decl, this.mkValue(bvDecl, lower));
|
|
294
|
+
if (!lower.isZero() && (domainSize & (domainSize - 1n)) !== 0n)
|
|
295
|
+
this.sideConditions.push(
|
|
87
296
|
mkBvApp(manager, OP_ULEQ, [bits, manager.mkBvNumeral(domainSize - 1n, numBits)]),
|
|
88
297
|
);
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
const
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
298
|
+
manager.decRef(bits);
|
|
299
|
+
return bvDecl;
|
|
300
|
+
}
|
|
301
|
+
|
|
302
|
+
reduce(state: FdState, trail: ModelTrail) {
|
|
303
|
+
const manager = this.manager;
|
|
304
|
+
const fmls = state.goal;
|
|
305
|
+
const bounds = this.bounds[this.bounds.length - 1];
|
|
306
|
+
state.forEachIndex((index) => collectBounds(manager, bounds, fmls.forms.items[index]));
|
|
307
|
+
const substitution = new ExprSafeReplace(manager);
|
|
308
|
+
try {
|
|
309
|
+
for (const scopeBounds of this.bounds)
|
|
310
|
+
this.accumulateSubstitution(substitution, scopeBounds, trail);
|
|
311
|
+
if (substitution.sources.size > 0) {
|
|
312
|
+
let replaced = -1;
|
|
313
|
+
let result = -1;
|
|
314
|
+
try {
|
|
315
|
+
state.forEachIndex((index) => {
|
|
316
|
+
const form = fmls.forms.items[index];
|
|
317
|
+
replaced = assignOwned(manager, replaced, substitution.apply(form));
|
|
318
|
+
result = assignOwned(manager, result, this.rewriter.rewrite(replaced));
|
|
319
|
+
if (result !== form) fmls.update(index, result, fmls.getDependency(index));
|
|
320
|
+
});
|
|
321
|
+
} finally {
|
|
322
|
+
release(manager, result);
|
|
323
|
+
release(manager, replaced);
|
|
324
|
+
}
|
|
325
|
+
}
|
|
326
|
+
for (const condition of this.sideConditions.items) fmls.assert(condition);
|
|
327
|
+
this.sideConditions.reset();
|
|
328
|
+
this.rewriter.reset();
|
|
329
|
+
} finally {
|
|
330
|
+
substitution.release();
|
|
102
331
|
}
|
|
103
|
-
rewriter.release();
|
|
104
|
-
context.release();
|
|
105
|
-
replacer.release();
|
|
106
332
|
}
|
|
107
|
-
for (const condition of sideConditions.items) goal.assert(condition);
|
|
108
|
-
if (definitions.length > 0) goal.addDefinitions(definitions);
|
|
109
|
-
sideConditions.reset();
|
|
110
|
-
trail.reset();
|
|
111
|
-
};
|
|
112
333
|
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
334
|
+
push() {
|
|
335
|
+
this.fnLimits.push(this.bvFns.length);
|
|
336
|
+
this.bounds.push(new BoundManager(this.manager));
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
pop(numScopes: number) {
|
|
340
|
+
const manager = this.manager;
|
|
341
|
+
const limit = this.fnLimits[this.fnLimits.length - numScopes];
|
|
342
|
+
for (let index = this.intFns.length - 1; index >= limit; index--) {
|
|
343
|
+
this.int2bv.delete(this.intFns[index]);
|
|
344
|
+
this.bv2offset.delete(this.bvFns[index]);
|
|
345
|
+
}
|
|
346
|
+
for (const decl of this.bvFns.splice(limit)) manager.decDeclRef(decl);
|
|
347
|
+
for (const decl of this.intFns.splice(limit)) manager.decDeclRef(decl);
|
|
348
|
+
this.fnLimits.length -= numScopes;
|
|
349
|
+
this.bounds.length -= numScopes;
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
release() {
|
|
353
|
+
const manager = this.manager;
|
|
354
|
+
this.sideConditions.reset();
|
|
355
|
+
this.rewriter.release();
|
|
356
|
+
this.context.release();
|
|
357
|
+
for (const decl of this.intFns) manager.decDeclRef(decl);
|
|
358
|
+
for (const decl of this.bvFns) manager.decDeclRef(decl);
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
class Enum2BvSimplifier {
|
|
363
|
+
private readonly rewriter: Enum2BvRewriter;
|
|
364
|
+
private readonly hidden = new Set<number>();
|
|
365
|
+
private readonly defined = new Set<number>();
|
|
366
|
+
private readonly hiddenTrail: number[] = [];
|
|
367
|
+
private readonly definedTrail: number[] = [];
|
|
368
|
+
private readonly hiddenLimits: number[] = [];
|
|
369
|
+
private readonly definedLimits: number[] = [];
|
|
370
|
+
|
|
371
|
+
constructor(private readonly manager: AstManager) {
|
|
372
|
+
this.rewriter = new Enum2BvRewriter(manager, undefined);
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
reduce(state: FdState, trail: ModelTrail) {
|
|
376
|
+
const manager = this.manager;
|
|
377
|
+
const fmls = state.goal;
|
|
378
|
+
const rewriter = this.rewriter;
|
|
379
|
+
let result = -1;
|
|
380
|
+
try {
|
|
381
|
+
state.forEachIndex((index) => {
|
|
382
|
+
const form = fmls.forms.items[index];
|
|
383
|
+
result = assignOwned(manager, result, rewriter.rewrite(form));
|
|
384
|
+
if (result !== form) fmls.update(index, result, fmls.getDependency(index));
|
|
385
|
+
});
|
|
386
|
+
const bounds = new RefVector(manager);
|
|
387
|
+
for (const bound of rewriter.bounds.items) bounds.push(bound);
|
|
388
|
+
rewriter.bounds.reset();
|
|
389
|
+
for (const bound of bounds.items) fmls.assert(bound);
|
|
390
|
+
bounds.reset();
|
|
391
|
+
for (const [, index] of rewriter.enumIndexes) {
|
|
392
|
+
const bvDecl = rewriter.enumBvs[index];
|
|
393
|
+
if (this.hidden.has(bvDecl)) continue;
|
|
394
|
+
this.hidden.add(bvDecl);
|
|
395
|
+
manager.incDeclRef(bvDecl);
|
|
396
|
+
this.hiddenTrail.push(bvDecl);
|
|
397
|
+
trail.hide(bvDecl);
|
|
398
|
+
}
|
|
399
|
+
for (const [decl, index] of rewriter.enumIndexes) {
|
|
400
|
+
if (this.defined.has(decl)) continue;
|
|
401
|
+
this.defined.add(decl);
|
|
402
|
+
manager.incDeclRef(decl);
|
|
403
|
+
this.definedTrail.push(decl);
|
|
404
|
+
trail.define(decl, rewriter.enumDefs.items[index]);
|
|
405
|
+
}
|
|
406
|
+
} finally {
|
|
407
|
+
release(manager, result);
|
|
408
|
+
}
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
push() {
|
|
412
|
+
this.rewriter.push();
|
|
413
|
+
this.hiddenLimits.push(this.hiddenTrail.length);
|
|
414
|
+
this.definedLimits.push(this.definedTrail.length);
|
|
415
|
+
}
|
|
416
|
+
|
|
417
|
+
pop(numScopes: number) {
|
|
418
|
+
const manager = this.manager;
|
|
419
|
+
const hiddenLimit = this.hiddenLimits[this.hiddenLimits.length - numScopes];
|
|
420
|
+
const definedLimit = this.definedLimits[this.definedLimits.length - numScopes];
|
|
421
|
+
for (let index = this.hiddenTrail.length - 1; index >= hiddenLimit; index--)
|
|
422
|
+
this.hidden.delete(this.hiddenTrail[index]);
|
|
423
|
+
for (let index = this.definedTrail.length - 1; index >= definedLimit; index--)
|
|
424
|
+
this.defined.delete(this.definedTrail[index]);
|
|
425
|
+
for (const decl of this.hiddenTrail.splice(hiddenLimit)) manager.decDeclRef(decl);
|
|
426
|
+
for (const decl of this.definedTrail.splice(definedLimit)) manager.decDeclRef(decl);
|
|
427
|
+
this.hiddenLimits.length -= numScopes;
|
|
428
|
+
this.definedLimits.length -= numScopes;
|
|
429
|
+
this.rewriter.pop(numScopes);
|
|
430
|
+
}
|
|
431
|
+
|
|
432
|
+
release() {
|
|
433
|
+
const manager = this.manager;
|
|
434
|
+
for (const decl of this.definedTrail) manager.decDeclRef(decl);
|
|
435
|
+
for (const decl of this.hiddenTrail) manager.decDeclRef(decl);
|
|
436
|
+
this.rewriter.release();
|
|
437
|
+
}
|
|
438
|
+
}
|
|
121
439
|
|
|
122
440
|
// The sole uninterpreted constant of a term, which stands for it in the SAT solver.
|
|
123
441
|
const getRepresentative = (manager: AstManager, expr: number) => {
|
|
@@ -137,49 +455,115 @@ const getRepresentative = (manager: AstManager, expr: number) => {
|
|
|
137
455
|
return result;
|
|
138
456
|
};
|
|
139
457
|
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
458
|
+
interface FdScope {
|
|
459
|
+
qhead: number;
|
|
460
|
+
size: number;
|
|
461
|
+
trailSize: number;
|
|
462
|
+
isInconsistent: boolean;
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
export class FdSolver {
|
|
466
|
+
private readonly solver: IncSatSolver;
|
|
467
|
+
private readonly fmls: SolverFormulas;
|
|
468
|
+
private readonly state: FdState;
|
|
469
|
+
private readonly trail: ModelTrail;
|
|
470
|
+
private readonly int2bv: BoundedInt2BvSimplifier;
|
|
471
|
+
private readonly enum2bv: Enum2BvSimplifier;
|
|
472
|
+
private readonly coreReplace: ExprSafeReplace;
|
|
473
|
+
private readonly core: RefVector;
|
|
474
|
+
private readonly scopes: FdScope[] = [];
|
|
475
|
+
private converter: Definition[] = [];
|
|
476
|
+
private model: ProtoModel | undefined;
|
|
477
|
+
|
|
478
|
+
constructor(
|
|
479
|
+
private readonly manager: AstManager,
|
|
480
|
+
params: SatParams,
|
|
481
|
+
isIncremental = true,
|
|
482
|
+
) {
|
|
483
|
+
this.solver = new IncSatSolver(manager, params, isIncremental);
|
|
484
|
+
this.fmls = new SolverFormulas(manager);
|
|
485
|
+
this.state = new FdState(manager, this.fmls);
|
|
486
|
+
this.trail = new ModelTrail(manager);
|
|
487
|
+
this.int2bv = new BoundedInt2BvSimplifier(manager);
|
|
488
|
+
this.enum2bv = new Enum2BvSimplifier(manager);
|
|
489
|
+
this.coreReplace = new ExprSafeReplace(manager);
|
|
490
|
+
this.core = new RefVector(manager);
|
|
491
|
+
}
|
|
492
|
+
|
|
493
|
+
get reasonUnknown() {
|
|
494
|
+
return this.solver.reasonUnknown;
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
assertExpr(form: number, name = -1) {
|
|
498
|
+
this.clearModel();
|
|
499
|
+
this.fmls.forms.push(form);
|
|
500
|
+
this.fmls.dependencies.push(name === -1 ? undefined : mkDependencyLeaf(name));
|
|
501
|
+
}
|
|
502
|
+
|
|
503
|
+
push() {
|
|
504
|
+
this.flush([]).reset();
|
|
505
|
+
this.scopes.push({
|
|
506
|
+
qhead: this.state.qhead,
|
|
507
|
+
size: this.fmls.forms.size,
|
|
508
|
+
trailSize: this.trail.entries.length,
|
|
509
|
+
isInconsistent: this.fmls.isInconsistent,
|
|
510
|
+
});
|
|
511
|
+
this.int2bv.push();
|
|
512
|
+
this.enum2bv.push();
|
|
513
|
+
this.solver.push();
|
|
514
|
+
}
|
|
515
|
+
|
|
516
|
+
pop(numScopes: number) {
|
|
517
|
+
this.solver.pop(numScopes);
|
|
518
|
+
this.clearModel();
|
|
519
|
+
this.int2bv.pop(numScopes);
|
|
520
|
+
this.enum2bv.pop(numScopes);
|
|
521
|
+
const scope = this.scopes[this.scopes.length - numScopes];
|
|
522
|
+
this.scopes.length -= numScopes;
|
|
523
|
+
this.trail.shrink(scope.trailSize);
|
|
524
|
+
this.fmls.isInconsistent = scope.isInconsistent;
|
|
525
|
+
this.fmls.shrinkTo(scope.size);
|
|
526
|
+
this.state.qhead = scope.qhead;
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
check(assumptions: readonly number[] = []) {
|
|
530
|
+
const flushed = this.flush(assumptions);
|
|
531
|
+
const result = this.solver.check(flushed.items);
|
|
532
|
+
flushed.reset();
|
|
533
|
+
// solver::check_sat counts a step to see whether the limit stopped a search that gave up.
|
|
534
|
+
if (result === L_UNDEF) this.manager.limit.inc();
|
|
163
535
|
return result;
|
|
164
|
-
}
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
for (const
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
getModel() {
|
|
539
|
+
if (this.model !== undefined) return this.model;
|
|
540
|
+
const model = this.solver.mkModel();
|
|
541
|
+
if (model === null) return undefined;
|
|
542
|
+
const converted = this.converter.length > 0 ? applyDefinitions(this.converter, model) : model;
|
|
543
|
+
converted.incRef();
|
|
544
|
+
this.model = converted;
|
|
545
|
+
return converted;
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
getUnsatCore() {
|
|
549
|
+
this.core.reset();
|
|
550
|
+
for (const expr of this.solver.getUnsatCore())
|
|
551
|
+
this.core.pushOwned(this.coreReplace.apply(expr));
|
|
552
|
+
return this.core.items;
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
getConsequences(assumptions: readonly number[], vars: readonly number[]) {
|
|
556
|
+
const manager = this.manager;
|
|
557
|
+
const flushed = this.flush([...assumptions, ...vars]);
|
|
558
|
+
const asms1 = flushed.items.slice(0, assumptions.length);
|
|
559
|
+
const vars1 = flushed.items.slice(assumptions.length);
|
|
560
|
+
const queryVars = vars1.map((expr) => {
|
|
561
|
+
const representative = getRepresentative(manager, expr);
|
|
562
|
+
return representative === -1 ? expr : representative;
|
|
563
|
+
});
|
|
564
|
+
const found = this.solver.getConsequences(asms1, queryVars);
|
|
565
|
+
const trail = new RefVector(manager);
|
|
566
|
+
const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
|
|
183
567
|
const consequences = new RefVector(manager);
|
|
184
568
|
for (const consequence of found.consequences) {
|
|
185
569
|
const premise = manager.getArg(consequence, 0);
|
|
@@ -212,50 +596,135 @@ export const getFdConsequences = (
|
|
|
212
596
|
const replaced = substitution.apply(vars1[index]);
|
|
213
597
|
trail.pushOwned(replaced);
|
|
214
598
|
substitution.release();
|
|
599
|
+
const rewritten = rewriter.rewrite(replaced);
|
|
600
|
+
trail.pushOwned(rewritten);
|
|
215
601
|
return manager.mkApp(
|
|
216
602
|
OP_IMPLIES,
|
|
217
|
-
[premise, manager.mkEq(vars[index],
|
|
603
|
+
[premise, manager.mkEq(vars[index], rewritten)],
|
|
218
604
|
SORT_BOOL,
|
|
219
605
|
);
|
|
220
606
|
})();
|
|
221
|
-
consequences.pushOwned(coreReplace.apply(decoded));
|
|
607
|
+
consequences.pushOwned(this.coreReplace.apply(decoded));
|
|
222
608
|
}
|
|
223
|
-
coreReplace.release();
|
|
224
|
-
const model = found.result === L_TRUE ? solver.getModel() : null;
|
|
225
|
-
model?.incRef();
|
|
226
|
-
return {
|
|
227
|
-
result: found.result,
|
|
228
|
-
consequences,
|
|
229
|
-
model: model === null ? undefined : convertModel(fmls, model),
|
|
230
|
-
};
|
|
231
|
-
} finally {
|
|
232
|
-
solver.release();
|
|
233
609
|
rewriter.release();
|
|
234
|
-
definitions.release();
|
|
235
610
|
trail.reset();
|
|
611
|
+
flushed.reset();
|
|
612
|
+
return { result: found.result, consequences };
|
|
613
|
+
}
|
|
614
|
+
|
|
615
|
+
getAssertions() {
|
|
616
|
+
return this.solver.getAssertions();
|
|
236
617
|
}
|
|
237
|
-
};
|
|
238
618
|
|
|
239
|
-
|
|
619
|
+
getConverters(): Goal["converters"] {
|
|
620
|
+
const definitions = retainDefinitions(this.manager, this.converter);
|
|
621
|
+
return [...(definitions.length > 0 ? [{ definitions }] : []), ...this.solver.getConverters()];
|
|
622
|
+
}
|
|
623
|
+
|
|
624
|
+
private flush(assumptions: readonly number[]) {
|
|
625
|
+
const manager = this.manager;
|
|
626
|
+
const fmls = this.fmls;
|
|
627
|
+
this.clearModel();
|
|
628
|
+
const qhead = this.state.qhead;
|
|
629
|
+
const flushed = new RefVector(manager);
|
|
630
|
+
for (const assumption of assumptions) flushed.push(assumption);
|
|
631
|
+
this.coreReplace.reset();
|
|
632
|
+
this.replay(qhead, flushed);
|
|
633
|
+
if (qhead < fmls.forms.size) {
|
|
634
|
+
this.reduce();
|
|
635
|
+
if (!manager.limit.inc()) return flushed;
|
|
636
|
+
this.replay(qhead, flushed);
|
|
637
|
+
this.state.qhead = fmls.forms.size;
|
|
638
|
+
}
|
|
639
|
+
flushed.items.forEach((assumption, index) =>
|
|
640
|
+
this.coreReplace.insert(assumption, assumptions[index]),
|
|
641
|
+
);
|
|
642
|
+
const converter = retainDefinitions(manager, this.trail.entries);
|
|
643
|
+
releaseDefinitions(manager, this.converter);
|
|
644
|
+
this.converter = converter;
|
|
645
|
+
for (let index = qhead; index < fmls.forms.size; index++) {
|
|
646
|
+
const names = getDependencyValues(fmls.getDependency(index));
|
|
647
|
+
if (names.length === 0) this.solver.assertExpr(fmls.forms.items[index]);
|
|
648
|
+
else this.solver.assertNamed(fmls.forms.items[index], manager.mkAnd(names));
|
|
649
|
+
}
|
|
650
|
+
return flushed;
|
|
651
|
+
}
|
|
652
|
+
|
|
653
|
+
private replay(qhead: number, assumptions: RefVector) {
|
|
654
|
+
const manager = this.manager;
|
|
655
|
+
this.trail.replay(qhead, assumptions, this.fmls);
|
|
656
|
+
if (assumptions.size === 0) return;
|
|
657
|
+
const rewriter = new Rewriter(manager, getRewriterOptions(manager, new Map()));
|
|
658
|
+
for (let index = 0; index < assumptions.size; index++)
|
|
659
|
+
assumptions.setOwned(index, rewriter.rewrite(assumptions.items[index]));
|
|
660
|
+
rewriter.release();
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
private reduce() {
|
|
664
|
+
const manager = this.manager;
|
|
665
|
+
const fmls = this.fmls;
|
|
666
|
+
const state = this.state;
|
|
667
|
+
if (fmls.isInconsistent || !manager.limit.inc()) return;
|
|
668
|
+
const simplifiers = [
|
|
669
|
+
() => this.int2bv.reduce(state, this.trail),
|
|
670
|
+
() => {
|
|
671
|
+
const simplifier = createCard2Bv(manager, getRewriterOptions(manager, new Map()))(state);
|
|
672
|
+
try {
|
|
673
|
+
simplifier.reduce();
|
|
674
|
+
} finally {
|
|
675
|
+
simplifier.release();
|
|
676
|
+
}
|
|
677
|
+
},
|
|
678
|
+
() => this.enum2bv.reduce(state, this.trail),
|
|
679
|
+
];
|
|
680
|
+
for (const simplify of simplifiers) {
|
|
681
|
+
if (fmls.isInconsistent || !manager.limit.inc()) break;
|
|
682
|
+
try {
|
|
683
|
+
simplify();
|
|
684
|
+
} catch (error) {
|
|
685
|
+
// The rewriter_exception of a canceled rewrite or of a nested datatype.
|
|
686
|
+
if (!(error instanceof SmtCanceledError || error instanceof SmtTacticError)) throw error;
|
|
687
|
+
break;
|
|
688
|
+
}
|
|
689
|
+
fmls.flattenSuffix(state.qhead);
|
|
690
|
+
}
|
|
691
|
+
fmls.flattenSuffix(state.qhead);
|
|
692
|
+
}
|
|
693
|
+
|
|
694
|
+
private clearModel() {
|
|
695
|
+
this.model?.decRef();
|
|
696
|
+
this.model = undefined;
|
|
697
|
+
}
|
|
698
|
+
|
|
699
|
+
release() {
|
|
700
|
+
this.clearModel();
|
|
701
|
+
this.core.reset();
|
|
702
|
+
this.coreReplace.release();
|
|
703
|
+
releaseDefinitions(this.manager, this.converter);
|
|
704
|
+
this.converter = [];
|
|
705
|
+
this.int2bv.release();
|
|
706
|
+
this.enum2bv.release();
|
|
707
|
+
this.trail.shrink(0);
|
|
708
|
+
this.fmls.reset();
|
|
709
|
+
this.solver.release();
|
|
710
|
+
}
|
|
711
|
+
}
|
|
712
|
+
|
|
240
713
|
export const createFdTactic = (manager: AstManager, params: SatParams) => (goal: Goal) => {
|
|
241
|
-
const
|
|
242
|
-
const solver = new IncSatSolver(manager, params, false);
|
|
714
|
+
const solver = new FdSolver(manager, params, false);
|
|
243
715
|
try {
|
|
244
|
-
for (const form of
|
|
245
|
-
const result =
|
|
716
|
+
for (const form of goal.forms.items) solver.assertExpr(form);
|
|
717
|
+
const result = solver.check();
|
|
246
718
|
goal.reset();
|
|
247
719
|
if (result === L_TRUE) {
|
|
248
720
|
const model = solver.getModel();
|
|
249
721
|
model?.incRef();
|
|
250
|
-
if (model !==
|
|
251
|
-
goal.converters = [...goal.converters, ...fmls.converters];
|
|
252
|
-
goal.model = model;
|
|
253
|
-
}
|
|
722
|
+
if (model !== undefined) goal.model = model;
|
|
254
723
|
} else if (result === L_FALSE) goal.assert(manager.falseExpr);
|
|
255
724
|
else {
|
|
256
|
-
if (!manager.limit.inc()) throw new
|
|
725
|
+
if (!manager.limit.inc()) throw new SmtTacticError("canceled");
|
|
257
726
|
for (const form of solver.getAssertions()) goal.assert(form);
|
|
258
|
-
goal.converters = [...goal.converters, ...
|
|
727
|
+
goal.converters = [...goal.converters, ...solver.getConverters()];
|
|
259
728
|
}
|
|
260
729
|
goal.depth++;
|
|
261
730
|
return [goal];
|