tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828
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/deciders.cjs +37 -36
- package/dist/deciders.js +55 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +146 -58
- package/dist/prove.js +142 -54
- package/dist/run.cjs +45 -43
- package/dist/run.js +47 -45
- package/dist/transfer.cjs +39 -36
- package/dist/transfer.js +23 -20
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/check.ts +203 -33
- package/src/cli/tlapm.ts +261 -68
- package/src/dependencies.ts +23 -2
- package/src/errors.ts +1 -1
- package/src/exit-codes.ts +1 -0
- package/src/liveness-checker.ts +530 -201
- package/src/liveness.ts +47 -32
- package/src/obligations/anonymize.ts +2 -4
- package/src/obligations/index.ts +5 -3
- package/src/obligations/pragma.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +151 -42
- package/src/prover/deciders.ts +1 -8
- package/src/prover/isabelle/isar/attrib.ts +86 -45
- package/src/prover/isabelle/isar/context.ts +25 -22
- package/src/prover/isabelle/isar/induct.ts +2 -5
- package/src/prover/isabelle/isar/method.ts +5 -7
- package/src/prover/isabelle/isar/proof.ts +33 -16
- package/src/prover/isabelle/isar/rule-cases.ts +6 -14
- package/src/prover/isabelle/isar/theory.ts +16 -17
- package/src/prover/isabelle/isar/toplevel.ts +46 -52
- package/src/prover/isabelle/provers/classical.ts +1 -1
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +1 -0
- package/src/prover/prep/methods.ts +50 -3
- package/src/prover/prep/normalize.ts +4 -1
- package/src/prover/prove.ts +58 -32
- package/src/prover/ptl/decide.ts +43 -63
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +1 -0
- package/src/prover/smt/solver/aig-tactic.ts +25 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -5
- package/src/prover/smt/solver/asserted-formulas.ts +1 -1
- package/src/prover/smt/solver/ast-util.ts +3 -1
- package/src/prover/smt/solver/ast.ts +110 -152
- package/src/prover/smt/solver/bound-manager.ts +39 -28
- package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
- package/src/prover/smt/solver/bv-rewriter.ts +14 -16
- package/src/prover/smt/solver/bv1-blast.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +19 -14
- package/src/prover/smt/solver/check-logic.ts +6 -1
- package/src/prover/smt/solver/context.ts +20 -10
- package/src/prover/smt/solver/demodulator.ts +2 -2
- package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
- package/src/prover/smt/solver/distribute-forall.ts +1 -10
- package/src/prover/smt/solver/dom-simplify.ts +1 -1
- package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
- package/src/prover/smt/solver/e-matching.ts +6 -6
- package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
- package/src/prover/smt/solver/enode.ts +15 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
- package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
- package/src/prover/smt/solver/euf/egraph.ts +65 -32
- package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
- package/src/prover/smt/solver/euf/mam.ts +6 -48
- package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
- package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
- package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
- package/src/prover/smt/solver/euf/q-solver.ts +2 -0
- package/src/prover/smt/solver/euf/th-solver.ts +1 -1
- package/src/prover/smt/solver/factor.ts +1 -11
- package/src/prover/smt/solver/fd-solver.ts +1 -2
- package/src/prover/smt/solver/fm-tactic.ts +19 -13
- package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
- package/src/prover/smt/solver/internalizer.ts +41 -2
- package/src/prover/smt/solver/lia2pb.ts +18 -4
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
- package/src/prover/smt/solver/macro-finder.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +13 -13
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
- package/src/prover/smt/solver/maxcore.ts +4 -12
- package/src/prover/smt/solver/maxlex.ts +0 -7
- package/src/prover/smt/solver/maxsmt-base.ts +7 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
- package/src/prover/smt/solver/model-evaluator.ts +9 -5
- package/src/prover/smt/solver/model-macro-solver.ts +3 -3
- package/src/prover/smt/solver/muz/dl-context.ts +57 -3
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
- package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
- package/src/prover/smt/solver/muz/hnf.ts +6 -5
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
- package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
- package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
- package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
- package/src/prover/smt/solver/muz/substitution.ts +88 -37
- package/src/prover/smt/solver/nlqsat.ts +2 -2
- package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
- package/src/prover/smt/solver/nlsat/explain.ts +5 -0
- package/src/prover/smt/solver/nlsat/solver.ts +36 -25
- package/src/prover/smt/solver/opt-context.ts +9 -8
- package/src/prover/smt/solver/opt-nlsat.ts +68 -58
- package/src/prover/smt/solver/opt-solver.ts +16 -7
- package/src/prover/smt/solver/optsmt.ts +12 -9
- package/src/prover/smt/solver/pattern-inference.ts +2 -2
- package/src/prover/smt/solver/pb-rewriter.ts +13 -13
- package/src/prover/smt/solver/poly-rewriter.ts +2 -2
- package/src/prover/smt/solver/probes.ts +1 -1
- package/src/prover/smt/solver/propagate-values.ts +4 -0
- package/src/prover/smt/solver/proto-model.ts +5 -5
- package/src/prover/smt/solver/purify-arith.ts +50 -15
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
- package/src/prover/smt/solver/qe-mbp.ts +13 -23
- package/src/prover/smt/solver/qe.ts +45 -53
- package/src/prover/smt/solver/qsat.ts +70 -90
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
- package/src/prover/smt/solver/quasi-macros.ts +9 -18
- package/src/prover/smt/solver/rational.ts +17 -0
- package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
- package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
- package/src/prover/smt/solver/rewriter.ts +1 -1
- package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
- package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
- package/src/prover/smt/solver/sat/clause.ts +1 -3
- package/src/prover/smt/solver/sat/config.ts +3 -3
- package/src/prover/smt/solver/sat/consequences.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
- package/src/prover/smt/solver/sat/model-converter.ts +1 -15
- package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
- package/src/prover/smt/solver/sat/probing.ts +22 -19
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
- package/src/prover/smt/solver/sat/simplifier.ts +15 -56
- package/src/prover/smt/solver/sat/solver.ts +20 -19
- package/src/prover/smt/solver/sat/watch-list.ts +7 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
- package/src/prover/smt/solver/seq-derive.ts +6 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
- package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
- package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
- package/src/prover/smt/solver/seq-re-util.ts +1 -2
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +4 -4
- package/src/prover/smt/solver/seq-rewriter.ts +1 -4
- package/src/prover/smt/solver/smt-setup.ts +15 -9
- package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
- package/src/prover/smt/solver/smtlib-script.ts +866 -728
- package/src/prover/smt/solver/tactic.ts +66 -14
- package/src/prover/smt/solver/theory-array.ts +25 -58
- package/src/prover/smt/solver/theory-bv.ts +13 -50
- package/src/prover/smt/solver/theory-fpa.ts +46 -78
- package/src/prover/smt/solver/theory-pb.ts +10 -6
- package/src/prover/smt/solver/theory-recfun.ts +2 -2
- package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
- package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
- package/src/prover/smt/solver/theory-seq-state.ts +6 -3
- package/src/prover/smt/solver/theory-seq.ts +32 -54
- package/src/prover/smt/solver/theory.ts +16 -1
- package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
- package/src/prover/smt/solver/var-subst.ts +2 -2
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/zenon/decide.ts +9 -11
- package/src/prover/zenon/node.ts +12 -11
- package/src/prover/zenon/tla/sets.ts +1 -1
- package/src/search.ts +131 -16
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/summary.ts +29 -14
- package/src/typed-tier.ts +6535 -0
- package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
|
@@ -11,7 +11,6 @@ import {
|
|
|
11
11
|
OP_LE,
|
|
12
12
|
OP_MOD,
|
|
13
13
|
OP_MUL,
|
|
14
|
-
OP_NUM,
|
|
15
14
|
OP_SUB,
|
|
16
15
|
OP_UMINUS,
|
|
17
16
|
SORT_BOOL,
|
|
@@ -20,6 +19,7 @@ import {
|
|
|
20
19
|
} from "../ast";
|
|
21
20
|
import { isAppOf, mkNot } from "../ast-util";
|
|
22
21
|
import { Rational } from "../rational";
|
|
22
|
+
import { getBinaryArgs, getNumeral } from "./mbp-plugin";
|
|
23
23
|
|
|
24
24
|
export interface SolvePlugin {
|
|
25
25
|
readonly family: number;
|
|
@@ -33,14 +33,6 @@ interface SignedExpr {
|
|
|
33
33
|
expr: number;
|
|
34
34
|
}
|
|
35
35
|
|
|
36
|
-
const getBinaryArgs = (manager: AstManager, expr: number, op: number) =>
|
|
37
|
-
isAppOf(manager, expr, op) && manager.getNumArgs(expr) === 2
|
|
38
|
-
? [manager.getArg(expr, 0), manager.getArg(expr, 1)]
|
|
39
|
-
: undefined;
|
|
40
|
-
|
|
41
|
-
const getNumeral = (manager: AstManager, expr: number) =>
|
|
42
|
-
isAppOf(manager, expr, OP_NUM) ? manager.getRationalValue(expr) : undefined;
|
|
43
|
-
|
|
44
36
|
const isZero = (manager: AstManager, expr: number) => getNumeral(manager, expr)?.isZero() === true;
|
|
45
37
|
|
|
46
38
|
export const mkArithSolvePlugin = (
|
|
@@ -32,6 +32,7 @@ import {
|
|
|
32
32
|
SORT_BOOL,
|
|
33
33
|
} from "./ast";
|
|
34
34
|
import type { AstManager } from "./ast";
|
|
35
|
+
import { DEFAULT_BV_OPTIONS } from "./bv-rewriter";
|
|
35
36
|
import { isConsideredUninterpreted } from "./fpa-decl-plugin";
|
|
36
37
|
import { FuncInterp, getManagerSomeValue } from "./proto-model";
|
|
37
38
|
import type { ProtoModel } from "./proto-model";
|
|
@@ -61,7 +62,10 @@ export class ModelEvaluator extends RewriterTpl {
|
|
|
61
62
|
private model: ProtoModel,
|
|
62
63
|
) {
|
|
63
64
|
super(manager);
|
|
64
|
-
this.rewriter = new Rewriter(manager,
|
|
65
|
+
this.rewriter = new Rewriter(manager, {
|
|
66
|
+
...TACTIC_REWRITER_OPTIONS,
|
|
67
|
+
bv: { ...DEFAULT_BV_OPTIONS, isHiDiv0: manager.isHiDiv0, isMkbv2num: true },
|
|
68
|
+
});
|
|
65
69
|
this.rewriter.releaseResult = () => this.setLastResult(-1);
|
|
66
70
|
}
|
|
67
71
|
|
|
@@ -124,7 +128,7 @@ export class ModelEvaluator extends RewriterTpl {
|
|
|
124
128
|
if (interp === undefined) return -1;
|
|
125
129
|
if (interp.isPartial()) interp.setElse(model.getSomeValue(sort));
|
|
126
130
|
const result = this.substitute(interp.getInterp() as number, args);
|
|
127
|
-
return manager.
|
|
131
|
+
return manager.isGroundApp(result) ? { expr: result, depth: Infinity } : result;
|
|
128
132
|
}
|
|
129
133
|
const rewritten = this.rewriter.reduceAppCore(decl, args);
|
|
130
134
|
const reduced =
|
|
@@ -192,7 +196,7 @@ export class ModelEvaluator extends RewriterTpl {
|
|
|
192
196
|
model.registerFunc(decl, created);
|
|
193
197
|
return value;
|
|
194
198
|
}
|
|
195
|
-
if (!manager.
|
|
199
|
+
if (!manager.isGroundApp(args[0])) return manager.mkApp(decl, args, sort);
|
|
196
200
|
}
|
|
197
201
|
if (op === OP_DT_CONSTRUCTOR) return manager.mkApp(decl, args, sort);
|
|
198
202
|
if (interp === undefined) return -1;
|
|
@@ -221,11 +225,11 @@ export class ModelEvaluator extends RewriterTpl {
|
|
|
221
225
|
);
|
|
222
226
|
const elseExpr = interp?.elseExpr ?? null;
|
|
223
227
|
if (interp === undefined || elseExpr === null) return undefined;
|
|
224
|
-
let isGround = manager.
|
|
228
|
+
let isGround = manager.isGroundApp(elseExpr);
|
|
225
229
|
for (const entry of interp.entries) {
|
|
226
230
|
if (entry.result === elseExpr) continue;
|
|
227
231
|
const store = [...entry.args, entry.result];
|
|
228
|
-
isGround &&= store.every((arg) => manager.
|
|
232
|
+
isGround &&= store.every((arg) => manager.isGroundApp(arg));
|
|
229
233
|
stores.push(store);
|
|
230
234
|
}
|
|
231
235
|
return isGround ? { stores, elseExpr, areUnique } : undefined;
|
|
@@ -117,7 +117,7 @@ const getHintHeadVars = (manager: AstManager, expr: number) => {
|
|
|
117
117
|
const isVarsOfSubset = (manager: AstManager, expr: number, vars: number[]) => {
|
|
118
118
|
const visited = new Set<number>();
|
|
119
119
|
const visit = (current: number): boolean => {
|
|
120
|
-
if (manager.
|
|
120
|
+
if (manager.isGroundApp(current) || visited.has(current)) return true;
|
|
121
121
|
visited.add(current);
|
|
122
122
|
const kind = manager.kinds[current];
|
|
123
123
|
if (kind === KIND_VAR) return vars.includes(current);
|
|
@@ -555,7 +555,7 @@ const collectNgFuncDecls = (manager: AstManager, expr: number) => {
|
|
|
555
555
|
visit(manager.getArg(current, index));
|
|
556
556
|
if (
|
|
557
557
|
manager.getNumArgs(current) > 0 &&
|
|
558
|
-
!manager.
|
|
558
|
+
!manager.isGroundApp(current) &&
|
|
559
559
|
isUserApp(manager, current)
|
|
560
560
|
)
|
|
561
561
|
decls.add(manager.decls[current]);
|
|
@@ -592,7 +592,7 @@ const nonAufMacroSolver = (manager: AstManager, model: ProtoModel, getInfo: GetI
|
|
|
592
592
|
const isBetterMacro = (first: CondMacro, second: CondMacro | null) => {
|
|
593
593
|
if (second === null || !first.isHint) return true;
|
|
594
594
|
if (!second.isHint) return false;
|
|
595
|
-
return manager.
|
|
595
|
+
return manager.isGroundApp(first.def) && !manager.isGroundApp(second.def);
|
|
596
596
|
};
|
|
597
597
|
const getMacroFor = (decl: number, quantifier: number) => {
|
|
598
598
|
let result: CondMacro | null = null;
|
|
@@ -11,6 +11,9 @@ import {
|
|
|
11
11
|
SORT_BOOL,
|
|
12
12
|
SORT_SIZE_INFINITE,
|
|
13
13
|
} from "../ast";
|
|
14
|
+
import type { Definition } from "../goal";
|
|
15
|
+
import { ModelEvaluator } from "../model-evaluator";
|
|
16
|
+
import { FuncInterp, type ProtoModel } from "../proto-model";
|
|
14
17
|
import { type RewriterOptions, Rewriter } from "../rewriter";
|
|
15
18
|
import { RefVector } from "../ref-vector";
|
|
16
19
|
import { applyQeLiteToConjuncts } from "../qe-lite";
|
|
@@ -56,8 +59,45 @@ export class FpParams {
|
|
|
56
59
|
}
|
|
57
60
|
}
|
|
58
61
|
|
|
62
|
+
export type ModelConverter = (model: ProtoModel) => ProtoModel;
|
|
63
|
+
|
|
64
|
+
// generic_model_converter::operator() over predicates, where a definition of -1 hides the
|
|
65
|
+
// declaration.
|
|
66
|
+
const applyDefinitions = (definitions: readonly Definition[], model: ProtoModel) => {
|
|
67
|
+
const manager = model.manager;
|
|
68
|
+
let evaluator = new ModelEvaluator(manager, model);
|
|
69
|
+
evaluator.setModelCompletion(true);
|
|
70
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
71
|
+
const definition = definitions[index];
|
|
72
|
+
if (definition.def === -1) {
|
|
73
|
+
model.unregisterDecl(definition.decl);
|
|
74
|
+
continue;
|
|
75
|
+
}
|
|
76
|
+
const value = evaluator.rewrite(definition.def);
|
|
77
|
+
const arity = manager.funcDecls[definition.decl].domain.length;
|
|
78
|
+
const oldInterp = model.funcInterps.get(definition.decl);
|
|
79
|
+
const old = arity === 0 ? model.constInterps.get(definition.decl) : oldInterp?.elseExpr;
|
|
80
|
+
if (old !== value) {
|
|
81
|
+
if (arity === 0) model.registerConst(definition.decl, value);
|
|
82
|
+
else {
|
|
83
|
+
const interp = new FuncInterp(manager, arity);
|
|
84
|
+
interp.setElse(value);
|
|
85
|
+
model.registerFunc(definition.decl, interp);
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
manager.decRef(value);
|
|
89
|
+
if (old === value || (arity === 0 ? old === undefined : oldInterp === undefined)) continue;
|
|
90
|
+
evaluator.release();
|
|
91
|
+
evaluator = new ModelEvaluator(manager, model);
|
|
92
|
+
evaluator.setModelCompletion(true);
|
|
93
|
+
}
|
|
94
|
+
evaluator.release();
|
|
95
|
+
return model;
|
|
96
|
+
};
|
|
97
|
+
|
|
59
98
|
export interface Engine {
|
|
60
99
|
query(query: number): number;
|
|
100
|
+
getModel(): ProtoModel;
|
|
61
101
|
}
|
|
62
102
|
|
|
63
103
|
type EngineFactory = (context: DatalogContext, engine: number) => Engine;
|
|
@@ -77,12 +117,13 @@ export class DatalogContext {
|
|
|
77
117
|
private engineType = ENGINE_LAST;
|
|
78
118
|
private engine: Engine | undefined;
|
|
79
119
|
readonly rewriter: Rewriter;
|
|
80
|
-
|
|
120
|
+
// m_mc: the converters since the last query, or undefined before one.
|
|
121
|
+
modelConverters: ModelConverter[] | undefined;
|
|
81
122
|
|
|
82
123
|
constructor(
|
|
83
124
|
readonly manager: AstManager,
|
|
84
125
|
readonly params: FpParams,
|
|
85
|
-
rewriterOptions: RewriterOptions,
|
|
126
|
+
readonly rewriterOptions: RewriterOptions,
|
|
86
127
|
private engineFactory: EngineFactory,
|
|
87
128
|
) {
|
|
88
129
|
this.ruleManager = new RuleManager(manager, this);
|
|
@@ -288,12 +329,25 @@ export class DatalogContext {
|
|
|
288
329
|
}
|
|
289
330
|
|
|
290
331
|
query(query: number) {
|
|
291
|
-
this.
|
|
332
|
+
this.modelConverters = [];
|
|
292
333
|
this.getEngine(query);
|
|
293
334
|
this.flushAddRules();
|
|
294
335
|
return this.ensureEngine(query).query(query);
|
|
295
336
|
}
|
|
296
337
|
|
|
338
|
+
addGenericModelConverter(definitions: readonly Definition[]) {
|
|
339
|
+
if (this.modelConverters === undefined) return;
|
|
340
|
+
for (const definition of definitions) {
|
|
341
|
+
this.manager.incDeclRef(definition.decl);
|
|
342
|
+
if (definition.def !== -1) this.manager.incRef(definition.def);
|
|
343
|
+
}
|
|
344
|
+
this.modelConverters.push((model) => applyDefinitions(definitions, model));
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
getModel() {
|
|
348
|
+
return this.ensureEngine().getModel();
|
|
349
|
+
}
|
|
350
|
+
|
|
297
351
|
// engine_base::query over one relation.
|
|
298
352
|
relQuery(relation: number) {
|
|
299
353
|
const manager = this.manager;
|
|
@@ -1,6 +1,9 @@
|
|
|
1
1
|
// Ported from Z3 (src/muz/transforms/dl_mk_coi_filter.cpp, src/muz/dataflow/dataflow.h,
|
|
2
2
|
// src/muz/dataflow/reachability.h), MIT license, see z3-license.txt.
|
|
3
|
+
import { ObjHashtable, ObjMap } from "../hashtable";
|
|
3
4
|
import type { DatalogContext } from "./dl-context";
|
|
5
|
+
import type { Rule } from "./dl-rule";
|
|
6
|
+
import { HornSubsumeModelConverter } from "./horn-subsume-model-converter";
|
|
4
7
|
import { RuleSet } from "./dl-rule-set";
|
|
5
8
|
import type { RuleTransformerPlugin } from "./dl-rule-transformer";
|
|
6
9
|
|
|
@@ -15,30 +18,50 @@ export class MkCoiFilter implements RuleTransformerPlugin {
|
|
|
15
18
|
return this.bottomUp(topDown ?? source) ?? topDown;
|
|
16
19
|
}
|
|
17
20
|
|
|
18
|
-
//
|
|
19
|
-
|
|
21
|
+
// dataflow_engine<reachability_info>::run_bottom_up: whether the rules of a predicate can
|
|
22
|
+
// derive a fact, for the predicates the engine reached.
|
|
23
|
+
private runBottomUp(source: RuleSet) {
|
|
20
24
|
const manager = this.context.manager;
|
|
21
|
-
const
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
reachable.add(head);
|
|
33
|
-
isChanged = true;
|
|
25
|
+
const getHash = (decl: number) => manager.getDeclHash(decl);
|
|
26
|
+
const facts = new ObjMap<boolean>(getHash);
|
|
27
|
+
const body2rules = new Map<number, Rule[]>();
|
|
28
|
+
const todos = [new ObjHashtable(getHash), new ObjHashtable(getHash)];
|
|
29
|
+
let todoIndex = 0;
|
|
30
|
+
for (const rule of source.rules) {
|
|
31
|
+
for (let index = 0; index < rule.uninterpretedSize; index++) {
|
|
32
|
+
const decl = rule.getTailDecl(manager, index);
|
|
33
|
+
const users = body2rules.get(decl);
|
|
34
|
+
if (users === undefined) body2rules.set(decl, [rule]);
|
|
35
|
+
else users.push(rule);
|
|
34
36
|
}
|
|
37
|
+
const head = rule.getDecl(manager);
|
|
38
|
+
if (rule.positiveSize !== 0 || facts.get(head) === true) continue;
|
|
39
|
+
facts.set(head, true);
|
|
40
|
+
todos[todoIndex].add(head);
|
|
35
41
|
}
|
|
36
|
-
|
|
42
|
+
while (todos[todoIndex].size > 0) {
|
|
43
|
+
for (const decl of todos[todoIndex])
|
|
44
|
+
for (const rule of body2rules.get(decl) ?? []) {
|
|
45
|
+
const head = rule.getDecl(manager);
|
|
46
|
+
if (!facts.has(head)) facts.set(head, false);
|
|
47
|
+
if (facts.get(head) === true) continue;
|
|
48
|
+
let isFiring = true;
|
|
49
|
+
for (let index = 0; isFiring && index < rule.positiveSize; index++)
|
|
50
|
+
isFiring = facts.get(rule.getTailDecl(manager, index)) === true;
|
|
51
|
+
if (!isFiring) continue;
|
|
52
|
+
facts.set(head, true);
|
|
53
|
+
todos[1 - todoIndex].add(head);
|
|
54
|
+
}
|
|
55
|
+
todos[todoIndex] = new ObjHashtable(getHash);
|
|
56
|
+
todoIndex = 1 - todoIndex;
|
|
57
|
+
}
|
|
58
|
+
return facts;
|
|
37
59
|
}
|
|
38
60
|
|
|
39
61
|
private bottomUp(source: RuleSet) {
|
|
40
62
|
const manager = this.context.manager;
|
|
41
|
-
const
|
|
63
|
+
const facts = this.runBottomUp(source);
|
|
64
|
+
const unreachable = new ObjHashtable((decl) => manager.getDeclHash(decl));
|
|
42
65
|
const result = new RuleSet(this.context);
|
|
43
66
|
result.inheritPredicates(source);
|
|
44
67
|
for (const rule of source.rules) {
|
|
@@ -46,7 +69,8 @@ export class MkCoiFilter implements RuleTransformerPlugin {
|
|
|
46
69
|
let newTail: number[] | undefined;
|
|
47
70
|
let newNegated: boolean[] = [];
|
|
48
71
|
for (let index = 0; index < rule.uninterpretedSize; index++) {
|
|
49
|
-
const isReachable =
|
|
72
|
+
const isReachable = facts.get(rule.getTailDecl(manager, index)) === true;
|
|
73
|
+
if (!isReachable) unreachable.add(rule.getTailDecl(manager, index));
|
|
50
74
|
if (rule.isNegated[index]) {
|
|
51
75
|
if (!isReachable && newTail === undefined) {
|
|
52
76
|
newTail = rule.tail.slice(0, index);
|
|
@@ -73,6 +97,12 @@ export class MkCoiFilter implements RuleTransformerPlugin {
|
|
|
73
97
|
}
|
|
74
98
|
if (result.rules.length === source.rules.length) return undefined;
|
|
75
99
|
result.close();
|
|
100
|
+
if (this.context.modelConverters !== undefined) {
|
|
101
|
+
for (const [decl, isReachable] of facts) if (!isReachable) unreachable.add(decl);
|
|
102
|
+
this.context.addGenericModelConverter(
|
|
103
|
+
[...unreachable].map((decl) => ({ decl, def: manager.falseExpr })),
|
|
104
|
+
);
|
|
105
|
+
}
|
|
76
106
|
return result;
|
|
77
107
|
}
|
|
78
108
|
|
|
@@ -103,6 +133,7 @@ export class MkCoiFilter implements RuleTransformerPlugin {
|
|
|
103
133
|
const result = new RuleSet(this.context);
|
|
104
134
|
result.inheritPredicates(source);
|
|
105
135
|
const seen = new Set<number>();
|
|
136
|
+
const prunedPreds = new ObjHashtable((decl) => manager.getDeclHash(decl));
|
|
106
137
|
for (const rule of source.rules) {
|
|
107
138
|
const predicate = rule.getDecl(manager);
|
|
108
139
|
if (seen.has(predicate)) continue;
|
|
@@ -111,11 +142,28 @@ export class MkCoiFilter implements RuleTransformerPlugin {
|
|
|
111
142
|
for (const kept of source.getPredicateRules(predicate)) result.addRule(kept);
|
|
112
143
|
continue;
|
|
113
144
|
}
|
|
114
|
-
if (
|
|
145
|
+
if (this.context.modelConverters === undefined) continue;
|
|
115
146
|
for (const pruned of source.getPredicateRules(predicate))
|
|
116
147
|
for (let index = 0; index < pruned.uninterpretedSize; index++)
|
|
117
148
|
if (pruned.getTailDecl(manager, index) !== predicate) return undefined;
|
|
149
|
+
prunedPreds.add(predicate);
|
|
118
150
|
}
|
|
119
|
-
|
|
151
|
+
if (result.rules.length === source.rules.length) return undefined;
|
|
152
|
+
if (this.context.modelConverters !== undefined && prunedPreds.size > 0) {
|
|
153
|
+
const horn = new HornSubsumeModelConverter(this.context);
|
|
154
|
+
this.context.addGenericModelConverter(
|
|
155
|
+
[...prunedPreds].map((decl) => ({
|
|
156
|
+
decl,
|
|
157
|
+
def: manager.mkOr(
|
|
158
|
+
source
|
|
159
|
+
.getPredicateRules(decl)
|
|
160
|
+
.map((rule) =>
|
|
161
|
+
horn.mkHorn(rule.head, manager.mkAnd(rule.tail.slice(rule.uninterpretedSize))),
|
|
162
|
+
),
|
|
163
|
+
),
|
|
164
|
+
})),
|
|
165
|
+
);
|
|
166
|
+
}
|
|
167
|
+
return result;
|
|
120
168
|
}
|
|
121
169
|
}
|
|
@@ -24,7 +24,13 @@ class BlastTermIte extends RewriterTpl {
|
|
|
24
24
|
reduceApp(decl: number, args: number[], sort: number): number | Rewrite {
|
|
25
25
|
const manager = this.manager;
|
|
26
26
|
if (decl === OP_ITE) return -1;
|
|
27
|
-
|
|
27
|
+
// The product wraps as Z3's unsigned one does.
|
|
28
|
+
if (
|
|
29
|
+
this.maxInflation < 0xffffffff &&
|
|
30
|
+
this.initTermSize > 0 &&
|
|
31
|
+
Math.imul(this.maxInflation, this.initTermSize) >>> 0 < this.numFresh
|
|
32
|
+
)
|
|
33
|
+
return -1;
|
|
28
34
|
for (let index = 0; index < args.length; index++) {
|
|
29
35
|
const arg = args[index];
|
|
30
36
|
if (manager.sorts[arg] === SORT_BOOL || manager.getOp(arg) !== OP_ITE) continue;
|
|
@@ -1,10 +1,12 @@
|
|
|
1
1
|
// Ported from Z3 (src/muz/transforms/dl_mk_rule_inliner.cpp), MIT license, see z3-license.txt.
|
|
2
2
|
import { SmtUnsupportedError } from "../../../../errors";
|
|
3
|
+
import { L_FALSE, L_UNDEF } from "../lbool";
|
|
3
4
|
import type { DatalogContext } from "./dl-context";
|
|
4
5
|
import { MkInterpTailSimplifier } from "./dl-mk-interp-tail-simplifier";
|
|
5
6
|
import { getRuleVars, type Rule } from "./dl-rule";
|
|
6
7
|
import { RuleSet } from "./dl-rule-set";
|
|
7
8
|
import { removeDuplicateTails, type RuleTransformerPlugin } from "./dl-rule-transformer";
|
|
9
|
+
import { HornSubsumeModelConverter } from "./horn-subsume-model-converter";
|
|
8
10
|
import { Substitution } from "./substitution";
|
|
9
11
|
|
|
10
12
|
class RuleUnifier {
|
|
@@ -50,7 +52,7 @@ class RuleUnifier {
|
|
|
50
52
|
this.subst.apply(target.head, 0, this.deltas),
|
|
51
53
|
tail,
|
|
52
54
|
isNegated,
|
|
53
|
-
`${target.
|
|
55
|
+
`${target.getNameText()};${source.getNameText()}`,
|
|
54
56
|
),
|
|
55
57
|
true,
|
|
56
58
|
);
|
|
@@ -58,9 +60,6 @@ class RuleUnifier {
|
|
|
58
60
|
}
|
|
59
61
|
}
|
|
60
62
|
|
|
61
|
-
const hasQuantifier = (context: DatalogContext, rule: Rule) =>
|
|
62
|
-
context.ruleManager.hasQuantifiers(rule);
|
|
63
|
-
|
|
64
63
|
// The rules at a position of a head or tail, and which of them can still be expanded or removed.
|
|
65
64
|
class Visitor {
|
|
66
65
|
readonly positions = new Map<number, number[]>();
|
|
@@ -98,6 +97,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
98
97
|
private tailVisitor = new Visitor();
|
|
99
98
|
// Z3 throws has_new_quantifier when it would inline a rule that has a quantifier.
|
|
100
99
|
private hasNewQuantifier = false;
|
|
100
|
+
private modelConverter: HornSubsumeModelConverter | undefined;
|
|
101
101
|
|
|
102
102
|
constructor(
|
|
103
103
|
private context: DatalogContext,
|
|
@@ -109,7 +109,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
109
109
|
|
|
110
110
|
private tryToInlineRule(target: Rule, source: Rule, tailIndex: number): Rule | undefined {
|
|
111
111
|
this.context.ruleManager.normVars(target);
|
|
112
|
-
if (
|
|
112
|
+
if (this.context.ruleManager.hasQuantifiers(source)) {
|
|
113
113
|
this.hasNewQuantifier = true;
|
|
114
114
|
return undefined;
|
|
115
115
|
}
|
|
@@ -213,10 +213,18 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
213
213
|
if (this.forbidMultipleMultipliers(source, candidates))
|
|
214
214
|
candidates = this.createAllowedRuleSet(source);
|
|
215
215
|
for (const stratum of candidates.getStrats())
|
|
216
|
-
for (const rule of candidates.getPredicateRules(stratum.values().next().value as number))
|
|
216
|
+
for (const rule of candidates.getPredicateRules(stratum.values().next().value as number)) {
|
|
217
217
|
this.transformRule(source, rule, this.inlinedRules);
|
|
218
|
+
// Z3 does not catch the has_new_quantifier that plan_inlining throws, and aborts.
|
|
219
|
+
if (this.hasNewQuantifier)
|
|
220
|
+
throw new SmtUnsupportedError("inlining a rule with a quantifier");
|
|
221
|
+
}
|
|
222
|
+
for (const rule of this.inlinedRules.rules) this.modelConverter?.delRule(rule, L_UNDEF);
|
|
218
223
|
}
|
|
219
224
|
|
|
225
|
+
// Deviation from Z3: transform_rule keeps a rule that has a quantifier without inlining the rest
|
|
226
|
+
// of its tail, although the rules of those predicates are dropped, so Z3 answers unreachable for
|
|
227
|
+
// a reachable query (dl_mk_rule_inliner.cpp). The rest of the tail is inlined here.
|
|
220
228
|
private transformRule(source: RuleSet, original: Rule, target: RuleSet) {
|
|
221
229
|
const manager = this.context.manager;
|
|
222
230
|
let isModified = false;
|
|
@@ -239,6 +247,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
239
247
|
if (result !== undefined) todo.push(result);
|
|
240
248
|
}
|
|
241
249
|
}
|
|
250
|
+
if (isModified) this.modelConverter?.delRule(original, L_UNDEF);
|
|
242
251
|
return isModified;
|
|
243
252
|
}
|
|
244
253
|
|
|
@@ -253,6 +262,10 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
253
262
|
isDone = true;
|
|
254
263
|
if (this.hasNewQuantifier) break;
|
|
255
264
|
}
|
|
265
|
+
if (isDone)
|
|
266
|
+
for (const rule of source.rules)
|
|
267
|
+
if (this.isInliningAllowed(source, rule.getDecl(manager)))
|
|
268
|
+
this.modelConverter?.delRule(rule, L_UNDEF);
|
|
256
269
|
return isDone;
|
|
257
270
|
}
|
|
258
271
|
|
|
@@ -297,9 +310,15 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
297
310
|
candidate = predicateRule;
|
|
298
311
|
}
|
|
299
312
|
if (isAmbiguous) continue;
|
|
300
|
-
if (candidate === undefined)
|
|
313
|
+
if (candidate === undefined) {
|
|
314
|
+
this.modelConverter?.delRule(rule, L_FALSE);
|
|
315
|
+
return null;
|
|
316
|
+
}
|
|
301
317
|
if (!this.isOrientedRewriter(candidate, rules)) continue;
|
|
302
|
-
|
|
318
|
+
const inlined = this.tryToInlineRule(rule, candidate, index);
|
|
319
|
+
if (inlined !== undefined) return inlined;
|
|
320
|
+
this.modelConverter?.delRule(rule, L_FALSE);
|
|
321
|
+
return null;
|
|
303
322
|
}
|
|
304
323
|
return undefined;
|
|
305
324
|
}
|
|
@@ -384,6 +403,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
384
403
|
canExpand[index] = canExpand[other];
|
|
385
404
|
if (tailUnifiers.length === 1) {
|
|
386
405
|
isValid[other] = false;
|
|
406
|
+
this.modelConverter?.delRule(otherRule, L_UNDEF);
|
|
387
407
|
this.delRule(otherRule, other);
|
|
388
408
|
}
|
|
389
409
|
}
|
|
@@ -397,8 +417,14 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
397
417
|
|
|
398
418
|
apply(source: RuleSet) {
|
|
399
419
|
if (source.rules.length === 0) return undefined;
|
|
400
|
-
if (source.rules.some((rule) =>
|
|
420
|
+
if (source.rules.some((rule) => this.context.ruleManager.hasQuantifiers(rule)))
|
|
421
|
+
return undefined;
|
|
401
422
|
this.hasNewQuantifier = false;
|
|
423
|
+
this.modelConverter =
|
|
424
|
+
this.context.modelConverters === undefined
|
|
425
|
+
? undefined
|
|
426
|
+
: new HornSubsumeModelConverter(this.context);
|
|
427
|
+
const converter = this.modelConverter;
|
|
402
428
|
let isDone = false;
|
|
403
429
|
let result = new RuleSet(this.context);
|
|
404
430
|
if (this.context.params.getBool("xform.inline_eager", true)) {
|
|
@@ -422,6 +448,9 @@ export class MkRuleInliner implements RuleTransformerPlugin {
|
|
|
422
448
|
}
|
|
423
449
|
}
|
|
424
450
|
if (this.hasNewQuantifier) throw new SmtUnsupportedError("inlining a rule with a quantifier");
|
|
425
|
-
|
|
451
|
+
if (!isDone) return undefined;
|
|
452
|
+
if (converter !== undefined)
|
|
453
|
+
this.context.modelConverters?.push((model) => converter.apply(model));
|
|
454
|
+
return result;
|
|
426
455
|
}
|
|
427
456
|
}
|
|
@@ -1,8 +1,10 @@
|
|
|
1
1
|
// Ported from Z3 (src/muz/transforms/dl_mk_slice.cpp), MIT license, see z3-license.txt.
|
|
2
2
|
import { getSymbolName, KIND_VAR, OP_EQ, OP_ITE, SORT_BOOL } from "../ast";
|
|
3
3
|
import { flattenAndVector } from "../ast-util";
|
|
4
|
+
import { ObjMap } from "../hashtable";
|
|
5
|
+
import { FuncInterp, ProtoModel } from "../proto-model";
|
|
4
6
|
import { RefVector } from "../ref-vector";
|
|
5
|
-
import { getFreeVarSorts } from "../var-subst";
|
|
7
|
+
import { getFreeVarSorts, VarSubst } from "../var-subst";
|
|
6
8
|
import type { DatalogContext } from "./dl-context";
|
|
7
9
|
import type { Rule } from "./dl-rule";
|
|
8
10
|
import { RuleSet } from "./dl-rule-set";
|
|
@@ -10,14 +12,19 @@ import type { RuleTransformerPlugin } from "./dl-rule-transformer";
|
|
|
10
12
|
|
|
11
13
|
export class MkSlice implements RuleTransformerPlugin {
|
|
12
14
|
readonly priority = 1;
|
|
13
|
-
private sliceable
|
|
15
|
+
private sliceable: ObjMap<boolean[]>;
|
|
14
16
|
private input: boolean[] = [];
|
|
15
17
|
private output: boolean[] = [];
|
|
16
18
|
private isVarSliceable: boolean[] = [];
|
|
17
19
|
private solvedVars: number[] = [];
|
|
18
20
|
readonly predicates = new Map<number, number>();
|
|
21
|
+
// slice_model_converter::m_slice2old
|
|
22
|
+
private slice2old: ObjMap<number>;
|
|
19
23
|
|
|
20
|
-
constructor(private context: DatalogContext) {
|
|
24
|
+
constructor(private context: DatalogContext) {
|
|
25
|
+
this.sliceable = new ObjMap((decl) => context.manager.getDeclHash(decl));
|
|
26
|
+
this.slice2old = new ObjMap((decl) => context.manager.getDeclHash(decl));
|
|
27
|
+
}
|
|
21
28
|
|
|
22
29
|
private getPredicateSlice(predicate: number) {
|
|
23
30
|
const existing = this.sliceable.get(predicate);
|
|
@@ -82,7 +89,7 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
82
89
|
const manager = this.context.manager;
|
|
83
90
|
if (manager.getOp(expr) === OP_ITE) {
|
|
84
91
|
const thenEq = this.getEq(manager.getArg(expr, 1));
|
|
85
|
-
const elseEq = this.getEq(manager.getArg(expr, 2));
|
|
92
|
+
const elseEq = thenEq === undefined ? undefined : this.getEq(manager.getArg(expr, 2));
|
|
86
93
|
if (thenEq !== undefined && elseEq !== undefined && thenEq.index === elseEq.index)
|
|
87
94
|
return {
|
|
88
95
|
index: thenEq.index,
|
|
@@ -95,11 +102,13 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
95
102
|
}
|
|
96
103
|
if (manager.kinds[expr] === KIND_VAR)
|
|
97
104
|
return { index: manager.values[expr], value: manager.trueExpr };
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
if (manager.
|
|
101
|
-
|
|
102
|
-
|
|
105
|
+
// is_not rebinds the expression to its argument, so the equation under a negation is solved.
|
|
106
|
+
const atom = manager.isNot(expr) ? manager.getArg(expr, 0) : expr;
|
|
107
|
+
if (atom !== expr && manager.kinds[atom] === KIND_VAR)
|
|
108
|
+
return { index: manager.values[atom], value: manager.falseExpr };
|
|
109
|
+
if (manager.getOp(atom) !== OP_EQ) return undefined;
|
|
110
|
+
const left = manager.getArg(atom, 0);
|
|
111
|
+
const right = manager.getArg(atom, 1);
|
|
103
112
|
if (manager.kinds[left] === KIND_VAR) return { index: manager.values[left], value: right };
|
|
104
113
|
if (manager.kinds[right] === KIND_VAR) return { index: manager.values[right], value: left };
|
|
105
114
|
return undefined;
|
|
@@ -214,6 +223,7 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
214
223
|
);
|
|
215
224
|
this.predicates.set(predicate, sliced);
|
|
216
225
|
target.inheritPredicate(source, predicate, sliced);
|
|
226
|
+
this.slice2old.set(sliced, predicate);
|
|
217
227
|
} else if (source.isOutputPredicate(predicate)) {
|
|
218
228
|
target.setOutputPredicate(predicate);
|
|
219
229
|
hasOutput = true;
|
|
@@ -246,16 +256,14 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
246
256
|
return;
|
|
247
257
|
}
|
|
248
258
|
this.initVars(rule);
|
|
259
|
+
const head = this.updatePredicate(rule.head);
|
|
249
260
|
const tail = rule.tail
|
|
250
261
|
.slice(0, rule.uninterpretedSize)
|
|
251
262
|
.map((atom) => this.updatePredicate(atom));
|
|
252
263
|
const conjs = this.getTailConjs(rule);
|
|
253
264
|
tail.push(...conjs.items);
|
|
254
265
|
const ruleManager = this.context.ruleManager;
|
|
255
|
-
const updated = ruleManager.fixUnboundVars(
|
|
256
|
-
ruleManager.mk(this.updatePredicate(rule.head), tail, [], rule.name),
|
|
257
|
-
false,
|
|
258
|
-
);
|
|
266
|
+
const updated = ruleManager.fixUnboundVars(ruleManager.mk(head, tail, [], rule.name), false);
|
|
259
267
|
conjs.reset();
|
|
260
268
|
target.addRule(updated);
|
|
261
269
|
}
|
|
@@ -273,6 +281,61 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
273
281
|
this.declarePredicates(source, result);
|
|
274
282
|
if (this.predicates.size === 0) return undefined;
|
|
275
283
|
for (const rule of source.rules) this.updateRule(rule, result);
|
|
284
|
+
const slice2old = this.slice2old;
|
|
285
|
+
const sliceable = new Map([...this.sliceable].map((entry) => [entry[0], [...entry[1]]]));
|
|
286
|
+
this.context.modelConverters?.push((model) => this.convertModel(model, slice2old, sliceable));
|
|
276
287
|
return result;
|
|
277
288
|
}
|
|
289
|
+
|
|
290
|
+
// slice_model_converter::operator(): the interpretation of a sliced predicate over the
|
|
291
|
+
// arguments of the predicate it was sliced from.
|
|
292
|
+
private convertModel(
|
|
293
|
+
model: ProtoModel,
|
|
294
|
+
slice2old: ObjMap<number>,
|
|
295
|
+
sliceable: ReadonlyMap<number, boolean[]>,
|
|
296
|
+
) {
|
|
297
|
+
const manager = this.context.manager;
|
|
298
|
+
const oldModel = new ProtoModel(manager);
|
|
299
|
+
const varSubst = new VarSubst(manager, false);
|
|
300
|
+
for (const [sliced, predicate] of slice2old) {
|
|
301
|
+
// Z3 drops the interpretation of a predicate that has every argument sliced.
|
|
302
|
+
if (manager.funcDecls[sliced].domain.length === 0) continue;
|
|
303
|
+
const slice = sliceable.get(predicate) ?? [];
|
|
304
|
+
const domain = manager.funcDecls[predicate].domain;
|
|
305
|
+
const subst = domain
|
|
306
|
+
.map((sort, index) => manager.mkVar(index, sort))
|
|
307
|
+
.filter((_, index) => !slice[index]);
|
|
308
|
+
const interp = model.funcInterps.get(sliced);
|
|
309
|
+
if (interp === undefined) continue;
|
|
310
|
+
const oldInterp = new FuncInterp(manager, slice.length);
|
|
311
|
+
if (interp.elseExpr !== null) {
|
|
312
|
+
const elseExpr = varSubst.apply(interp.elseExpr, subst);
|
|
313
|
+
oldInterp.setElse(elseExpr);
|
|
314
|
+
manager.decRef(elseExpr);
|
|
315
|
+
}
|
|
316
|
+
for (const entry of interp.entries) {
|
|
317
|
+
let next = 0;
|
|
318
|
+
const args = domain.map((sort, index) =>
|
|
319
|
+
slice[index] ? manager.mkVar(index, sort) : varSubst.apply(entry.args[next++], subst),
|
|
320
|
+
);
|
|
321
|
+
const result = varSubst.apply(entry.result, subst);
|
|
322
|
+
oldInterp.insertEntry(args, result);
|
|
323
|
+
manager.decRef(result);
|
|
324
|
+
args.forEach((arg, index) => {
|
|
325
|
+
if (!slice[index]) manager.decRef(arg);
|
|
326
|
+
});
|
|
327
|
+
}
|
|
328
|
+
oldModel.registerFunc(predicate, oldInterp);
|
|
329
|
+
}
|
|
330
|
+
for (const decl of model.getConstDecls()) {
|
|
331
|
+
const value = model.constInterps.get(decl);
|
|
332
|
+
if (value !== undefined && !slice2old.has(decl)) oldModel.registerConst(decl, value);
|
|
333
|
+
}
|
|
334
|
+
for (const decl of model.getFuncDecls()) {
|
|
335
|
+
const interp = model.funcInterps.get(decl);
|
|
336
|
+
if (interp !== undefined && !slice2old.has(decl)) oldModel.registerFunc(decl, interp.copy());
|
|
337
|
+
}
|
|
338
|
+
varSubst.release();
|
|
339
|
+
return oldModel;
|
|
340
|
+
}
|
|
278
341
|
}
|