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
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
// Ported from Z3 (src/muz/transforms/dl_mk_subsumption_checker.cpp,
|
|
2
2
|
// src/muz/base/dl_rule_subsumption_index.cpp), MIT license, see z3-license.txt.
|
|
3
3
|
import { KIND_VAR } from "../ast";
|
|
4
|
+
import { ObjHashtable } from "../hashtable";
|
|
4
5
|
import type { DatalogContext } from "./dl-context";
|
|
5
6
|
import type { Rule } from "./dl-rule";
|
|
6
7
|
import { RuleSet } from "./dl-rule-set";
|
|
@@ -28,14 +29,16 @@ class RuleSubsumptionIndex {
|
|
|
28
29
|
}
|
|
29
30
|
|
|
30
31
|
export class MkSubsumptionChecker implements RuleTransformerPlugin {
|
|
31
|
-
private totalRelations
|
|
32
|
+
private totalRelations: ObjHashtable;
|
|
32
33
|
private definingRules = new Map<number, Rule>();
|
|
33
34
|
private hasNewTotalRule = false;
|
|
34
35
|
|
|
35
36
|
constructor(
|
|
36
37
|
private context: DatalogContext,
|
|
37
38
|
readonly priority: number,
|
|
38
|
-
) {
|
|
39
|
+
) {
|
|
40
|
+
this.totalRelations = new ObjHashtable((decl) => context.manager.getDeclHash(decl));
|
|
41
|
+
}
|
|
39
42
|
|
|
40
43
|
private isTotalRule(rule: Rule) {
|
|
41
44
|
const manager = this.context.manager;
|
|
@@ -136,6 +139,10 @@ export class MkSubsumptionChecker implements RuleTransformerPlugin {
|
|
|
136
139
|
index.add(transformed);
|
|
137
140
|
}
|
|
138
141
|
target.inheritPredicates(source);
|
|
142
|
+
if (this.totalRelations.size > 0)
|
|
143
|
+
this.context.addGenericModelConverter(
|
|
144
|
+
[...this.totalRelations].map((decl) => ({ decl, def: manager.trueExpr })),
|
|
145
|
+
);
|
|
139
146
|
return isModified;
|
|
140
147
|
}
|
|
141
148
|
|
|
@@ -12,7 +12,6 @@ import { RuleSet } from "./dl-rule-set";
|
|
|
12
12
|
|
|
13
13
|
export interface RuleTransformerPlugin {
|
|
14
14
|
readonly priority: number;
|
|
15
|
-
readonly canDestratifyNegation?: boolean;
|
|
16
15
|
apply(source: RuleSet): RuleSet | undefined;
|
|
17
16
|
}
|
|
18
17
|
|
|
@@ -50,7 +49,6 @@ export const transformRules = (context: DatalogContext, plugins: RuleTransformer
|
|
|
50
49
|
context.manager.limit.checkpoint();
|
|
51
50
|
const result = plugin.apply(rules);
|
|
52
51
|
if (result === undefined) continue;
|
|
53
|
-
if (plugin.canDestratifyNegation === true && !result.isClosed() && !result.close()) continue;
|
|
54
52
|
isModified = true;
|
|
55
53
|
rules = result;
|
|
56
54
|
rules.ensureClosed();
|
|
@@ -3,6 +3,7 @@
|
|
|
3
3
|
import { SmtTacticError, SmtUnsupportedError } from "../../../../errors";
|
|
4
4
|
import {
|
|
5
5
|
type AstManager,
|
|
6
|
+
getSymbolName,
|
|
6
7
|
KIND_APP,
|
|
7
8
|
KIND_QUANTIFIER,
|
|
8
9
|
KIND_VAR,
|
|
@@ -14,6 +15,7 @@ import {
|
|
|
14
15
|
} from "../ast";
|
|
15
16
|
import { flattenAndVector } from "../ast-util";
|
|
16
17
|
import { RefVector } from "../ref-vector";
|
|
18
|
+
import { DEFAULT_PRINT_OPTIONS, printExpr } from "../smt2-printer";
|
|
17
19
|
import { getFreeVarSorts, VarSubst } from "../var-subst";
|
|
18
20
|
import { simplifyQuantifiers } from "../qe";
|
|
19
21
|
import { QuantifierHoister } from "../quant-hoist";
|
|
@@ -21,6 +23,24 @@ import type { DatalogContext } from "./dl-context";
|
|
|
21
23
|
import { Hnf } from "./hnf";
|
|
22
24
|
import type { RuleSet } from "./dl-rule-set";
|
|
23
25
|
|
|
26
|
+
const PRINT_ENVIRONMENT = {
|
|
27
|
+
options: DEFAULT_PRINT_OPTIONS,
|
|
28
|
+
isUsed: () => false,
|
|
29
|
+
isClashing: () => false,
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
export const mkPp = (manager: AstManager, expr: number) =>
|
|
33
|
+
printExpr(manager, PRINT_ENVIRONMENT, expr);
|
|
34
|
+
|
|
35
|
+
// output_predicate of src/muz/base/dl_util.cpp.
|
|
36
|
+
const outputPredicate = (manager: AstManager, predicate: number) =>
|
|
37
|
+
`${getSymbolName(manager.funcDecls[manager.decls[predicate]].name)}(${manager
|
|
38
|
+
.getArgs(predicate)
|
|
39
|
+
.map((arg) =>
|
|
40
|
+
manager.kinds[arg] === KIND_VAR ? `#${manager.values[arg]}` : mkPp(manager, arg),
|
|
41
|
+
)
|
|
42
|
+
.join(",")})`;
|
|
43
|
+
|
|
24
44
|
// The tail lists the positive predicates, then the negated ones, then the interpreted formulas.
|
|
25
45
|
export class Rule {
|
|
26
46
|
constructor(
|
|
@@ -45,6 +65,24 @@ export class Rule {
|
|
|
45
65
|
if (this.isNegated[index]) return true;
|
|
46
66
|
return false;
|
|
47
67
|
}
|
|
68
|
+
|
|
69
|
+
// symbol::str of the name, where the empty name is the null symbol.
|
|
70
|
+
getNameText() {
|
|
71
|
+
return this.name === "" ? "<null>" : this.name;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
display(context: DatalogContext) {
|
|
75
|
+
const manager = context.manager;
|
|
76
|
+
const head = `${this.getNameText()}:\n${outputPredicate(manager, this.head)}`;
|
|
77
|
+
if (this.tail.length === 0) return `${head}.\n`;
|
|
78
|
+
const tail = this.tail.map(
|
|
79
|
+
(literal, index) =>
|
|
80
|
+
`\n ${this.isNegated[index] ? "not " : ""}${
|
|
81
|
+
context.isPredicate(literal) ? outputPredicate(manager, literal) : mkPp(manager, literal)
|
|
82
|
+
}`,
|
|
83
|
+
);
|
|
84
|
+
return `${head} :- ${tail.join(",")}.\n`;
|
|
85
|
+
}
|
|
48
86
|
}
|
|
49
87
|
|
|
50
88
|
// The sorts of the free variables of the expressions, by index, as Z3's used_vars collects them.
|
|
@@ -100,46 +138,71 @@ export class BindVariables {
|
|
|
100
138
|
const bound = new Map<number, number>();
|
|
101
139
|
const names: string[] = [];
|
|
102
140
|
const sorts: number[] = [];
|
|
141
|
+
const todo: number[] = [];
|
|
142
|
+
// The arguments of an application are abstracted last to first, as Z3's stack pops them.
|
|
103
143
|
const abstract = (term: number, scope: number, cache: Map<number, number>): number => {
|
|
104
|
-
const
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
if (
|
|
109
|
-
|
|
110
|
-
|
|
144
|
+
const size = todo.length;
|
|
145
|
+
todo.push(term);
|
|
146
|
+
while (todo.length > size) {
|
|
147
|
+
const current = todo[todo.length - 1];
|
|
148
|
+
if (cache.has(current)) {
|
|
149
|
+
todo.pop();
|
|
150
|
+
continue;
|
|
151
|
+
}
|
|
152
|
+
const kind = manager.kinds[current];
|
|
153
|
+
if (kind === KIND_VAR) cache.set(current, current);
|
|
154
|
+
else if (kind === KIND_QUANTIFIER) {
|
|
155
|
+
const data = manager.getQuantifier(current);
|
|
111
156
|
const innerScope = scope + data.sorts.length;
|
|
112
157
|
const innerCache = new Map<number, number>();
|
|
113
158
|
const patterns = data.patterns.map((pattern) =>
|
|
114
159
|
abstract(pattern, innerScope, innerCache),
|
|
115
160
|
);
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
161
|
+
cache.set(
|
|
162
|
+
current,
|
|
163
|
+
manager.mkQuantifier({
|
|
164
|
+
...data,
|
|
165
|
+
patterns,
|
|
166
|
+
body: abstract(data.body, innerScope, innerCache),
|
|
167
|
+
}),
|
|
168
|
+
);
|
|
169
|
+
} else if (this.vars.includes(current)) {
|
|
123
170
|
const existing =
|
|
124
|
-
bound.get(
|
|
171
|
+
bound.get(current) ??
|
|
125
172
|
(() => {
|
|
126
|
-
const variable = manager.mkVar(names.length, manager.sorts[
|
|
127
|
-
names.push(manager.getDeclName(
|
|
128
|
-
sorts.push(manager.sorts[
|
|
129
|
-
bound.set(
|
|
173
|
+
const variable = manager.mkVar(names.length, manager.sorts[current]);
|
|
174
|
+
names.push(manager.getDeclName(current));
|
|
175
|
+
sorts.push(manager.sorts[current]);
|
|
176
|
+
bound.set(current, variable);
|
|
130
177
|
return variable;
|
|
131
178
|
})();
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
179
|
+
cache.set(
|
|
180
|
+
current,
|
|
181
|
+
scope === 0
|
|
182
|
+
? existing
|
|
183
|
+
: manager.mkVar(scope + manager.values[existing], manager.sorts[existing]),
|
|
184
|
+
);
|
|
185
|
+
} else {
|
|
186
|
+
const args: number[] = [];
|
|
187
|
+
let isAllVisited = true;
|
|
188
|
+
for (const arg of manager.getArgs(current)) {
|
|
189
|
+
const abstracted = cache.get(arg);
|
|
190
|
+
if (abstracted === undefined) {
|
|
191
|
+
todo.push(arg);
|
|
192
|
+
isAllVisited = false;
|
|
193
|
+
} else if (isAllVisited) args.push(abstracted);
|
|
194
|
+
}
|
|
195
|
+
if (!isAllVisited) continue;
|
|
196
|
+
cache.set(
|
|
197
|
+
current,
|
|
198
|
+
args.every((arg, index) => arg === manager.getArg(current, index))
|
|
199
|
+
? current
|
|
200
|
+
: manager.mkApp(manager.decls[current], args, manager.sorts[current]),
|
|
201
|
+
);
|
|
135
202
|
}
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
: manager.mkApp(manager.decls[term], args, manager.sorts[term]);
|
|
140
|
-
})();
|
|
141
|
-
cache.set(term, result);
|
|
142
|
-
return result;
|
|
203
|
+
todo.pop();
|
|
204
|
+
}
|
|
205
|
+
return cache.get(term) ?? term;
|
|
143
206
|
};
|
|
144
207
|
const body = abstract(fml, 0, new Map());
|
|
145
208
|
if (names.length === 0) return body;
|
|
@@ -359,6 +422,7 @@ export class RuleManager {
|
|
|
359
422
|
names.reverse();
|
|
360
423
|
const queryPredicate = this.context.mkFreshHeadPredicate("query", "", domain);
|
|
361
424
|
rules.setOutputPredicate(queryPredicate);
|
|
425
|
+
this.context.addGenericModelConverter([{ decl: queryPredicate, def: -1 }]);
|
|
362
426
|
const head = manager.mkApp(
|
|
363
427
|
queryPredicate,
|
|
364
428
|
domain.map((sort, index) => manager.mkVar(domain.length - index - 1, sort)),
|
|
@@ -47,8 +47,10 @@ export class Hnf {
|
|
|
47
47
|
if (visited.has(current)) continue;
|
|
48
48
|
visited.add(current);
|
|
49
49
|
const kind = manager.kinds[current];
|
|
50
|
-
if (kind === KIND_QUANTIFIER)
|
|
51
|
-
|
|
50
|
+
if (kind === KIND_QUANTIFIER) {
|
|
51
|
+
const quantifier = manager.getQuantifier(current);
|
|
52
|
+
todo.push(quantifier.body, ...quantifier.patterns, ...quantifier.noPatterns);
|
|
53
|
+
} else if (kind === KIND_APP) {
|
|
52
54
|
if (this.isPredicate(current)) return true;
|
|
53
55
|
manager.pushArgs(current, todo);
|
|
54
56
|
}
|
|
@@ -172,12 +174,11 @@ export class Hnf {
|
|
|
172
174
|
used.forEach((sort, index) => {
|
|
173
175
|
if (sort !== undefined) args.push(manager.mkVar(index, sort));
|
|
174
176
|
});
|
|
177
|
+
// Z3 passes an empty suffix that is not the null symbol, so the name has two separators.
|
|
175
178
|
const decl = manager.mkFreshFuncDecl(
|
|
176
|
-
this.name
|
|
179
|
+
`${this.name}!`,
|
|
177
180
|
args.map((arg) => manager.sorts[arg]),
|
|
178
181
|
SORT_BOOL,
|
|
179
|
-
true,
|
|
180
|
-
"",
|
|
181
182
|
);
|
|
182
183
|
manager.incDeclRef(decl);
|
|
183
184
|
this.freshPredicates.push(decl);
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
// Ported from Z3 (src/ast/converters/horn_subsume_model_converter.cpp, del_rule of
|
|
2
|
+
// src/muz/base/dl_util.cpp), MIT license, see z3-license.txt.
|
|
3
|
+
import {
|
|
4
|
+
FAMILY_USER,
|
|
5
|
+
KIND_APP,
|
|
6
|
+
KIND_QUANTIFIER,
|
|
7
|
+
KIND_VAR,
|
|
8
|
+
OP_AND,
|
|
9
|
+
OP_OR,
|
|
10
|
+
QUANTIFIER_EXISTS,
|
|
11
|
+
SORT_BOOL,
|
|
12
|
+
} from "../ast";
|
|
13
|
+
import { L_FALSE, L_TRUE } from "../lbool";
|
|
14
|
+
import { FuncInterp, type ProtoModel } from "../proto-model";
|
|
15
|
+
import { VarSubst } from "../var-subst";
|
|
16
|
+
import type { DatalogContext } from "./dl-context";
|
|
17
|
+
import { getUsedVars, type Rule } from "./dl-rule";
|
|
18
|
+
|
|
19
|
+
export class HornSubsumeModelConverter {
|
|
20
|
+
private delayHeads: number[] = [];
|
|
21
|
+
private delayBodies: number[] = [];
|
|
22
|
+
private funcs: number[] = [];
|
|
23
|
+
private bodies: number[] = [];
|
|
24
|
+
|
|
25
|
+
constructor(private context: DatalogContext) {}
|
|
26
|
+
|
|
27
|
+
insert(head: number, body: readonly number[]) {
|
|
28
|
+
const manager = this.context.manager;
|
|
29
|
+
const conjunction = this.context.rewriter.mkAnd([...body]);
|
|
30
|
+
manager.incRef(head);
|
|
31
|
+
manager.incRef(conjunction);
|
|
32
|
+
this.delayHeads.push(head);
|
|
33
|
+
this.delayBodies.push(conjunction);
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
// The predicate of the head is the body with the head's arguments as the variables above the
|
|
37
|
+
// existentially bound ones. The result comes with a reference.
|
|
38
|
+
mkHorn(head: number, body: number) {
|
|
39
|
+
const manager = this.context.manager;
|
|
40
|
+
const args = manager.getArgs(head);
|
|
41
|
+
const sorts = getUsedVars(manager, [head, body]).map((sort) => sort ?? SORT_BOOL);
|
|
42
|
+
if (args.length === 0 && sorts.length === 0) {
|
|
43
|
+
manager.incRef(body);
|
|
44
|
+
return body;
|
|
45
|
+
}
|
|
46
|
+
const conjs = [body];
|
|
47
|
+
const subst: number[] = [];
|
|
48
|
+
args.forEach((arg, index) => {
|
|
49
|
+
const variable = manager.mkVar(sorts.length + index, manager.sorts[arg]);
|
|
50
|
+
if (manager.kinds[arg] !== KIND_VAR) {
|
|
51
|
+
conjs.push(manager.mkEq(variable, arg));
|
|
52
|
+
return;
|
|
53
|
+
}
|
|
54
|
+
const argIndex = manager.values[arg];
|
|
55
|
+
while (subst.length <= argIndex) subst.push(-1);
|
|
56
|
+
if (subst[argIndex] === -1) subst[argIndex] = variable;
|
|
57
|
+
else conjs.push(manager.mkEq(variable, subst[argIndex]));
|
|
58
|
+
});
|
|
59
|
+
const conjunction = manager.mkApp(OP_AND, conjs, SORT_BOOL);
|
|
60
|
+
manager.incRef(conjunction);
|
|
61
|
+
const varSubst = new VarSubst(manager, false);
|
|
62
|
+
const substituted = varSubst.apply(conjunction, subst);
|
|
63
|
+
varSubst.release();
|
|
64
|
+
manager.decRef(conjunction);
|
|
65
|
+
if (sorts.length === 0) return substituted;
|
|
66
|
+
const quantified = manager.mkQuantifier({
|
|
67
|
+
kind: QUANTIFIER_EXISTS,
|
|
68
|
+
sorts: sorts.reverse(),
|
|
69
|
+
names: sorts.map((_, index) => sorts.length - index - 1),
|
|
70
|
+
body: substituted,
|
|
71
|
+
patterns: [],
|
|
72
|
+
noPatterns: [],
|
|
73
|
+
weight: 0,
|
|
74
|
+
qid: "",
|
|
75
|
+
});
|
|
76
|
+
manager.incRef(quantified);
|
|
77
|
+
manager.decRef(substituted);
|
|
78
|
+
const result = this.context.simplify(quantified);
|
|
79
|
+
manager.decRef(quantified);
|
|
80
|
+
return result;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
// add_default_proc under for_each_expr: the predicates the model leaves open are false.
|
|
84
|
+
private addDefaultFalseInterpretation(root: number, model: ProtoModel) {
|
|
85
|
+
const manager = this.context.manager;
|
|
86
|
+
const visited = new Set<number>([root]);
|
|
87
|
+
const exprs = [root];
|
|
88
|
+
const positions = [0];
|
|
89
|
+
while (exprs.length > 0) {
|
|
90
|
+
const current = exprs[exprs.length - 1];
|
|
91
|
+
const quantifier =
|
|
92
|
+
manager.kinds[current] === KIND_QUANTIFIER ? manager.getQuantifier(current) : undefined;
|
|
93
|
+
const children =
|
|
94
|
+
quantifier !== undefined
|
|
95
|
+
? [quantifier.body, ...quantifier.patterns, ...quantifier.noPatterns]
|
|
96
|
+
: manager.kinds[current] === KIND_APP
|
|
97
|
+
? manager.getArgs(current)
|
|
98
|
+
: [];
|
|
99
|
+
const position = positions[positions.length - 1];
|
|
100
|
+
if (position < children.length) {
|
|
101
|
+
positions[positions.length - 1]++;
|
|
102
|
+
const child = children[position];
|
|
103
|
+
if (visited.has(child)) continue;
|
|
104
|
+
visited.add(child);
|
|
105
|
+
exprs.push(child);
|
|
106
|
+
positions.push(0);
|
|
107
|
+
continue;
|
|
108
|
+
}
|
|
109
|
+
exprs.pop();
|
|
110
|
+
positions.pop();
|
|
111
|
+
if (manager.kinds[current] !== KIND_APP || manager.sorts[current] !== SORT_BOOL) continue;
|
|
112
|
+
const decl = manager.decls[current];
|
|
113
|
+
const info = manager.funcDecls[decl];
|
|
114
|
+
if (
|
|
115
|
+
info.family !== FAMILY_USER ||
|
|
116
|
+
model.constInterps.has(decl) ||
|
|
117
|
+
model.funcInterps.has(decl)
|
|
118
|
+
)
|
|
119
|
+
continue;
|
|
120
|
+
if (info.domain.length === 0) {
|
|
121
|
+
model.registerConst(decl, manager.falseExpr);
|
|
122
|
+
continue;
|
|
123
|
+
}
|
|
124
|
+
const interp = new FuncInterp(manager, info.domain.length);
|
|
125
|
+
interp.setElse(manager.falseExpr);
|
|
126
|
+
model.registerFunc(decl, interp);
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
apply(model: ProtoModel) {
|
|
131
|
+
const manager = this.context.manager;
|
|
132
|
+
this.delayHeads.forEach((head, index) => {
|
|
133
|
+
this.funcs.push(manager.decls[head]);
|
|
134
|
+
this.bodies.push(this.mkHorn(head, this.delayBodies[index]));
|
|
135
|
+
});
|
|
136
|
+
this.delayHeads = [];
|
|
137
|
+
this.delayBodies = [];
|
|
138
|
+
for (let index = this.funcs.length - 1; index >= 0; index--) {
|
|
139
|
+
const decl = this.funcs[index];
|
|
140
|
+
this.addDefaultFalseInterpretation(this.bodies[index], model);
|
|
141
|
+
const body = model.eval(this.bodies[index], false);
|
|
142
|
+
if (manager.funcDecls[decl].domain.length === 0) {
|
|
143
|
+
const old = model.constInterps.get(decl);
|
|
144
|
+
const merged = old === undefined ? body : manager.mkApp(OP_OR, [old, body], SORT_BOOL);
|
|
145
|
+
const simplified = this.context.simplify(merged);
|
|
146
|
+
model.registerConst(decl, simplified);
|
|
147
|
+
manager.decRef(simplified);
|
|
148
|
+
manager.decRef(body);
|
|
149
|
+
continue;
|
|
150
|
+
}
|
|
151
|
+
const old = model.funcInterps.get(decl);
|
|
152
|
+
const interp = old ?? new FuncInterp(manager, manager.funcDecls[decl].domain.length);
|
|
153
|
+
if (old === undefined) model.registerFunc(decl, interp);
|
|
154
|
+
const oldElse = old === undefined ? null : old.elseExpr;
|
|
155
|
+
const merged = oldElse === null ? body : manager.mkApp(OP_OR, [oldElse, body], SORT_BOOL);
|
|
156
|
+
const simplified = this.context.simplify(merged);
|
|
157
|
+
interp.setElse(simplified);
|
|
158
|
+
manager.decRef(simplified);
|
|
159
|
+
manager.decRef(body);
|
|
160
|
+
}
|
|
161
|
+
return model;
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
// del_rule of dl_util.cpp.
|
|
165
|
+
delRule(rule: Rule, unreachable: number) {
|
|
166
|
+
const manager = this.context.manager;
|
|
167
|
+
this.insert(
|
|
168
|
+
rule.head,
|
|
169
|
+
unreachable === L_TRUE
|
|
170
|
+
? [manager.trueExpr]
|
|
171
|
+
: unreachable === L_FALSE
|
|
172
|
+
? [manager.falseExpr]
|
|
173
|
+
: rule.tail.map((literal, index) =>
|
|
174
|
+
rule.isNegated[index] ? manager.mkNot(literal) : literal,
|
|
175
|
+
),
|
|
176
|
+
);
|
|
177
|
+
}
|
|
178
|
+
}
|
|
@@ -20,7 +20,7 @@ import { RefVector } from "../ref-vector";
|
|
|
20
20
|
import type { RewriterOptions } from "../rewriter";
|
|
21
21
|
import { getFreeVarSorts } from "../var-subst";
|
|
22
22
|
import { DatalogContext, ENGINE_SPACER, FpParams } from "./dl-context";
|
|
23
|
-
import { mkForall } from "./dl-rule";
|
|
23
|
+
import { mkForall, mkPp } from "./dl-rule";
|
|
24
24
|
import { SpacerDlInterface } from "./spacer-dl-interface";
|
|
25
25
|
|
|
26
26
|
export const createDatalogContext = (
|
|
@@ -158,7 +158,8 @@ class HornTactic {
|
|
|
158
158
|
const queries: number[] = [];
|
|
159
159
|
for (const form of goal.forms.items) {
|
|
160
160
|
const kind = this.getFormulaKind(form);
|
|
161
|
-
if (kind === undefined)
|
|
161
|
+
if (kind === undefined)
|
|
162
|
+
throw new SmtTacticError(`formula is not in Horn fragment: ${mkPp(manager, form)}\n`);
|
|
162
163
|
if (kind.isRule) context.addRule(kind.formula);
|
|
163
164
|
else queries.push(kind.formula);
|
|
164
165
|
}
|
|
@@ -173,11 +174,21 @@ class HornTactic {
|
|
|
173
174
|
}
|
|
174
175
|
queries.length = 0;
|
|
175
176
|
queries.push(query);
|
|
177
|
+
goal.addConverter(manager.decls[query]);
|
|
176
178
|
}
|
|
177
179
|
const reachable = context.query(queries[0]);
|
|
178
180
|
goal.depth++;
|
|
179
181
|
if (reachable === L_TRUE && context.isMonotone()) goal.assert(manager.falseExpr);
|
|
180
|
-
if (reachable === L_FALSE)
|
|
182
|
+
if (reachable === L_FALSE) {
|
|
183
|
+
goal.reset();
|
|
184
|
+
// model2model_converter: the interpretations go to the goal's model in table order.
|
|
185
|
+
const found = context.getModel();
|
|
186
|
+
goal.addModelConversion((model) => {
|
|
187
|
+
for (const [decl, value] of found.constInterps) model.registerConst(decl, value);
|
|
188
|
+
for (const [decl, interp] of found.funcInterps) model.registerFunc(decl, interp.copy());
|
|
189
|
+
return model;
|
|
190
|
+
});
|
|
191
|
+
}
|
|
181
192
|
return [goal];
|
|
182
193
|
}
|
|
183
194
|
}
|