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,18 +1,20 @@
|
|
|
1
1
|
// Ported from Z3 (src/ast/substitution/substitution.cpp, src/ast/substitution/unifier.cpp), MIT
|
|
2
2
|
// license, see z3-license.txt.
|
|
3
3
|
import { type AstManager, KIND_APP, KIND_VAR } from "../ast";
|
|
4
|
+
import { VarShifter } from "../rewriter-tpl";
|
|
4
5
|
|
|
5
6
|
interface Binding {
|
|
6
7
|
expr: number;
|
|
7
8
|
offset: number;
|
|
8
9
|
}
|
|
9
10
|
|
|
10
|
-
|
|
11
|
+
// A variable index or an expression at one of the two offsets.
|
|
12
|
+
const getKey = (index: number, offset: number) => 2 * index + offset;
|
|
11
13
|
|
|
12
14
|
// Bindings of variables at offsets to expressions at offsets. Applying it renames each unbound
|
|
13
15
|
// variable at offset i by deltas[i].
|
|
14
16
|
export class Substitution {
|
|
15
|
-
private bindings = new Map<
|
|
17
|
+
private bindings = new Map<number, Binding>();
|
|
16
18
|
|
|
17
19
|
constructor(private manager: AstManager) {}
|
|
18
20
|
|
|
@@ -24,13 +26,15 @@ export class Substitution {
|
|
|
24
26
|
// bindings of variables to variables, where the larger class becomes the root.
|
|
25
27
|
unify(first: number, firstOffset: number, second: number, secondOffset: number) {
|
|
26
28
|
const manager = this.manager;
|
|
27
|
-
const parents = new Map<
|
|
28
|
-
const sizes = new Map<
|
|
29
|
-
const getNodeKey = (node: Binding) =>
|
|
29
|
+
const parents = new Map<number, Binding>();
|
|
30
|
+
const sizes = new Map<number, number>();
|
|
31
|
+
const getNodeKey = (node: Binding) => getKey(node.expr, node.offset);
|
|
30
32
|
for (const [key, root] of [...this.bindings].reverse()) {
|
|
31
33
|
if (manager.kinds[root.expr] !== KIND_VAR) continue;
|
|
32
|
-
const
|
|
33
|
-
|
|
34
|
+
const child = {
|
|
35
|
+
expr: manager.mkVar(Math.floor(key / 2), manager.sorts[root.expr]),
|
|
36
|
+
offset: key % 2,
|
|
37
|
+
};
|
|
34
38
|
const childSize = sizes.get(getNodeKey(child)) ?? 1;
|
|
35
39
|
const rootSize = sizes.get(getNodeKey(root)) ?? 1;
|
|
36
40
|
parents.set(getNodeKey(child), root);
|
|
@@ -95,8 +99,8 @@ export class Substitution {
|
|
|
95
99
|
|
|
96
100
|
private isAcyclic() {
|
|
97
101
|
const manager = this.manager;
|
|
98
|
-
const visiting = new Set<
|
|
99
|
-
const done = new Set<
|
|
102
|
+
const visiting = new Set<number>();
|
|
103
|
+
const done = new Set<number>();
|
|
100
104
|
const visit = (expr: number, offset: number): boolean => {
|
|
101
105
|
if (manager.isGround(expr)) return true;
|
|
102
106
|
if (manager.kinds[expr] === KIND_VAR) {
|
|
@@ -113,11 +117,9 @@ export class Substitution {
|
|
|
113
117
|
if (manager.kinds[expr] !== KIND_APP) return true;
|
|
114
118
|
return manager.getArgs(expr).every((arg) => visit(arg, offset));
|
|
115
119
|
};
|
|
116
|
-
for (const key of this.bindings
|
|
117
|
-
const [offset, index] = key.split(":").map(Number);
|
|
118
|
-
const binding = this.bindings.get(key) as Binding;
|
|
120
|
+
for (const [key, binding] of this.bindings) {
|
|
119
121
|
visiting.clear();
|
|
120
|
-
visiting.add(
|
|
122
|
+
visiting.add(key);
|
|
121
123
|
if (!visit(binding.expr, binding.offset)) return false;
|
|
122
124
|
}
|
|
123
125
|
return true;
|
|
@@ -125,30 +127,79 @@ export class Substitution {
|
|
|
125
127
|
|
|
126
128
|
apply(expr: number, offset: number, deltas: readonly number[] = [0]) {
|
|
127
129
|
const manager = this.manager;
|
|
128
|
-
const cache = new Map<
|
|
129
|
-
const
|
|
130
|
-
|
|
131
|
-
const
|
|
132
|
-
const
|
|
133
|
-
if (
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
130
|
+
const cache = new Map<number, number>();
|
|
131
|
+
const todo = [{ expr, offset }];
|
|
132
|
+
while (todo.length > 0) {
|
|
133
|
+
const node = todo[todo.length - 1];
|
|
134
|
+
const key = getKey(node.expr, node.offset);
|
|
135
|
+
if (cache.has(key)) {
|
|
136
|
+
todo.pop();
|
|
137
|
+
continue;
|
|
138
|
+
}
|
|
139
|
+
const kind = manager.kinds[node.expr];
|
|
140
|
+
if (manager.isGround(node.expr)) cache.set(key, node.expr);
|
|
141
|
+
else if (kind === KIND_VAR) {
|
|
142
|
+
const binding = this.bindings.get(getKey(manager.values[node.expr], node.offset));
|
|
143
|
+
const bound =
|
|
144
|
+
binding === undefined ? undefined : cache.get(getKey(binding.expr, binding.offset));
|
|
145
|
+
if (binding !== undefined && bound === undefined) {
|
|
146
|
+
todo.push(binding);
|
|
147
|
+
continue;
|
|
142
148
|
}
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
149
|
+
const delta = deltas[node.offset] ?? 0;
|
|
150
|
+
cache.set(
|
|
151
|
+
key,
|
|
152
|
+
bound ??
|
|
153
|
+
(delta === 0
|
|
154
|
+
? node.expr
|
|
155
|
+
: manager.mkVar(manager.values[node.expr] + delta, manager.sorts[node.expr])),
|
|
156
|
+
);
|
|
157
|
+
} else if (kind === KIND_APP) {
|
|
158
|
+
let isVisited = true;
|
|
159
|
+
for (let index = manager.getNumArgs(node.expr); index > 0; index--) {
|
|
160
|
+
const arg = manager.getArg(node.expr, index - 1);
|
|
161
|
+
if (cache.has(getKey(arg, node.offset))) continue;
|
|
162
|
+
todo.push({ expr: arg, offset: node.offset });
|
|
163
|
+
isVisited = false;
|
|
164
|
+
}
|
|
165
|
+
if (!isVisited) continue;
|
|
166
|
+
const args = manager
|
|
167
|
+
.getArgs(node.expr)
|
|
168
|
+
.map((arg) => cache.get(getKey(arg, node.offset)) ?? arg);
|
|
169
|
+
cache.set(
|
|
170
|
+
key,
|
|
171
|
+
args.every((arg, index) => arg === manager.getArg(node.expr, index))
|
|
172
|
+
? node.expr
|
|
173
|
+
: manager.mkApp(manager.decls[node.expr], args, manager.sorts[node.expr]),
|
|
174
|
+
);
|
|
175
|
+
} else cache.set(key, this.applyQuantifier(node.expr, node.offset, deltas));
|
|
176
|
+
todo.pop();
|
|
177
|
+
}
|
|
178
|
+
return cache.get(getKey(expr, offset)) ?? expr;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
// The bindings move under the bound variables, by offset and then by variable.
|
|
182
|
+
private applyQuantifier(expr: number, offset: number, deltas: readonly number[]) {
|
|
183
|
+
const manager = this.manager;
|
|
184
|
+
const quantifier = manager.getQuantifier(expr);
|
|
185
|
+
const numVars = quantifier.sorts.length;
|
|
186
|
+
const nested = new Substitution(manager);
|
|
187
|
+
const shifter = new VarShifter(manager);
|
|
188
|
+
const shifted = [...this.bindings]
|
|
189
|
+
.sort((first, second) => (first[0] % 2) - (second[0] % 2) || first[0] - second[0])
|
|
190
|
+
.map((entry) => {
|
|
191
|
+
const moved = shifter.shift(entry[1].expr, 0, numVars, 0);
|
|
192
|
+
nested.bindings.set(entry[0] + 2 * numVars, { expr: moved, offset: entry[1].offset });
|
|
193
|
+
return moved;
|
|
194
|
+
});
|
|
195
|
+
const patterns = quantifier.patterns.map((pattern) => nested.apply(pattern, offset, deltas));
|
|
196
|
+
const noPatterns = quantifier.noPatterns.map((pattern) =>
|
|
197
|
+
nested.apply(pattern, offset, deltas),
|
|
198
|
+
);
|
|
199
|
+
const body = nested.apply(quantifier.body, offset, deltas);
|
|
200
|
+
const result = manager.mkQuantifier({ ...quantifier, patterns, noPatterns, body });
|
|
201
|
+
for (const moved of shifted) manager.decRef(moved);
|
|
202
|
+
shifter.release();
|
|
203
|
+
return result;
|
|
153
204
|
}
|
|
154
205
|
}
|
|
@@ -76,7 +76,7 @@ class DivRewriter extends RewriterTpl {
|
|
|
76
76
|
manager.incRef(result);
|
|
77
77
|
return result;
|
|
78
78
|
}
|
|
79
|
-
if (!manager.
|
|
79
|
+
if (!manager.isGroundApp(num) || !manager.isGroundApp(den)) return -1;
|
|
80
80
|
const name = manager.mkFreshConst("div", SORT_REAL);
|
|
81
81
|
this.trail.push(name);
|
|
82
82
|
this.trail.push(num);
|
|
@@ -315,7 +315,7 @@ class Nlqsat {
|
|
|
315
315
|
isUnsignedPositive(manager.getRationalValue(exponent))
|
|
316
316
|
)
|
|
317
317
|
continue;
|
|
318
|
-
if (op === OP_DIV && manager.
|
|
318
|
+
if (op === OP_DIV && manager.isGroundApp(current)) {
|
|
319
319
|
hasDivs = true;
|
|
320
320
|
continue;
|
|
321
321
|
}
|
|
@@ -925,8 +925,7 @@ export class AlgebraicManager {
|
|
|
925
925
|
if (anum.value instanceof Rational) return [anum.value, anum.value];
|
|
926
926
|
const cell = anum.value;
|
|
927
927
|
const refined = this.um.refineToPrecision(cell.p, cell.lower, cell.upper, precision * 4);
|
|
928
|
-
|
|
929
|
-
return [lower, refined.isInterval ? refined.upper.toRational() : lower];
|
|
928
|
+
return [refined.lower.toRational(), refined.upper.toRational()];
|
|
930
929
|
}
|
|
931
930
|
|
|
932
931
|
displayRootSmt2(anum: Anum) {
|
|
@@ -102,6 +102,11 @@ export class Explain {
|
|
|
102
102
|
this.result = null;
|
|
103
103
|
}
|
|
104
104
|
|
|
105
|
+
reset() {
|
|
106
|
+
this.resetResult();
|
|
107
|
+
this.core.reset();
|
|
108
|
+
}
|
|
109
|
+
|
|
105
110
|
private collectPolys(literals: readonly number[]) {
|
|
106
111
|
return literals.flatMap((literal) => {
|
|
107
112
|
const atom = this.getAtom(literal);
|
|
@@ -405,7 +405,9 @@ export class NlsatSolver {
|
|
|
405
405
|
this.checkpoint();
|
|
406
406
|
if (this.value(literal) === L_FALSE) continue;
|
|
407
407
|
if (this.value(literal) === L_TRUE) return true;
|
|
408
|
-
const atom = this.atoms.getAtom(literal)
|
|
408
|
+
const atom = this.atoms.getAtom(literal);
|
|
409
|
+
if (atom === null)
|
|
410
|
+
throw new SmtInvariantError("a literal of an arithmetic clause has no atom");
|
|
409
411
|
const set = this.evaluator.infeasibleIntervals(atom, (literal & 1) === 1, clause);
|
|
410
412
|
if (set === null) {
|
|
411
413
|
this.propagate(literal, null);
|
|
@@ -657,8 +659,7 @@ export class NlsatSolver {
|
|
|
657
659
|
for (let index = 0; index < sorted.length; index++) clauses[index] = sorted[index];
|
|
658
660
|
}
|
|
659
661
|
|
|
660
|
-
private projectModel() {
|
|
661
|
-
const cube = new ScopedLiterals(this.atoms);
|
|
662
|
+
private projectModel(cube: ScopedLiterals) {
|
|
662
663
|
const seen = new Set<number>();
|
|
663
664
|
for (const clause of this.clauses) {
|
|
664
665
|
this.checkpoint();
|
|
@@ -670,15 +671,17 @@ export class NlsatSolver {
|
|
|
670
671
|
}
|
|
671
672
|
// Strict sector bounds keep every point of the projection extensible.
|
|
672
673
|
this.explain.isFullDimensional = false;
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
678
|
-
|
|
674
|
+
const projected = new ScopedLiterals(this.atoms);
|
|
675
|
+
try {
|
|
676
|
+
for (let variable = this.isInt.length - 1; variable >= 1 && cube.size > 0; variable--) {
|
|
677
|
+
this.checkpoint();
|
|
678
|
+
projected.reset();
|
|
679
|
+
this.explain.projectVariable(variable, cube.literals, projected);
|
|
680
|
+
[cube.literals, projected.literals] = [projected.literals, cube.literals];
|
|
681
|
+
}
|
|
682
|
+
} finally {
|
|
679
683
|
projected.reset();
|
|
680
684
|
}
|
|
681
|
-
return cube;
|
|
682
685
|
}
|
|
683
686
|
|
|
684
687
|
private getCubeSup(cube: ScopedLiterals) {
|
|
@@ -717,28 +720,36 @@ export class NlsatSolver {
|
|
|
717
720
|
this.checkpoint();
|
|
718
721
|
const status = this.check();
|
|
719
722
|
if (status !== L_TRUE) return status;
|
|
720
|
-
const cube = this.
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
723
|
+
const cube = new ScopedLiterals(this.atoms);
|
|
724
|
+
try {
|
|
725
|
+
this.projectModel(cube);
|
|
726
|
+
const sup = this.getCubeSup(cube);
|
|
727
|
+
if (
|
|
728
|
+
limit === null
|
|
729
|
+
? sup === null
|
|
730
|
+
: sup !== null && !sup.isAttained && this.am.compare(sup.sup, limit) === 0
|
|
731
|
+
)
|
|
732
|
+
return L_TRUE;
|
|
733
|
+
this.mkExternalClause(
|
|
734
|
+
cube.literals.map((literal) => literal ^ 1),
|
|
735
|
+
tag,
|
|
736
|
+
);
|
|
737
|
+
} finally {
|
|
738
|
+
cube.reset();
|
|
739
|
+
}
|
|
733
740
|
}
|
|
734
741
|
} finally {
|
|
735
|
-
this.maxVar = savedMaxVar;
|
|
736
742
|
this.retract(tag);
|
|
743
|
+
this.maxVar = savedMaxVar;
|
|
737
744
|
}
|
|
738
745
|
}
|
|
739
746
|
|
|
740
747
|
retract(tag: number, maxLemmas = Infinity) {
|
|
741
748
|
this.initSearch();
|
|
749
|
+
this.explain.reset();
|
|
750
|
+
this.lemma.reset();
|
|
751
|
+
this.lazyClause.reset();
|
|
752
|
+
this.lemmaAssumptions = null;
|
|
742
753
|
const isKept = (clause: Clause) => {
|
|
743
754
|
const isFound = linearize([clause.assumptions]).includes(tag);
|
|
744
755
|
if (isFound) this.delClause(clause);
|
|
@@ -748,7 +759,7 @@ export class NlsatSolver {
|
|
|
748
759
|
this.learned = this.learned.filter(isKept);
|
|
749
760
|
if (this.learned.length <= maxLemmas) return;
|
|
750
761
|
this.learned.sort((first, second) => first.literals.length - second.literals.length);
|
|
751
|
-
for (const clause of this.learned.splice(maxLemmas)) this.delClause(clause);
|
|
762
|
+
for (const clause of this.learned.splice(maxLemmas).reverse()) this.delClause(clause);
|
|
752
763
|
}
|
|
753
764
|
|
|
754
765
|
// Like Z3, only a falsified clause restores the assignment.
|
|
@@ -23,7 +23,7 @@ import { mkBvApp } from "./bv-decl-plugin";
|
|
|
23
23
|
import { Goal } from "./goal";
|
|
24
24
|
import { getPbSum } from "./lia2card";
|
|
25
25
|
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
26
|
-
import type { MaxsatContext, MaxsatParams } from "./maxsmt-base";
|
|
26
|
+
import type { MaxsatContext, MaxsatParams, MaxsatSolver } from "./maxsmt-base";
|
|
27
27
|
import { Maxsmt } from "./maxsmt";
|
|
28
28
|
import { isInNraFragment } from "./opt-nlsat";
|
|
29
29
|
import { canReuseNlsatSolver, giaPareto, ParetoNlsatSolver, type ParetoSolver } from "./opt-pareto";
|
|
@@ -245,19 +245,20 @@ export class OptContext {
|
|
|
245
245
|
private getMaxsatContext(optSolver: OptSolver, options: OptOptions): MaxsatContext {
|
|
246
246
|
const getSolver = () => this.satSolver ?? optSolver;
|
|
247
247
|
const isSatEnabled = () => this.satSolver !== null;
|
|
248
|
+
const solver: MaxsatSolver = {
|
|
249
|
+
assertExpr: (expr) => getSolver().assertExpr(expr),
|
|
250
|
+
checkSat: (assumptions) => getSolver().check(assumptions),
|
|
251
|
+
getModel: () => getSolver().getModel(),
|
|
252
|
+
getUnsatCore: () => getSolver().getUnsatCore(),
|
|
253
|
+
findMutexes: (vars) => ({ status: L_TRUE, mutexes: getSolver().findMutexes(vars) }),
|
|
254
|
+
};
|
|
248
255
|
return {
|
|
249
256
|
manager: this.manager,
|
|
250
257
|
params: options.maxsat,
|
|
251
258
|
get isSatEnabled() {
|
|
252
259
|
return isSatEnabled();
|
|
253
260
|
},
|
|
254
|
-
getSolver: () =>
|
|
255
|
-
assertExpr: (expr) => getSolver().assertExpr(expr),
|
|
256
|
-
checkSat: (assumptions) => getSolver().check(assumptions),
|
|
257
|
-
getModel: () => getSolver().getModel(),
|
|
258
|
-
getUnsatCore: () => getSolver().getUnsatCore(),
|
|
259
|
-
findMutexes: (vars) => ({ status: L_TRUE, mutexes: getSolver().findMutexes(vars) }),
|
|
260
|
-
}),
|
|
261
|
+
getSolver: () => solver,
|
|
261
262
|
getBaseModel: () => this.rawModel,
|
|
262
263
|
hide: (decl) => {
|
|
263
264
|
this.hiddenDecls.push(decl);
|
|
@@ -34,31 +34,44 @@ const PREPROCESSOR =
|
|
|
34
34
|
"(using-params simplify :elim_and true :blast_distinct true) tseitin-cnf-core " +
|
|
35
35
|
"(using-params simplify :elim_and true :blast_distinct true))";
|
|
36
36
|
|
|
37
|
-
|
|
38
|
-
value: Anum
|
|
37
|
+
interface NlsatSupremum {
|
|
38
|
+
value: Anum;
|
|
39
39
|
lower: Rational;
|
|
40
40
|
upper: Rational;
|
|
41
|
-
isAttained: boolean;
|
|
42
|
-
isUnbounded: boolean;
|
|
43
|
-
hasSup: boolean;
|
|
44
41
|
isOpen: boolean;
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
interface NlsatNoModel {
|
|
45
|
+
hasModel: false;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
interface NlsatOptimum {
|
|
49
|
+
hasModel: true;
|
|
50
|
+
model: ProtoModel;
|
|
51
|
+
value: Anum;
|
|
52
|
+
lower: Rational;
|
|
53
|
+
upper: Rational;
|
|
54
|
+
isUnbounded: boolean;
|
|
55
|
+
sup: NlsatSupremum | null;
|
|
49
56
|
}
|
|
50
57
|
|
|
51
58
|
interface NlsatOptOutcome {
|
|
52
59
|
status: number;
|
|
53
|
-
result:
|
|
60
|
+
result: NlsatNoModel | NlsatOptimum;
|
|
54
61
|
}
|
|
55
62
|
|
|
56
|
-
interface
|
|
57
|
-
status:
|
|
58
|
-
goal: Goal
|
|
63
|
+
interface PreprocessedGoal {
|
|
64
|
+
status: typeof L_TRUE;
|
|
65
|
+
goal: Goal;
|
|
59
66
|
objective: number;
|
|
60
67
|
}
|
|
61
68
|
|
|
69
|
+
interface PreprocessedNothing {
|
|
70
|
+
status: typeof L_FALSE | typeof L_UNDEF;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
const NO_MODEL: NlsatNoModel = { hasModel: false };
|
|
74
|
+
|
|
62
75
|
interface Loaded {
|
|
63
76
|
solver: NlsatSolver;
|
|
64
77
|
variable: number;
|
|
@@ -175,7 +188,7 @@ export class NlsatOpt {
|
|
|
175
188
|
objective: number,
|
|
176
189
|
lower: Rational,
|
|
177
190
|
upper: Rational | null,
|
|
178
|
-
):
|
|
191
|
+
): PreprocessedGoal | PreprocessedNothing {
|
|
179
192
|
const manager = this.manager;
|
|
180
193
|
const pinned = new RefVector(manager);
|
|
181
194
|
const pin = (expr: number) => {
|
|
@@ -199,10 +212,11 @@ export class NlsatOpt {
|
|
|
199
212
|
})();
|
|
200
213
|
pinned.reset();
|
|
201
214
|
const result = goals?.length === 1 ? goals[0] : null;
|
|
202
|
-
if (result
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
215
|
+
if (result === null) return { status: L_UNDEF };
|
|
216
|
+
if (result.isInconsistent) return { status: L_FALSE };
|
|
217
|
+
return result.forms.items.some((form) => isOccurring(manager, target, form))
|
|
218
|
+
? { status: L_TRUE, goal: result, objective: target }
|
|
219
|
+
: { status: L_UNDEF };
|
|
206
220
|
}
|
|
207
221
|
|
|
208
222
|
// The objective is nlsat's first variable and its maximization target.
|
|
@@ -270,23 +284,22 @@ export class NlsatOpt {
|
|
|
270
284
|
proveUnbounded(hard: readonly number[], objective: number, lower: Rational) {
|
|
271
285
|
if (!isInNraFragment(this.manager, [...hard, objective])) return L_UNDEF;
|
|
272
286
|
const preprocessed = this.preprocess(hard, objective, lower, null);
|
|
273
|
-
if (preprocessed.status
|
|
274
|
-
if (preprocessed.goal === null) return L_UNDEF;
|
|
287
|
+
if (preprocessed.status !== L_TRUE) return preprocessed.status;
|
|
275
288
|
return this.checkLimit(preprocessed.goal, preprocessed.objective, null);
|
|
276
289
|
}
|
|
277
290
|
|
|
278
291
|
// Refuting T >= sup, at a model below an open candidate supremum, proves a strict upper bound,
|
|
279
292
|
// but not that feasible values approach it.
|
|
280
|
-
private proveStrictUpperBound(loaded: Loaded, sup: Anum, best: Anum
|
|
293
|
+
private proveStrictUpperBound(loaded: Loaded, sup: Anum, best: Anum): NlsatSupremum | null {
|
|
281
294
|
const solver = loaded.solver;
|
|
282
|
-
if (solver.am.compare(sup, best) <= 0) return;
|
|
295
|
+
if (solver.am.compare(sup, best) <= 0) return null;
|
|
283
296
|
const literal = mkLowerBound(solver, loaded.variable, sup, false);
|
|
284
|
-
if (literal === null) return;
|
|
297
|
+
if (literal === null) return null;
|
|
285
298
|
solver.mkExternalClause([literal], null);
|
|
286
|
-
if (solver.check() !== L_FALSE) return;
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
299
|
+
if (solver.check() !== L_FALSE) return null;
|
|
300
|
+
const value = solver.am.copy(sup);
|
|
301
|
+
const bracket = getBracket(solver, value);
|
|
302
|
+
return { value, lower: bracket[0], upper: bracket[1], isOpen: false };
|
|
290
303
|
}
|
|
291
304
|
|
|
292
305
|
maximize(
|
|
@@ -297,30 +310,20 @@ export class NlsatOpt {
|
|
|
297
310
|
maxRounds: number,
|
|
298
311
|
supremumRlimit: number,
|
|
299
312
|
): NlsatOptOutcome {
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
lower: Rational.zero,
|
|
303
|
-
upper: Rational.zero,
|
|
304
|
-
isAttained: false,
|
|
305
|
-
isUnbounded: false,
|
|
306
|
-
hasSup: false,
|
|
307
|
-
isOpen: false,
|
|
308
|
-
sup: null,
|
|
309
|
-
supLower: Rational.zero,
|
|
310
|
-
supUpper: Rational.zero,
|
|
311
|
-
model: null,
|
|
312
|
-
};
|
|
313
|
-
if (!isInNraFragment(this.manager, [...hard, objective])) return { status: L_UNDEF, result };
|
|
313
|
+
if (!isInNraFragment(this.manager, [...hard, objective]))
|
|
314
|
+
return { status: L_UNDEF, result: NO_MODEL };
|
|
314
315
|
const preprocessed = this.preprocess(hard, objective, lower, upper);
|
|
316
|
+
if (preprocessed.status !== L_TRUE) return { status: preprocessed.status, result: NO_MODEL };
|
|
315
317
|
const goal = preprocessed.goal;
|
|
316
|
-
if (goal === null) return { status: preprocessed.status, result };
|
|
317
318
|
const loaded = this.load(goal, preprocessed.objective);
|
|
318
|
-
if (loaded === null) return { status: L_UNDEF, result };
|
|
319
|
+
if (loaded === null) return { status: L_UNDEF, result: NO_MODEL };
|
|
319
320
|
const solver = loaded.solver;
|
|
320
321
|
const am = solver.am;
|
|
321
322
|
let status = L_UNDEF;
|
|
322
323
|
let best: Anum | null = null;
|
|
323
324
|
let sup: Anum | null = null;
|
|
325
|
+
let model: ProtoModel | null = null;
|
|
326
|
+
let isUnbounded = false;
|
|
324
327
|
let unboundedRounds = 0;
|
|
325
328
|
// A round without a candidate supremum is inconclusive, since bounds through later variables
|
|
326
329
|
// reach the objective only through conflicts, so five in a row probe for a feasible ray.
|
|
@@ -330,13 +333,13 @@ export class NlsatOpt {
|
|
|
330
333
|
best = am.copy(solver.getValue(loaded.variable));
|
|
331
334
|
const found = solver.getMaxVarSup();
|
|
332
335
|
sup = found === null ? null : found.sup;
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
+
model?.decRef();
|
|
337
|
+
model = this.extractModel(loaded, goal, preprocessed.objective);
|
|
338
|
+
model.incRef();
|
|
336
339
|
if (sup === null) {
|
|
337
340
|
if (++unboundedRounds > 4) {
|
|
338
341
|
if (upper === null && this.checkLimit(goal, preprocessed.objective, null) === L_TRUE)
|
|
339
|
-
|
|
342
|
+
isUnbounded = true;
|
|
340
343
|
break;
|
|
341
344
|
}
|
|
342
345
|
} else unboundedRounds = 0;
|
|
@@ -347,20 +350,27 @@ export class NlsatOpt {
|
|
|
347
350
|
}
|
|
348
351
|
solver.mkExternalClause([literal], null);
|
|
349
352
|
}
|
|
350
|
-
if (best === null
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
result.isOpen =
|
|
353
|
+
if (best === null || model === null)
|
|
354
|
+
return { status: status === L_FALSE ? L_FALSE : L_UNDEF, result: NO_MODEL };
|
|
355
|
+
const bracket = getBracket(solver, best);
|
|
356
|
+
const certified =
|
|
357
|
+
status === L_TRUE && sup !== null ? this.proveStrictUpperBound(loaded, sup, best) : null;
|
|
358
|
+
if (certified !== null)
|
|
359
|
+
certified.isOpen =
|
|
358
360
|
this.getBoundedLimit(supremumRlimit, () =>
|
|
359
|
-
this.checkLimit(goal, preprocessed.objective,
|
|
361
|
+
this.checkLimit(goal, preprocessed.objective, certified.value),
|
|
360
362
|
) === L_TRUE;
|
|
361
363
|
return {
|
|
362
|
-
status:
|
|
363
|
-
result
|
|
364
|
+
status: status === L_FALSE || isUnbounded || certified?.isOpen === true ? L_TRUE : L_UNDEF,
|
|
365
|
+
result: {
|
|
366
|
+
hasModel: true,
|
|
367
|
+
model,
|
|
368
|
+
value: best,
|
|
369
|
+
lower: bracket[0],
|
|
370
|
+
upper: bracket[1],
|
|
371
|
+
isUnbounded,
|
|
372
|
+
sup: certified,
|
|
373
|
+
},
|
|
364
374
|
};
|
|
365
375
|
}
|
|
366
376
|
}
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
// Ported from Z3 (src/opt/opt_solver.cpp, src/opt/opt_search.h), MIT license, see z3-license.txt.
|
|
2
|
-
import { SmtCanceledError } from "../../../errors";
|
|
2
|
+
import { SmtCanceledError, SmtInvariantError } from "../../../errors";
|
|
3
3
|
import { type AstManager, FAMILY_ARITH, FAMILY_PB } from "./ast";
|
|
4
4
|
import { InfEps } from "./inf-eps";
|
|
5
5
|
import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
@@ -9,10 +9,9 @@ import type { ProtoModel } from "./proto-model";
|
|
|
9
9
|
import { Rational } from "./rational";
|
|
10
10
|
import { RefVector } from "./ref-vector";
|
|
11
11
|
import { SmtKernel } from "./smt-kernel";
|
|
12
|
-
import type {
|
|
12
|
+
import type { TacticEnvironment } from "./tactic";
|
|
13
13
|
|
|
14
14
|
const MODEL_BOUND_SCALE = Rational.of(10n ** 12n);
|
|
15
|
-
const DUAL_BOUND_RLIMIT = 100;
|
|
16
15
|
|
|
17
16
|
export interface MaximizeResult {
|
|
18
17
|
// The no-model path accepts the hint without validating it.
|
|
@@ -53,12 +52,14 @@ export class OptSolver {
|
|
|
53
52
|
private pinned: RefVector;
|
|
54
53
|
private isFirst = true;
|
|
55
54
|
private numScopes = 0;
|
|
55
|
+
private readonly dualBoundRlimit: number;
|
|
56
56
|
wasUnknown = false;
|
|
57
57
|
|
|
58
58
|
constructor(
|
|
59
59
|
private readonly manager: AstManager,
|
|
60
|
-
params:
|
|
60
|
+
params: TacticEnvironment,
|
|
61
61
|
) {
|
|
62
|
+
this.dualBoundRlimit = Number(params.parameters.get("opt.optsmt_dual_bound_rlimit") ?? 100);
|
|
62
63
|
// opt_solver turns relevancy off under the default case split strategy, so a decided bound,
|
|
63
64
|
// such as one optsmt made for a lower bound, reaches the arithmetic solver.
|
|
64
65
|
this.kernel = new SmtKernel(manager, {
|
|
@@ -84,7 +85,9 @@ export class OptSolver {
|
|
|
84
85
|
private get arith() {
|
|
85
86
|
const context = this.kernel.context;
|
|
86
87
|
context.registerFamily(FAMILY_ARITH);
|
|
87
|
-
|
|
88
|
+
if (context.arith === undefined)
|
|
89
|
+
throw new SmtInvariantError("get_optimizer found no arithmetic theory");
|
|
90
|
+
return context.arith;
|
|
88
91
|
}
|
|
89
92
|
|
|
90
93
|
assertExpr(expr: number) {
|
|
@@ -200,7 +203,13 @@ export class OptSolver {
|
|
|
200
203
|
if (bound !== undefined && InfEps.of(bound).compare(this.objectiveValues[index]) > 0)
|
|
201
204
|
this.objectiveValues[index] = InfEps.of(bound);
|
|
202
205
|
if (this.manager.limit.isExhausted()) return outcome;
|
|
203
|
-
if (
|
|
206
|
+
if (
|
|
207
|
+
isProbing &&
|
|
208
|
+
value.isFinite() &&
|
|
209
|
+
upper !== null &&
|
|
210
|
+
!upper.isGlobal &&
|
|
211
|
+
this.dualBoundRlimit !== 0
|
|
212
|
+
) {
|
|
204
213
|
if (this.checkUpperBound(index, upper.value) === L_FALSE) result.upperBound = upper.value;
|
|
205
214
|
if (!this.manager.limit.inc() || !this.checkBound(index, value, result)) return outcome;
|
|
206
215
|
} else if (value.isFinite()) {
|
|
@@ -224,7 +233,7 @@ export class OptSolver {
|
|
|
224
233
|
if (!(error instanceof SmtCanceledError)) throw error;
|
|
225
234
|
return L_UNDEF;
|
|
226
235
|
}
|
|
227
|
-
limit.push(
|
|
236
|
+
limit.push(this.dualBoundRlimit);
|
|
228
237
|
const result = (() => {
|
|
229
238
|
try {
|
|
230
239
|
this.assertExpr(this.mkGe(index, InfEps.of(value, Rational.one)));
|