tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.63a6693bd
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +29 -29
- package/dist/deciders.js +40 -40
- package/dist/index.cjs +1 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +54 -54
- package/dist/prove.js +52 -52
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +39 -39
- package/dist/transfer.js +41 -41
- package/dist/worker.cjs +4 -4
- package/dist/worker.js +4 -4
- package/package.json +1 -1
- package/src/ast.ts +44 -39
- package/src/builtins.ts +4 -13
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +152 -518
- package/src/cli/options.ts +6 -31
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +14 -13
- package/src/cli/tlc-arguments.ts +222 -210
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +1 -1
- package/src/cli/tlc.ts +34 -701
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +5 -10
- package/src/coverage.ts +3 -10
- package/src/dependencies.ts +8 -13
- package/src/dfid.ts +16 -16
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +45 -333
- package/src/errors.ts +3 -2
- package/src/evaluate.ts +5 -4
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +47 -10
- package/src/java-hash.ts +7 -0
- package/src/json.ts +4 -7
- package/src/levels.ts +39 -42
- package/src/liveness-checker.ts +24 -37
- package/src/liveness.ts +47 -54
- package/src/obligations/action.ts +4 -11
- package/src/obligations/anonymize.ts +4 -2
- package/src/obligations/expression.ts +18 -2
- package/src/obligations/generate.ts +45 -38
- package/src/obligations/index.ts +2 -2
- package/src/obligations/module.ts +27 -38
- package/src/obligations/normalize.ts +2 -1
- package/src/obligations/simplify.ts +39 -44
- package/src/obligations/source.ts +47 -57
- package/src/obligations/temporal.ts +5 -5
- package/src/parallel-worker.ts +10 -30
- package/src/parallel.ts +22 -45
- package/src/parser.ts +19 -34
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +3 -3
- package/src/prover/isabelle/encode.ts +1 -1
- package/src/prover/isabelle/isar/inner-syntax.ts +9 -4
- package/src/prover/isabelle/isar/method.ts +14 -25
- package/src/prover/isabelle/isar/theory.ts +11 -10
- package/src/prover/isabelle/isar/type-check.ts +6 -6
- package/src/prover/isabelle/provers/blast/blast.ts +7 -63
- package/src/prover/isabelle/provers/hypsubst.ts +17 -26
- package/src/prover/isabelle/pure/bicompose.ts +9 -25
- package/src/prover/isabelle/pure/conv.ts +2 -8
- package/src/prover/isabelle/pure/drule.ts +9 -2
- package/src/prover/isabelle/pure/logic.ts +1 -1
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -13
- package/src/prover/isabelle/pure/rewriter.ts +5 -9
- package/src/prover/isabelle/pure/table.ts +2 -1
- package/src/prover/isabelle/pure/tactical.ts +42 -35
- package/src/prover/isabelle/pure/thm.ts +14 -11
- package/src/prover/isabelle/tla/classical-setup.ts +17 -14
- package/src/prover/isabelle/tla/context.ts +7 -2
- package/src/prover/isabelle/tla/logic.ts +10 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -10
- package/src/prover/prep/action.ts +11 -19
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/methods.ts +24 -3
- package/src/prover/prove.ts +87 -64
- package/src/prover/smt/context.ts +1 -2
- package/src/prover/smt/data.ts +418 -406
- package/src/prover/smt/encode.ts +30 -18
- package/src/prover/smt/rewrite.ts +657 -626
- package/src/prover/smt/solver/ast.ts +0 -22
- package/src/prover/smt/solver/auf-solver.ts +2 -5
- package/src/prover/smt/solver/context.ts +3 -3
- package/src/prover/smt/solver/e-matching.ts +1 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +1 -1
- package/src/prover/smt/solver/internalizer.ts +1 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -8
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -1
- package/src/prover/smt/solver/lp/nla-core.ts +2 -6
- package/src/prover/smt/solver/mam-compiler.ts +4 -2
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-finder.ts +12 -17
- package/src/prover/smt/solver/model-macro-solver.ts +11 -19
- package/src/prover/smt/solver/nlsat/algebraic.ts +9 -9
- package/src/prover/smt/solver/nlsat/atoms.ts +20 -4
- package/src/prover/smt/solver/nlsat/explain.ts +7 -22
- package/src/prover/smt/solver/nlsat/levelwise.ts +1 -6
- package/src/prover/smt/solver/nlsat/polynomial.ts +12 -3
- package/src/prover/smt/solver/nlsat/solver.ts +12 -24
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -1
- package/src/prover/smt/solver/proto-model.ts +0 -4
- package/src/prover/smt/solver/quantifier-analyzer.ts +10 -10
- package/src/prover/smt/solver/quantifier-manager.ts +1 -5
- package/src/prover/smt/solver/smtlib-parser.ts +78 -94
- package/src/prover/smt/solver/theory-lra-bounds.ts +1 -2
- package/src/prover/smt/solver/theory-lra-internalize.ts +5 -16
- package/src/prover/tlapm/cache.ts +28 -18
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/verdict.ts +7 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/eqrel.ts +2 -0
- package/src/prover/zenon/expr.ts +7 -0
- package/src/prover/zenon/index-table.ts +9 -19
- package/src/prover/zenon/isar.ts +35 -35
- package/src/prover/zenon/llproof.ts +2 -11
- package/src/prover/zenon/mltoll.ts +12 -28
- package/src/prover/zenon/parse.ts +3 -6
- package/src/prover/zenon/search.ts +4 -14
- package/src/prover/zenon/tla/functions.ts +2 -2
- package/src/prover/zenon/tla/llproof.ts +9 -11
- package/src/prover/zenon/tla/records.ts +1 -6
- package/src/prover/zenon/tla/sets.ts +15 -14
- package/src/prover/zenon/tla/tla.ts +7 -6
- package/src/resolve.ts +55 -72
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +155 -2625
- package/src/sany/lexer.ts +17 -16
- package/src/sany/nodes.ts +6 -13
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +35 -38
- package/src/sany/xml.ts +23 -55
- package/src/search.ts +65 -27
- package/src/simulate.ts +157 -133
- package/src/spec-description.ts +33 -48
- package/src/standard-modules.ts +16 -32
- package/src/state-graph.ts +2 -7
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +5 -7
- package/src/tlc/messages.ts +20 -15
- package/src/tlc/order.ts +2 -9
- package/src/tlc/random.ts +4 -4
- package/src/tlc/replay.ts +8 -15
- package/src/tlc/tlc-operators.ts +2 -3
- package/src/tlc/trace-spec.ts +25 -45
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/values.ts +63 -158
|
@@ -23,8 +23,6 @@ import { Rational } from "./rational";
|
|
|
23
23
|
import { Rewriter } from "./rewriter";
|
|
24
24
|
import { AufSolver, type Evaluate, InstantiationSet, Node } from "./auf-solver";
|
|
25
25
|
|
|
26
|
-
export const MBQI_FORCE_TEMPLATE = 10;
|
|
27
|
-
|
|
28
26
|
type QInfo =
|
|
29
27
|
| { kind: "f_var"; decl: number; argIndex: number; varIndex: number }
|
|
30
28
|
| { kind: "f_var_plus_offset"; decl: number; argIndex: number; varIndex: number; offset: number }
|
|
@@ -38,6 +36,7 @@ const mkVarPair = (kind: "x_eq_y" | "x_neq_y" | "x_leq_y", first: number, second
|
|
|
38
36
|
first > second ? { kind, first: second, second: first } : { kind, first, second };
|
|
39
37
|
|
|
40
38
|
export class QuantifierInfo {
|
|
39
|
+
private manager: AstManager;
|
|
41
40
|
readonly flatQ: number;
|
|
42
41
|
qinfos: QInfo[] = [];
|
|
43
42
|
isAuf = true;
|
|
@@ -47,11 +46,12 @@ export class QuantifierInfo {
|
|
|
47
46
|
readonly condMacros;
|
|
48
47
|
|
|
49
48
|
constructor(
|
|
50
|
-
private manager: AstManager,
|
|
51
49
|
private context: Context,
|
|
52
50
|
readonly quantifier: number,
|
|
53
51
|
macroRewriter: Rewriter,
|
|
54
52
|
) {
|
|
53
|
+
const manager = context.manager;
|
|
54
|
+
this.manager = manager;
|
|
55
55
|
const isNested = manager.hasQuantifierFlags[manager.getQuantifier(quantifier).body];
|
|
56
56
|
this.flatQ = isNested ? pullQuant(manager, quantifier) : quantifier;
|
|
57
57
|
if (!isNested) manager.incRef(quantifier);
|
|
@@ -262,10 +262,6 @@ export class QuantifierAnalyzer {
|
|
|
262
262
|
return { variable, term, isInverted };
|
|
263
263
|
}
|
|
264
264
|
|
|
265
|
-
private mkSub(first: number, second: number) {
|
|
266
|
-
return this.rewriter.mkSub(first, second);
|
|
267
|
-
}
|
|
268
|
-
|
|
269
265
|
private mkAdd(first: number, second: number) {
|
|
270
266
|
return this.rewriter.mkAdd([first, second]);
|
|
271
267
|
}
|
|
@@ -279,14 +275,18 @@ export class QuantifierAnalyzer {
|
|
|
279
275
|
if (left !== undefined && this.manager.isGround(rhs))
|
|
280
276
|
return {
|
|
281
277
|
variable: left.variable,
|
|
282
|
-
term: left.isInverted
|
|
278
|
+
term: left.isInverted
|
|
279
|
+
? this.rewriter.mkSub(left.term, rhs)
|
|
280
|
+
: this.rewriter.mkSub(rhs, left.term),
|
|
283
281
|
isInverted: left.isInverted,
|
|
284
282
|
};
|
|
285
283
|
const right = this.isVarPlusGround(rhs);
|
|
286
284
|
if (right !== undefined && this.manager.isGround(lhs))
|
|
287
285
|
return {
|
|
288
286
|
variable: right.variable,
|
|
289
|
-
term: right.isInverted
|
|
287
|
+
term: right.isInverted
|
|
288
|
+
? this.rewriter.mkSub(right.term, lhs)
|
|
289
|
+
: this.rewriter.mkSub(lhs, right.term),
|
|
290
290
|
isInverted: right.isInverted,
|
|
291
291
|
};
|
|
292
292
|
return undefined;
|
|
@@ -332,7 +332,7 @@ export class QuantifierAnalyzer {
|
|
|
332
332
|
const one = manager.mkNumeralOfSort(Rational.one, manager.sorts[found.term]);
|
|
333
333
|
return {
|
|
334
334
|
variable: found.variable,
|
|
335
|
-
term: isLe ? this.mkAdd(found.term, one) : this.mkSub(found.term, one),
|
|
335
|
+
term: isLe ? this.mkAdd(found.term, one) : this.rewriter.mkSub(found.term, one),
|
|
336
336
|
};
|
|
337
337
|
}
|
|
338
338
|
|
|
@@ -45,7 +45,7 @@ export class DefaultQuantifierManager {
|
|
|
45
45
|
this.mam = new Mam(context, onMatch);
|
|
46
46
|
this.lazyMam = new Mam(context, onMatch);
|
|
47
47
|
if (!isMbqi) return;
|
|
48
|
-
const finder = new ModelFinder(context
|
|
48
|
+
const finder = new ModelFinder(context);
|
|
49
49
|
this.mbqi = { finder, checker: new ModelChecker(context, finder, this) };
|
|
50
50
|
}
|
|
51
51
|
|
|
@@ -64,10 +64,6 @@ export class DefaultQuantifierManager {
|
|
|
64
64
|
this.generations.delete(quantifier);
|
|
65
65
|
}
|
|
66
66
|
|
|
67
|
-
hasQuantifiers() {
|
|
68
|
-
return this.quantifiers.length > 0;
|
|
69
|
-
}
|
|
70
|
-
|
|
71
67
|
getGeneration(quantifier: number) {
|
|
72
68
|
return this.generations.get(quantifier) ?? 0;
|
|
73
69
|
}
|
|
@@ -30,7 +30,6 @@ import {
|
|
|
30
30
|
OP_TRUE,
|
|
31
31
|
OP_FALSE,
|
|
32
32
|
OP_UMINUS,
|
|
33
|
-
OP_UNINTERPRETED,
|
|
34
33
|
OP_XOR,
|
|
35
34
|
SORT_BOOL,
|
|
36
35
|
SORT_INT,
|
|
@@ -58,36 +57,56 @@ interface ApplicationFrame {
|
|
|
58
57
|
next: number;
|
|
59
58
|
}
|
|
60
59
|
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
[
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
["+", OP_ADD],
|
|
70
|
-
["*", OP_MUL],
|
|
71
|
-
["/", OP_DIV],
|
|
72
|
-
["div", OP_IDIV],
|
|
73
|
-
["mod", OP_MOD],
|
|
74
|
-
["abs", OP_ABS],
|
|
75
|
-
["to_real", OP_TO_REAL],
|
|
76
|
-
["to_int", OP_TO_INT],
|
|
77
|
-
["is_int", OP_IS_INT],
|
|
78
|
-
]);
|
|
60
|
+
interface Operator {
|
|
61
|
+
op: number;
|
|
62
|
+
symbol?: string;
|
|
63
|
+
isChainable?: boolean;
|
|
64
|
+
arity: [min: number, max: number];
|
|
65
|
+
domain: "join" | "branches" | "arith" | "first" | number;
|
|
66
|
+
range: "domain" | number;
|
|
67
|
+
}
|
|
79
68
|
|
|
80
|
-
const
|
|
69
|
+
const OPERATORS: Operator[] = [
|
|
70
|
+
{ op: OP_AND, symbol: "and", arity: [0, Infinity], domain: SORT_BOOL, range: SORT_BOOL },
|
|
71
|
+
{ op: OP_OR, symbol: "or", arity: [0, Infinity], domain: SORT_BOOL, range: SORT_BOOL },
|
|
72
|
+
{ op: OP_NOT, symbol: "not", arity: [1, 1], domain: SORT_BOOL, range: SORT_BOOL },
|
|
73
|
+
{ op: OP_IMPLIES, symbol: "=>", arity: [2, 2], domain: SORT_BOOL, range: SORT_BOOL },
|
|
74
|
+
{ op: OP_XOR, symbol: "xor", arity: [2, 2], domain: SORT_BOOL, range: SORT_BOOL },
|
|
75
|
+
{ op: OP_ITE, symbol: "ite", arity: [3, 3], domain: "branches", range: "domain" },
|
|
76
|
+
{ op: OP_DISTINCT, symbol: "distinct", arity: [2, Infinity], domain: "join", range: SORT_BOOL },
|
|
77
|
+
{ op: OP_ADD, symbol: "+", arity: [1, Infinity], domain: "arith", range: "domain" },
|
|
78
|
+
{ op: OP_MUL, symbol: "*", arity: [1, Infinity], domain: "arith", range: "domain" },
|
|
79
|
+
{ op: OP_DIV, symbol: "/", arity: [2, 2], domain: SORT_REAL, range: SORT_REAL },
|
|
80
|
+
{ op: OP_IDIV, symbol: "div", arity: [2, 2], domain: SORT_INT, range: SORT_INT },
|
|
81
|
+
{ op: OP_MOD, symbol: "mod", arity: [2, 2], domain: SORT_INT, range: SORT_INT },
|
|
82
|
+
{ op: OP_ABS, symbol: "abs", arity: [1, 1], domain: "first", range: "domain" },
|
|
83
|
+
{ op: OP_TO_REAL, symbol: "to_real", arity: [1, 1], domain: "first", range: SORT_REAL },
|
|
84
|
+
{ op: OP_TO_INT, symbol: "to_int", arity: [1, 1], domain: "first", range: SORT_INT },
|
|
85
|
+
{ op: OP_IS_INT, symbol: "is_int", arity: [1, 1], domain: SORT_REAL, range: SORT_BOOL },
|
|
86
|
+
{
|
|
87
|
+
op: OP_EQ,
|
|
88
|
+
symbol: "=",
|
|
89
|
+
isChainable: true,
|
|
90
|
+
arity: [2, Infinity],
|
|
91
|
+
domain: "join",
|
|
92
|
+
range: SORT_BOOL,
|
|
93
|
+
},
|
|
94
|
+
{ op: OP_LE, symbol: "<=", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
|
|
95
|
+
{ op: OP_GE, symbol: ">=", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
|
|
96
|
+
{ op: OP_LT, symbol: "<", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
|
|
97
|
+
{ op: OP_GT, symbol: ">", isChainable: true, arity: [2, 2], domain: "arith", range: SORT_BOOL },
|
|
98
|
+
{ op: OP_SUB, arity: [1, Infinity], domain: "arith", range: "domain" },
|
|
99
|
+
{ op: OP_UMINUS, arity: [1, 1], domain: "arith", range: "domain" },
|
|
100
|
+
];
|
|
81
101
|
|
|
82
|
-
const
|
|
102
|
+
const OPERATORS_BY_OP = new Map<number, Operator>();
|
|
103
|
+
const OPERATORS_BY_SYMBOL = new Map<string, Operator>();
|
|
104
|
+
for (const operator of OPERATORS) {
|
|
105
|
+
OPERATORS_BY_OP.set(operator.op, operator);
|
|
106
|
+
if (operator.symbol !== undefined) OPERATORS_BY_SYMBOL.set(operator.symbol, operator);
|
|
107
|
+
}
|
|
83
108
|
|
|
84
|
-
const
|
|
85
|
-
["=", OP_EQ],
|
|
86
|
-
["<=", OP_LE],
|
|
87
|
-
[">=", OP_GE],
|
|
88
|
-
["<", OP_LT],
|
|
89
|
-
[">", OP_GT],
|
|
90
|
-
]);
|
|
109
|
+
const DECIMAL = /^([0-9]+)\.([0-9]+)$/;
|
|
91
110
|
|
|
92
111
|
const tokenize = (text: string) => {
|
|
93
112
|
const tokens: string[] = [];
|
|
@@ -183,30 +202,13 @@ export const parseSmtlib = (
|
|
|
183
202
|
return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
184
203
|
};
|
|
185
204
|
|
|
186
|
-
const getDomainSort = (
|
|
187
|
-
if (
|
|
188
|
-
if (
|
|
189
|
-
if (
|
|
190
|
-
|
|
191
|
-
if (op === OP_IDIV || op === OP_MOD) return SORT_INT;
|
|
192
|
-
if (op === OP_DIV || op === OP_IS_INT) return SORT_REAL;
|
|
193
|
-
return SORT_BOOL;
|
|
205
|
+
const getDomainSort = (operator: Operator, args: number[]) => {
|
|
206
|
+
if (operator.domain === "branches") return getJoin(args.slice(1));
|
|
207
|
+
if (operator.domain === "join") return getJoin(args);
|
|
208
|
+
if (operator.domain === "arith") return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
|
|
209
|
+
return operator.domain === "first" ? manager.sorts[args[0]] : operator.domain;
|
|
194
210
|
};
|
|
195
211
|
|
|
196
|
-
const getRange = (op: number, domainSort: number) =>
|
|
197
|
-
op === OP_TO_REAL || op === OP_DIV
|
|
198
|
-
? SORT_REAL
|
|
199
|
-
: op === OP_TO_INT || op === OP_IDIV || op === OP_MOD
|
|
200
|
-
? SORT_INT
|
|
201
|
-
: op === OP_ITE ||
|
|
202
|
-
op === OP_ABS ||
|
|
203
|
-
op === OP_ADD ||
|
|
204
|
-
op === OP_SUB ||
|
|
205
|
-
op === OP_UMINUS ||
|
|
206
|
-
op === OP_MUL
|
|
207
|
-
? domainSort
|
|
208
|
-
: SORT_BOOL;
|
|
209
|
-
|
|
210
212
|
const coerce = (arg: number, sort: number) => {
|
|
211
213
|
const argSort = manager.sorts[arg];
|
|
212
214
|
if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
|
|
@@ -216,61 +218,44 @@ export const parseSmtlib = (
|
|
|
216
218
|
};
|
|
217
219
|
|
|
218
220
|
const mkApp = (decl: number, inputArgs: number[], domainSort?: number) => {
|
|
219
|
-
const
|
|
220
|
-
const
|
|
221
|
-
const
|
|
222
|
-
|
|
223
|
-
const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
|
|
221
|
+
const funcDecl = manager.funcDecls[decl];
|
|
222
|
+
const operator = OPERATORS_BY_OP.get(funcDecl.op);
|
|
223
|
+
const builtinSort =
|
|
224
|
+
operator === undefined ? -1 : (domainSort ?? getDomainSort(operator, inputArgs));
|
|
224
225
|
const getExpected = (index: number) =>
|
|
225
|
-
|
|
226
|
+
operator === undefined
|
|
227
|
+
? funcDecl.domain[index]
|
|
228
|
+
: operator.op === OP_ITE && index === 0
|
|
229
|
+
? SORT_BOOL
|
|
230
|
+
: builtinSort;
|
|
226
231
|
const args = inputArgs.map((arg, index) =>
|
|
227
232
|
getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
|
|
228
233
|
);
|
|
229
|
-
const
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
? true
|
|
234
|
-
: op === OP_ITE
|
|
235
|
-
? isArity(3, 3)
|
|
236
|
-
: op === OP_EQ || op === OP_DISTINCT
|
|
237
|
-
? isArity(2, Infinity)
|
|
238
|
-
: op === OP_NOT ||
|
|
239
|
-
op === OP_UMINUS ||
|
|
240
|
-
op === OP_ABS ||
|
|
241
|
-
op === OP_TO_REAL ||
|
|
242
|
-
op === OP_TO_INT ||
|
|
243
|
-
op === OP_IS_INT
|
|
244
|
-
? isArity(1, 1)
|
|
245
|
-
: op === OP_IMPLIES ||
|
|
246
|
-
op === OP_XOR ||
|
|
247
|
-
op === OP_IDIV ||
|
|
248
|
-
op === OP_MOD ||
|
|
249
|
-
op === OP_DIV ||
|
|
250
|
-
op === OP_LE ||
|
|
251
|
-
op === OP_GE ||
|
|
252
|
-
op === OP_LT ||
|
|
253
|
-
op === OP_GT
|
|
254
|
-
? isArity(2, 2)
|
|
255
|
-
: isArity(1, Infinity);
|
|
256
|
-
const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
|
|
234
|
+
const isArityOk =
|
|
235
|
+
operator === undefined
|
|
236
|
+
? args.length === funcDecl.domain.length
|
|
237
|
+
: args.length >= operator.arity[0] && args.length <= operator.arity[1];
|
|
257
238
|
const isWellSorted =
|
|
258
239
|
isArityOk &&
|
|
259
|
-
(
|
|
240
|
+
(funcDecl.family !== FAMILY_ARITH || isArithSort(builtinSort)) &&
|
|
260
241
|
args.every((arg, index) => manager.sorts[arg] === getExpected(index));
|
|
261
|
-
if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`);
|
|
242
|
+
if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${funcDecl.name}`);
|
|
262
243
|
return manager.mkApp(
|
|
263
244
|
decl,
|
|
264
245
|
args,
|
|
265
|
-
|
|
246
|
+
operator === undefined
|
|
247
|
+
? funcDecl.range
|
|
248
|
+
: operator.range === "domain"
|
|
249
|
+
? builtinSort
|
|
250
|
+
: operator.range,
|
|
266
251
|
);
|
|
267
252
|
};
|
|
268
253
|
|
|
269
|
-
const mkChain = (
|
|
270
|
-
const domainSort = getDomainSort(
|
|
254
|
+
const mkChain = (operator: Operator, args: number[]) => {
|
|
255
|
+
const domainSort = getDomainSort(operator, args);
|
|
271
256
|
const pairs: number[] = [];
|
|
272
257
|
for (let index = 0; index + 1 < args.length; index++)
|
|
273
|
-
pairs.push(mkApp(op, [args[index], args[index + 1]], domainSort));
|
|
258
|
+
pairs.push(mkApp(operator.op, [args[index], args[index + 1]], domainSort));
|
|
274
259
|
return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs);
|
|
275
260
|
};
|
|
276
261
|
|
|
@@ -384,15 +369,14 @@ export const parseSmtlib = (
|
|
|
384
369
|
};
|
|
385
370
|
|
|
386
371
|
const parseApp = (name: string, args: number[]) => {
|
|
387
|
-
const chainable = CHAINABLE_OPS.get(name);
|
|
388
|
-
if (chainable !== undefined) return mkChain(chainable, args);
|
|
389
372
|
if (name === "-") return mkApp(args.length === 1 ? OP_UMINUS : OP_SUB, args);
|
|
390
373
|
if (name === "/" && args.length > 2)
|
|
391
374
|
return args
|
|
392
375
|
.slice(1)
|
|
393
376
|
.reduce((dividend, divisor) => mkApp(OP_DIV, [dividend, divisor]), args[0]);
|
|
394
|
-
const
|
|
395
|
-
if (
|
|
377
|
+
const operator = OPERATORS_BY_SYMBOL.get(name);
|
|
378
|
+
if (operator?.isChainable) return mkChain(operator, args);
|
|
379
|
+
if (operator !== undefined) return mkApp(operator.op, args);
|
|
396
380
|
const decl = funcs.get(name);
|
|
397
381
|
if (decl === undefined) throw new SmtParseError(`unknown function ${name}`);
|
|
398
382
|
return mkApp(decl, args);
|
|
@@ -76,7 +76,6 @@ export abstract class TheoryLraBounds extends TheoryLraInternalize {
|
|
|
76
76
|
this.internalizeHead--;
|
|
77
77
|
const column = this.registerVar(thVar);
|
|
78
78
|
const isInt = this.isIntVar(thVar);
|
|
79
|
-
const partial = { isLower, isInt };
|
|
80
79
|
const kindTrue = isLower ? KIND_GE : KIND_LE;
|
|
81
80
|
const kindFalse = isLower ? (isInt ? KIND_LE : KIND_LT) : isInt ? KIND_GE : KIND_GT;
|
|
82
81
|
const constraintTrue = this.solver.mkVarBound(column, kindTrue, value);
|
|
@@ -88,7 +87,7 @@ export abstract class TheoryLraBounds extends TheoryLraInternalize {
|
|
|
88
87
|
const constraintFalse = this.solver.mkVarBound(column, kindFalse, falseValue);
|
|
89
88
|
this.constraintSources[constraintTrue] = mkLiteral(boolVar);
|
|
90
89
|
this.constraintSources[constraintFalse] = mkLiteral(boolVar, true);
|
|
91
|
-
return { boolVar, thVar, column, value, constraintTrue, constraintFalse,
|
|
90
|
+
return { boolVar, thVar, column, value, constraintTrue, constraintFalse, isLower, isInt };
|
|
92
91
|
}
|
|
93
92
|
|
|
94
93
|
private mkBoundAxioms(bound: ApiBound) {
|
|
@@ -265,10 +265,8 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
|
|
|
265
265
|
toEnsureEnode.push(term);
|
|
266
266
|
const op = manager.getOp(term);
|
|
267
267
|
if (op === OP_ADD) {
|
|
268
|
-
for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++)
|
|
269
|
-
|
|
270
|
-
push(arg, coeffs[index]);
|
|
271
|
-
}
|
|
268
|
+
for (let argIndex = 0; argIndex < manager.getNumArgs(term); argIndex++)
|
|
269
|
+
push(manager.getArg(term, argIndex), coeffs[index]);
|
|
272
270
|
if (terms.size !== index + 1) {
|
|
273
271
|
terms.set(index, terms.items[terms.size - 1]);
|
|
274
272
|
coeffs[index] = coeffs[coeffs.length - 1];
|
|
@@ -324,10 +322,7 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
|
|
|
324
322
|
if (op === OP_DIV) {
|
|
325
323
|
const divisor = context.rewriter.rewrite(manager.getArg(term, 1));
|
|
326
324
|
if (!this.isNonzeroNumeral(divisor)) this.foundUnderspecified(term);
|
|
327
|
-
|
|
328
|
-
const arg = manager.getArg(term, argIndex);
|
|
329
|
-
toEnsureVar.push(arg);
|
|
330
|
-
}
|
|
325
|
+
manager.pushArgs(term, toEnsureVar);
|
|
331
326
|
} else if (op === OP_IDIV) {
|
|
332
327
|
if (!this.isNonzeroNumeral(manager.getArg(term, 1))) this.foundUnderspecified(term);
|
|
333
328
|
const remainder = manager.mkApp(OP_MOD, manager.getArgs(term), SORT_INT);
|
|
@@ -362,16 +357,10 @@ export abstract class TheoryLraInternalize extends TheoryLraAxioms {
|
|
|
362
357
|
nla.divisions.addDivisibility(this.registerDivision(quotient, term));
|
|
363
358
|
}
|
|
364
359
|
} else if (op === OP_IDIV0 || op === OP_MOD0) {
|
|
365
|
-
|
|
366
|
-
const arg = manager.getArg(term, argIndex);
|
|
367
|
-
toEnsureVar.push(arg);
|
|
368
|
-
}
|
|
360
|
+
manager.pushArgs(term, toEnsureVar);
|
|
369
361
|
} else if (op !== OP_TO_INT && op !== OP_DIV0) {
|
|
370
362
|
this.foundUnsupported(term);
|
|
371
|
-
|
|
372
|
-
const arg = manager.getArg(term, argIndex);
|
|
373
|
-
toEnsureVar.push(arg);
|
|
374
|
-
}
|
|
363
|
+
manager.pushArgs(term, toEnsureVar);
|
|
375
364
|
}
|
|
376
365
|
if (!context.relevancy.isEnabled && op !== OP_MOD) this.relevantEh(term);
|
|
377
366
|
}
|
|
@@ -19,7 +19,9 @@ import {
|
|
|
19
19
|
writeMarshaled,
|
|
20
20
|
type OcamlValue,
|
|
21
21
|
} from "./ocaml-marshal";
|
|
22
|
-
import
|
|
22
|
+
import { getBudget } from "../prep/methods";
|
|
23
|
+
import { getFailureReason, isProvedAttempt, type ProofAttempt } from "../prove";
|
|
24
|
+
import { BACKENDS, type Backend } from "../verdict";
|
|
23
25
|
|
|
24
26
|
export type FingerprintTable = Map<string, OcamlValue[]>;
|
|
25
27
|
|
|
@@ -27,7 +29,7 @@ const MAGIC_NUMBER = 20210223;
|
|
|
27
29
|
|
|
28
30
|
const RECORD_SIZE = 23;
|
|
29
31
|
|
|
30
|
-
const PROVERS: Record<
|
|
32
|
+
const PROVERS: Record<Backend, { field: number; tag: number }> = {
|
|
31
33
|
zenon: { field: 1, tag: 1 },
|
|
32
34
|
isabelle: { field: 2, tag: 0 },
|
|
33
35
|
smt: { field: 10, tag: 8 },
|
|
@@ -102,7 +104,10 @@ export const loadFingerprints = (table: FingerprintTable, path: string, isSafe:
|
|
|
102
104
|
});
|
|
103
105
|
};
|
|
104
106
|
|
|
105
|
-
const decodeResult = (
|
|
107
|
+
const decodeResult = (
|
|
108
|
+
prover: Backend,
|
|
109
|
+
result: OcamlValue | undefined,
|
|
110
|
+
): ProofAttempt | undefined => {
|
|
106
111
|
const status = getField(result, 0);
|
|
107
112
|
const outcome = getField(status, 0);
|
|
108
113
|
const argument = getField(getField(status, 1), 0);
|
|
@@ -111,13 +116,13 @@ const decodeResult = (prover: string, result: OcamlValue | undefined): ProofAtte
|
|
|
111
116
|
const tactic = prover === "isabelle" ? getField(argument, 1) : undefined;
|
|
112
117
|
const reason = getField(getField(outcome, 0), 0);
|
|
113
118
|
return {
|
|
119
|
+
kind: "stored",
|
|
114
120
|
method: {
|
|
115
121
|
prover,
|
|
116
122
|
timeLimitMs: seconds * 1000,
|
|
117
123
|
...(typeof tactic === "string" && { tactic }),
|
|
118
124
|
},
|
|
119
125
|
isProved: outcome === 0,
|
|
120
|
-
isReused: false,
|
|
121
126
|
...(reason !== undefined && {
|
|
122
127
|
reason: typeof reason === "number" ? REASONS[reason] : String(getField(reason, 0)),
|
|
123
128
|
}),
|
|
@@ -125,29 +130,30 @@ const decodeResult = (prover: string, result: OcamlValue | undefined): ProofAtte
|
|
|
125
130
|
};
|
|
126
131
|
|
|
127
132
|
// Fpfile.fp_writes, whose date counts months from 0.
|
|
128
|
-
const encodeResult = (attempt: ProofAttempt) => {
|
|
133
|
+
const encodeResult = (prover: Backend, attempt: ProofAttempt) => {
|
|
129
134
|
const now = new Date();
|
|
130
135
|
const method = attempt.method;
|
|
131
|
-
const timeout = { float: method
|
|
136
|
+
const timeout = { float: getBudget(method) };
|
|
132
137
|
const argument =
|
|
133
|
-
|
|
138
|
+
prover === "zenon"
|
|
134
139
|
? createBlock(0, timeout, FAIL_METHOD)
|
|
135
|
-
:
|
|
140
|
+
: prover === "isabelle"
|
|
136
141
|
? createBlock(0, createBlock(0, timeout), method.tactic ?? "auto")
|
|
137
142
|
: createBlock(0, timeout);
|
|
138
|
-
const
|
|
143
|
+
const failure = getFailureReason(attempt);
|
|
144
|
+
const reasonIndex = REASONS.indexOf(failure ?? "");
|
|
139
145
|
const reason =
|
|
140
|
-
|
|
146
|
+
failure === undefined
|
|
141
147
|
? 0
|
|
142
|
-
: createBlock(0, reasonIndex === -1 ? createBlock(0,
|
|
148
|
+
: createBlock(0, reasonIndex === -1 ? createBlock(0, failure) : reasonIndex);
|
|
143
149
|
return createBlock(
|
|
144
150
|
0,
|
|
145
151
|
createBlock(
|
|
146
152
|
0,
|
|
147
153
|
createBlock(
|
|
148
154
|
0,
|
|
149
|
-
attempt
|
|
150
|
-
createBlock(PROVERS[
|
|
155
|
+
isProvedAttempt(attempt) ? 0 : createBlock(0, reason),
|
|
156
|
+
createBlock(PROVERS[prover].tag, argument),
|
|
151
157
|
),
|
|
152
158
|
createBlock(
|
|
153
159
|
0,
|
|
@@ -201,10 +207,11 @@ export const getKnownResults = (table: FingerprintTable) => {
|
|
|
201
207
|
const results = new Map(
|
|
202
208
|
[...table].map(([fingerprint, record]) => {
|
|
203
209
|
const attempts = new Map(
|
|
204
|
-
|
|
205
|
-
const
|
|
210
|
+
BACKENDS.flatMap((prover) => {
|
|
211
|
+
const stored = record[PROVERS[prover].field];
|
|
212
|
+
const result = decodeResult(prover, getField(stored, 0));
|
|
206
213
|
if (!result) return [];
|
|
207
|
-
storedResults.set(result,
|
|
214
|
+
storedResults.set(result, stored);
|
|
208
215
|
return [[prover, result]];
|
|
209
216
|
}),
|
|
210
217
|
);
|
|
@@ -216,8 +223,11 @@ export const getKnownResults = (table: FingerprintTable) => {
|
|
|
216
223
|
table.clear();
|
|
217
224
|
results.forEach((attempts, fingerprint) => {
|
|
218
225
|
const record = [...(storedRecords.get(attempts) ?? Array<OcamlValue>(RECORD_SIZE).fill(0))];
|
|
219
|
-
|
|
220
|
-
|
|
226
|
+
BACKENDS.forEach((prover) => {
|
|
227
|
+
const attempt = attempts.get(prover);
|
|
228
|
+
if (attempt)
|
|
229
|
+
record[PROVERS[prover].field] =
|
|
230
|
+
storedResults.get(attempt) ?? encodeResult(prover, attempt);
|
|
221
231
|
});
|
|
222
232
|
table.set(fingerprint, record);
|
|
223
233
|
});
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { TlaUnsupportedError } from "../../errors";
|
|
1
|
+
import { TlaProverError, TlaUnsupportedError } from "../../errors";
|
|
2
2
|
|
|
3
3
|
// Loaded at runtime so browser bundles leave them out. prove loads this module only in Node and Bun.
|
|
4
4
|
const childProcess = process.getBuiltinModule("node:child_process");
|
|
@@ -22,12 +22,14 @@ export const getTlapmPaths = () =>
|
|
|
22
22
|
.map((directory) => path.join(directory, "tlapm"))
|
|
23
23
|
.filter((tlapm) => fileSystem.existsSync(tlapm));
|
|
24
24
|
|
|
25
|
+
const MESSAGE_END = "@!!END";
|
|
26
|
+
|
|
25
27
|
const parseToolboxMessages = (text: string) =>
|
|
26
28
|
text
|
|
27
29
|
.split("@!!BEGIN\n")
|
|
28
30
|
.slice(1)
|
|
29
31
|
.flatMap((block) => {
|
|
30
|
-
const end = block.indexOf(
|
|
32
|
+
const end = block.indexOf(MESSAGE_END);
|
|
31
33
|
if (end === -1) return [];
|
|
32
34
|
const fields = new Map<string, string>();
|
|
33
35
|
block
|
|
@@ -69,23 +71,27 @@ export const proveWithTlapm = async (
|
|
|
69
71
|
);
|
|
70
72
|
const kill = () => child.kill();
|
|
71
73
|
options.signal?.addEventListener("abort", kill);
|
|
72
|
-
let
|
|
73
|
-
let parsedCount = 0;
|
|
74
|
+
let unparsed = "";
|
|
74
75
|
child.stderr.on("data", (chunk: Buffer) => {
|
|
75
|
-
text
|
|
76
|
-
const
|
|
77
|
-
|
|
76
|
+
const text = unparsed + chunk.toString("utf8");
|
|
77
|
+
const end = text.lastIndexOf(MESSAGE_END);
|
|
78
|
+
const parsedLength = end === -1 ? 0 : end + MESSAGE_END.length;
|
|
79
|
+
unparsed = text.slice(parsedLength);
|
|
80
|
+
parseToolboxMessages(text.slice(0, parsedLength)).forEach((fields) => {
|
|
78
81
|
const result = getResult(fields);
|
|
79
82
|
const id = Number(fields.get("id"));
|
|
80
83
|
if (fields.get("type") !== "obligation" || !result) return;
|
|
81
84
|
results.set(id, result);
|
|
82
85
|
options.onResult?.(id, result);
|
|
83
86
|
});
|
|
84
|
-
parsedCount = messages.length;
|
|
85
87
|
});
|
|
86
|
-
await new Promise((resolve) =>
|
|
88
|
+
const failure = await new Promise<Error | undefined>((resolve) => {
|
|
89
|
+
child.on("error", resolve);
|
|
90
|
+
child.on("close", () => resolve(undefined));
|
|
91
|
+
});
|
|
87
92
|
options.signal?.removeEventListener("abort", kill);
|
|
88
93
|
fileSystem.rmSync(directory, { recursive: true, force: true });
|
|
89
94
|
options.signal?.throwIfAborted();
|
|
95
|
+
if (failure) throw new TlaProverError(failure.message, failure);
|
|
90
96
|
return results;
|
|
91
97
|
};
|
package/src/prover/verdict.ts
CHANGED
|
@@ -1,5 +1,12 @@
|
|
|
1
1
|
export type Verdict = "unsat" | "sat" | "unknown";
|
|
2
2
|
|
|
3
|
+
export const BACKENDS = ["zenon", "isabelle", "smt", "z3", "ls4"] as const;
|
|
4
|
+
|
|
5
|
+
export type Backend = (typeof BACKENDS)[number];
|
|
6
|
+
|
|
7
|
+
export const isBackend = (prover: string): prover is Backend =>
|
|
8
|
+
BACKENDS.some((backend) => backend === prover);
|
|
9
|
+
|
|
3
10
|
export interface Decision {
|
|
4
11
|
verdict: Verdict;
|
|
5
12
|
timeUsedMs: number;
|
|
@@ -87,8 +87,7 @@ export const checkProof = (root: Proof<Term>, context: CheckContext, limits: Lim
|
|
|
87
87
|
if (!needed.has(subproof)) stack.push([subproof, false]);
|
|
88
88
|
}
|
|
89
89
|
const hypotheses = new Set(context.hypotheses.map(keys.getTopKey));
|
|
90
|
-
|
|
91
|
-
return missing.length === 0;
|
|
90
|
+
return [...(needed.get(root) ?? [])].every((key) => hypotheses.has(key));
|
|
92
91
|
} catch (error) {
|
|
93
92
|
if (error instanceof UncheckedError) return false;
|
|
94
93
|
throw error;
|
|
@@ -25,7 +25,7 @@ export const getFields = (record: Term, constructor: "TLA.record" | "TLA.records
|
|
|
25
25
|
return fields;
|
|
26
26
|
};
|
|
27
27
|
|
|
28
|
-
const getLabels = (fields: [Term, Term][]) =>
|
|
28
|
+
export const getLabels = (fields: [Term, Term][]) =>
|
|
29
29
|
app(
|
|
30
30
|
"TLA.set",
|
|
31
31
|
fields.map((field) => field[0]),
|
|
@@ -1,15 +1,13 @@
|
|
|
1
1
|
import type { PlainRuleName } from "../proof";
|
|
2
|
-
import { getFields } from "./records";
|
|
2
|
+
import { getFields, getLabels } from "./records";
|
|
3
3
|
import {
|
|
4
4
|
and,
|
|
5
|
-
app,
|
|
6
5
|
domain,
|
|
7
6
|
ensure,
|
|
8
7
|
equal,
|
|
9
8
|
expectApp,
|
|
10
9
|
FALSE,
|
|
11
10
|
fapply,
|
|
12
|
-
getPairs,
|
|
13
11
|
getStringText,
|
|
14
12
|
instantiate,
|
|
15
13
|
isApp,
|
|
@@ -157,18 +155,7 @@ export const REWRITE_RULES = {
|
|
|
157
155
|
record_domain: (args, checker) =>
|
|
158
156
|
getRewriteSpec(checker, args[0], args[2], (filled) => {
|
|
159
157
|
const record = expectApp(filled, "TLA.DOMAIN", 1)[0];
|
|
160
|
-
|
|
161
|
-
return [
|
|
162
|
-
[
|
|
163
|
-
instantiate(
|
|
164
|
-
args[2],
|
|
165
|
-
app(
|
|
166
|
-
"TLA.set",
|
|
167
|
-
fields.map((field) => field[0]),
|
|
168
|
-
),
|
|
169
|
-
),
|
|
170
|
-
],
|
|
171
|
-
];
|
|
158
|
+
return [[instantiate(args[2], getLabels(getFields(record, "TLA.record")))]];
|
|
172
159
|
}),
|
|
173
160
|
boolcase_not: (args, checker) =>
|
|
174
161
|
getBoolCaseSpec(checker, args, (operand) => operand.kind === "not"),
|