tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +33 -33
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +17 -3
- package/dist/index.d.ts +17 -3
- 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 +55 -55
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -42
- package/dist/run.js +42 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +96 -91
- package/dist/transfer.js +95 -90
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +12 -10
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +418 -246
- package/src/cli/tlc-output.ts +17 -2
- package/src/cli/tlc.ts +5 -4
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +93 -35
- package/src/environment.ts +106 -39
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +415 -132
- package/src/exit-codes.ts +28 -15
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +674 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +161 -60
- package/src/liveness.ts +55 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parser.ts +110 -111
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +164 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +65 -13
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +65 -14
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +3 -9
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/fd-solver.ts +608 -141
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +4 -3
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +14 -42
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
- package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
- package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
- package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +16 -7
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +4 -3
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +1 -1
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +40 -6
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +579 -214
- package/src/prover/smt/solver/smtlib-script.ts +600 -170
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +342 -196
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1226 -246
- package/src/runtime.ts +19 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +4 -2
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +4 -2
- package/src/sany/generator-expressions.ts +51 -20
- package/src/sany/generator-proofs.ts +17 -11
- package/src/sany/generator.ts +11 -5
- package/src/sany/lexer.ts +15 -7
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +283 -126
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +563 -139
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +1 -3
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +9 -22
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
package/src/lexer.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import { TlaSyntaxError } from "./errors";
|
|
2
|
+
import { getEndOfFile } from "./sany/lexer";
|
|
2
3
|
|
|
3
4
|
type TokenKind =
|
|
4
5
|
| "Identifier"
|
|
@@ -479,8 +480,17 @@ export const matchBasedNumber = (source: string, index: number, isTlapm = false)
|
|
|
479
480
|
|
|
480
481
|
export const tokenize = (source: string, isTlapm = false): Token[] => {
|
|
481
482
|
const headerMatch = MODULE_HEADER.exec(source);
|
|
482
|
-
if (!headerMatch)
|
|
483
|
-
|
|
483
|
+
if (!headerMatch) {
|
|
484
|
+
// SANY skips the text before a module header, so it fails at the end of the file.
|
|
485
|
+
const end = getEndOfFile(source);
|
|
486
|
+
const reason = "Expected a module header such as ---- MODULE Name ----";
|
|
487
|
+
throw new TlaSyntaxError(`${reason} at line ${end.line}, column ${end.column}`, undefined, {
|
|
488
|
+
reason,
|
|
489
|
+
line: end.line,
|
|
490
|
+
column: end.column,
|
|
491
|
+
isEnd: true,
|
|
492
|
+
});
|
|
493
|
+
}
|
|
484
494
|
const tokens: Token[] = [];
|
|
485
495
|
// Each name is one string object, so looking a name up in a scope compares pointers.
|
|
486
496
|
const names = new Map<string, string>();
|
package/src/liveness-checker.ts
CHANGED
|
@@ -22,6 +22,7 @@ import {
|
|
|
22
22
|
type Solution,
|
|
23
23
|
type Tableau,
|
|
24
24
|
} from "./tableau";
|
|
25
|
+
import { findTraceLasso, type TraceLasso } from "./trace-liveness";
|
|
25
26
|
import { isSameValue, type Value } from "./values";
|
|
26
27
|
|
|
27
28
|
export interface LiveSuccessor<State = Value[]> {
|
|
@@ -51,6 +52,16 @@ export interface LivenessChecker {
|
|
|
51
52
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
52
53
|
}
|
|
53
54
|
|
|
55
|
+
export interface TraceViolation extends TraceLasso {
|
|
56
|
+
properties: string[];
|
|
57
|
+
failures: TlaEvaluationError[];
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
export interface LivenessChecks {
|
|
61
|
+
solutions: Solution[];
|
|
62
|
+
findTraceViolation: (trace: Value[][], fingerprints: bigint[]) => TraceViolation | undefined;
|
|
63
|
+
}
|
|
64
|
+
|
|
54
65
|
export interface LiveGraph<State> {
|
|
55
66
|
branches: number;
|
|
56
67
|
addInitialState: (index: number, state: State) => void;
|
|
@@ -59,16 +70,26 @@ export interface LiveGraph<State> {
|
|
|
59
70
|
index: number,
|
|
60
71
|
state: State,
|
|
61
72
|
successors: LiveSuccessor<State>[],
|
|
73
|
+
isRerun?: boolean,
|
|
62
74
|
) => number[] | undefined;
|
|
63
75
|
storeState: (pending: number, index: number) => void;
|
|
64
|
-
// How many states the graph of each branch has, which TLC counts as the fingerprints of its nodes.
|
|
65
76
|
getStateCounts: () => number[];
|
|
66
77
|
findViolation: () => Lasso | undefined;
|
|
67
78
|
}
|
|
68
79
|
|
|
69
80
|
export interface SearchGraph<State> {
|
|
70
81
|
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
71
|
-
|
|
82
|
+
forEachActionSuccessors: (
|
|
83
|
+
index: number,
|
|
84
|
+
state: State,
|
|
85
|
+
onSuccessors: (successors: LiveSuccessor<State>[]) => void,
|
|
86
|
+
replay?: Environment,
|
|
87
|
+
) => void;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
interface Tracing {
|
|
91
|
+
atoms: LiveAtoms<Value[]>;
|
|
92
|
+
replay: Environment | undefined;
|
|
72
93
|
}
|
|
73
94
|
|
|
74
95
|
export interface LiveEvaluation<State> {
|
|
@@ -252,13 +273,14 @@ const getLiveFormula = (
|
|
|
252
273
|
const fairness = temporals.map((item) =>
|
|
253
274
|
toLiveExpression(item.expression, item.scope, environment),
|
|
254
275
|
);
|
|
255
|
-
const
|
|
256
|
-
|
|
276
|
+
const checks = properties.map((property) =>
|
|
277
|
+
toLiveExpression(property.expression, property.scope, environment),
|
|
257
278
|
);
|
|
279
|
+
const negations = checks.map((check) => createUnary("Not", check));
|
|
258
280
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
259
281
|
const formula =
|
|
260
282
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
261
|
-
return { formula,
|
|
283
|
+
return { formula, checks };
|
|
262
284
|
};
|
|
263
285
|
|
|
264
286
|
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
@@ -313,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
|
|
|
313
335
|
getAtomExpressions(atom).map((item) => item.expression),
|
|
314
336
|
);
|
|
315
337
|
|
|
316
|
-
|
|
317
|
-
properties: TemporalProperty[],
|
|
318
|
-
temporals: ScopedExpression[],
|
|
319
|
-
environment: Environment,
|
|
320
|
-
search: SearchGraph<Value[]>,
|
|
321
|
-
): LivenessChecker | undefined => {
|
|
322
|
-
if (properties.length === 0) return undefined;
|
|
323
|
-
const live = getLiveFormula(properties, temporals, environment);
|
|
324
|
-
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
325
|
-
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
338
|
+
const isSharingResults = (formula: LiveExpression, environment: Environment) => {
|
|
326
339
|
const formulaAtoms = new Set<LiveAtom>();
|
|
327
|
-
collectAtoms(
|
|
340
|
+
collectAtoms(formula, formulaAtoms);
|
|
328
341
|
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
329
|
-
|
|
342
|
+
return checked.every((item) => item.scope === undefined)
|
|
330
343
|
? !isExpressionImpure(
|
|
331
344
|
checked.map((item) => item.expression),
|
|
332
345
|
environment,
|
|
333
346
|
"repeated",
|
|
334
347
|
)
|
|
335
348
|
: !hasRepeatedEffects(environment);
|
|
336
|
-
|
|
349
|
+
};
|
|
350
|
+
|
|
351
|
+
const getViolatedProperties = (
|
|
352
|
+
properties: TemporalProperty[],
|
|
353
|
+
checks: LiveExpression[],
|
|
354
|
+
path: Value[][],
|
|
355
|
+
cycleStart: number,
|
|
356
|
+
environment: Environment,
|
|
357
|
+
failures?: TlaEvaluationError[],
|
|
358
|
+
) => [
|
|
359
|
+
...new Set(
|
|
360
|
+
properties
|
|
361
|
+
.filter((_property, position) => {
|
|
362
|
+
try {
|
|
363
|
+
return !evaluateOnLasso(checks[position], path, cycleStart, 0, environment);
|
|
364
|
+
} catch (error) {
|
|
365
|
+
if (!failures || !(error instanceof TlaEvaluationError)) throw error;
|
|
366
|
+
failures.push(error);
|
|
367
|
+
return false;
|
|
368
|
+
}
|
|
369
|
+
})
|
|
370
|
+
.map((property) => property.name),
|
|
371
|
+
),
|
|
372
|
+
];
|
|
373
|
+
|
|
374
|
+
export const createLivenessChecks = (
|
|
375
|
+
properties: TemporalProperty[],
|
|
376
|
+
temporals: ScopedExpression[],
|
|
377
|
+
environment: Environment,
|
|
378
|
+
): LivenessChecks | undefined => {
|
|
379
|
+
if (properties.length === 0) return undefined;
|
|
380
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
381
|
+
const solutions = getSolutions(live.formula);
|
|
382
|
+
const atoms = getInterpretedAtoms(environment);
|
|
383
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
384
|
+
return {
|
|
385
|
+
solutions,
|
|
386
|
+
findTraceViolation: (trace, fingerprints) => {
|
|
387
|
+
const lasso = findTraceLasso(trace, fingerprints, solutions, atoms, isShared);
|
|
388
|
+
if (!lasso) return undefined;
|
|
389
|
+
// Liveness#findViolatedProperties reports a property it fails to evaluate on the lasso and goes on.
|
|
390
|
+
const failures: TlaEvaluationError[] = [];
|
|
391
|
+
const violated = getViolatedProperties(
|
|
392
|
+
properties,
|
|
393
|
+
live.checks,
|
|
394
|
+
lasso.positions.map((position) => trace[position]),
|
|
395
|
+
lasso.cyclePosition - 1,
|
|
396
|
+
environment,
|
|
397
|
+
failures,
|
|
398
|
+
);
|
|
399
|
+
return { ...lasso, properties: violated, failures };
|
|
400
|
+
},
|
|
401
|
+
};
|
|
402
|
+
};
|
|
403
|
+
|
|
404
|
+
export const createLivenessChecker = (
|
|
405
|
+
properties: TemporalProperty[],
|
|
406
|
+
temporals: ScopedExpression[],
|
|
407
|
+
environment: Environment,
|
|
408
|
+
search: SearchGraph<Value[]>,
|
|
409
|
+
): LivenessChecker | undefined => {
|
|
410
|
+
if (properties.length === 0) return undefined;
|
|
411
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
412
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
337
413
|
const solutions = getSolutions(live.formula);
|
|
414
|
+
const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
|
|
338
415
|
const graph = createLiveGraph(
|
|
339
416
|
solutions,
|
|
340
417
|
{
|
|
@@ -353,16 +430,22 @@ export const createLivenessChecker = (
|
|
|
353
430
|
}
|
|
354
431
|
},
|
|
355
432
|
},
|
|
356
|
-
|
|
433
|
+
{
|
|
434
|
+
getFingerprint: search.getFingerprint,
|
|
435
|
+
forEachActionSuccessors: (index, state, onSuccessors) =>
|
|
436
|
+
search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
|
|
437
|
+
},
|
|
357
438
|
environment.runtime.version !== "1.7.4",
|
|
358
439
|
);
|
|
359
440
|
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
360
441
|
if (replay === undefined) return run();
|
|
361
442
|
tracing.atoms = getInterpretedAtoms(replay);
|
|
443
|
+
tracing.replay = replay;
|
|
362
444
|
try {
|
|
363
445
|
return run();
|
|
364
446
|
} finally {
|
|
365
447
|
tracing.atoms = getInterpretedAtoms(environment);
|
|
448
|
+
tracing.replay = undefined;
|
|
366
449
|
}
|
|
367
450
|
};
|
|
368
451
|
return {
|
|
@@ -371,20 +454,12 @@ export const createLivenessChecker = (
|
|
|
371
454
|
addInitialState: (index, state, replay) =>
|
|
372
455
|
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
373
456
|
addState: (index, state, successors, replay) =>
|
|
374
|
-
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
457
|
+
traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
|
|
375
458
|
storeState: graph.storeState,
|
|
376
459
|
getStateCounts: graph.getStateCounts,
|
|
377
460
|
findViolation: graph.findViolation,
|
|
378
|
-
getViolatedProperties: (path, cycleStart) =>
|
|
379
|
-
|
|
380
|
-
properties
|
|
381
|
-
.filter(
|
|
382
|
-
(_property, position) =>
|
|
383
|
-
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
384
|
-
)
|
|
385
|
-
.map((property) => property.name),
|
|
386
|
-
),
|
|
387
|
-
],
|
|
461
|
+
getViolatedProperties: (path, cycleStart) =>
|
|
462
|
+
getViolatedProperties(properties, live.checks, path, cycleStart, environment),
|
|
388
463
|
};
|
|
389
464
|
};
|
|
390
465
|
|
|
@@ -637,7 +712,6 @@ export const createLiveGraph = <State>(
|
|
|
637
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
638
713
|
return node;
|
|
639
714
|
};
|
|
640
|
-
// TLC's table of tableau nodes has a state once the search expands it or it has a node.
|
|
641
715
|
const hasState = (behavior: BehaviorGraph<State>, state: number) =>
|
|
642
716
|
state < 0
|
|
643
717
|
? behavior.checks.nodes.some(
|
|
@@ -756,39 +830,57 @@ export const createLiveGraph = <State>(
|
|
|
756
830
|
actions.push(0);
|
|
757
831
|
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
758
832
|
}
|
|
759
|
-
const nextStates = search.getSuccessors(index, state);
|
|
760
833
|
// The results of the step to the state itself come first, then those of each successor.
|
|
761
|
-
const
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
const
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
const
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
834
|
+
const actionBatches = [selfResults];
|
|
835
|
+
let stepCount = 1;
|
|
836
|
+
search.forEachActionSuccessors(index, state, (nextStates) => {
|
|
837
|
+
const edges = createEdgeRows(nextStates.length);
|
|
838
|
+
const results = new Uint8Array(nextStates.length * actionCount);
|
|
839
|
+
actionBatches.push(results);
|
|
840
|
+
for (let position = 0; position < nextStates.length; position++) {
|
|
841
|
+
const successor = nextStates[position];
|
|
842
|
+
const successorRow = createRows(1);
|
|
843
|
+
checkAction(
|
|
844
|
+
behavior,
|
|
845
|
+
index,
|
|
846
|
+
state,
|
|
847
|
+
row,
|
|
848
|
+
offset,
|
|
849
|
+
successor.state,
|
|
850
|
+
edges,
|
|
851
|
+
position * actionIds.size,
|
|
852
|
+
results,
|
|
853
|
+
position * actionCount,
|
|
854
|
+
);
|
|
855
|
+
const isDone = behavior.isDone[successor.index] === true;
|
|
856
|
+
for (const next of tableauNode.successors) {
|
|
857
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
858
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
859
|
+
if (existing !== undefined && successors.includes(existing)) continue;
|
|
860
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
861
|
+
successors.push(target);
|
|
862
|
+
actions.push(stepCount + position);
|
|
863
|
+
if (existing === undefined && isDone) {
|
|
864
|
+
expandLate(
|
|
865
|
+
behavior,
|
|
866
|
+
tableau,
|
|
867
|
+
successor.state,
|
|
868
|
+
successor.index,
|
|
869
|
+
target,
|
|
870
|
+
successorRow,
|
|
871
|
+
0,
|
|
872
|
+
);
|
|
873
|
+
}
|
|
788
874
|
}
|
|
789
875
|
}
|
|
876
|
+
stepCount += nextStates.length;
|
|
790
877
|
});
|
|
791
878
|
if (successors.length > 0) {
|
|
879
|
+
const actionResults = new Uint8Array(stepCount * actionCount);
|
|
880
|
+
for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
|
|
881
|
+
actionResults.set(actionBatches[batch], resultOffset);
|
|
882
|
+
resultOffset += actionBatches[batch].length;
|
|
883
|
+
}
|
|
792
884
|
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
793
885
|
}
|
|
794
886
|
};
|
|
@@ -1143,7 +1235,7 @@ export const createLiveGraph = <State>(
|
|
|
1143
1235
|
}
|
|
1144
1236
|
}
|
|
1145
1237
|
},
|
|
1146
|
-
addState: (index, state, successors) => {
|
|
1238
|
+
addState: (index, state, successors, isRerun) => {
|
|
1147
1239
|
const set = getSuccessorSet(index, state, successors);
|
|
1148
1240
|
const rows = createRows(set.length);
|
|
1149
1241
|
// The set holds the state itself, as a successor of the same index.
|
|
@@ -1168,6 +1260,15 @@ export const createLiveGraph = <State>(
|
|
|
1168
1260
|
);
|
|
1169
1261
|
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1170
1262
|
const tableau = behavior.solution.tableau;
|
|
1263
|
+
// TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
|
|
1264
|
+
if (
|
|
1265
|
+
isRerun &&
|
|
1266
|
+
(tableau
|
|
1267
|
+
? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
|
|
1268
|
+
: set.every((successor) => isWritten(behavior, successor.index)))
|
|
1269
|
+
) {
|
|
1270
|
+
throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
|
|
1271
|
+
}
|
|
1171
1272
|
if (!tableau) {
|
|
1172
1273
|
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1173
1274
|
continue;
|
package/src/liveness.ts
CHANGED
|
@@ -16,6 +16,7 @@ import {
|
|
|
16
16
|
forEachBoundElement,
|
|
17
17
|
getBoundElements,
|
|
18
18
|
getDefinition,
|
|
19
|
+
getReevaluatedDefinitions,
|
|
19
20
|
getStartupValue,
|
|
20
21
|
lookupScope,
|
|
21
22
|
resolveApplyOperator,
|
|
@@ -26,6 +27,7 @@ import {
|
|
|
26
27
|
type Scope,
|
|
27
28
|
type Thunk,
|
|
28
29
|
} from "./evaluate";
|
|
30
|
+
import { letDefinitions } from "./coverage";
|
|
29
31
|
import { mapChildren } from "./instances";
|
|
30
32
|
import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "./levels";
|
|
31
33
|
import { isEnabled } from "./successors";
|
|
@@ -243,6 +245,7 @@ export const expandTemporal = (
|
|
|
243
245
|
return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
|
|
244
246
|
}
|
|
245
247
|
if (expression.kind === "Label") return expand(expression.body, scope);
|
|
248
|
+
if (expression.kind === "Selection") return expand(expression.expression, scope);
|
|
246
249
|
if (expression.kind === "Let") {
|
|
247
250
|
return expand(expression.body, bindLetDefinitions(expression, scope, environment));
|
|
248
251
|
}
|
|
@@ -323,14 +326,22 @@ export const expandTemporal = (
|
|
|
323
326
|
return [{ expression, scope, name: expansion.name, path: expansion.path }];
|
|
324
327
|
};
|
|
325
328
|
|
|
326
|
-
|
|
329
|
+
// TLC takes a formula apart through a LET without binding its definitions, so it evaluates an impure one again at each reference.
|
|
330
|
+
export const bindLetDefinitions = (
|
|
327
331
|
expression: Expression & { kind: "Let" },
|
|
328
332
|
scope: Scope | undefined,
|
|
329
333
|
environment: Environment,
|
|
330
334
|
) => {
|
|
331
|
-
const bound = bindDefinitions(
|
|
335
|
+
const bound = bindDefinitions(
|
|
336
|
+
expression.definitions,
|
|
337
|
+
getConstantContext(environment, scope),
|
|
338
|
+
getReevaluatedDefinitions(expression.definitions, environment),
|
|
339
|
+
);
|
|
332
340
|
for (let current = bound; current && current !== scope; current = current.parent) {
|
|
333
341
|
if (current.binding.kind === "Thunk") definitionThunks.add(current.binding);
|
|
342
|
+
const name = current.name;
|
|
343
|
+
const definition = expression.definitions.find((item) => item.name === name);
|
|
344
|
+
if (definition) letDefinitions.set(current, definition);
|
|
334
345
|
}
|
|
335
346
|
return bound;
|
|
336
347
|
};
|
|
@@ -488,12 +499,53 @@ export const toLiveExpression = (
|
|
|
488
499
|
return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
|
|
489
500
|
};
|
|
490
501
|
|
|
502
|
+
// SANY parses `a /\ b /\ c` as `(a /\ b) /\ c`, so TLC takes a prefix below the temporal level as one formula.
|
|
503
|
+
const convertJunction = (
|
|
504
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
505
|
+
scope: Scope | undefined,
|
|
506
|
+
) => {
|
|
507
|
+
const operands = expression.operands;
|
|
508
|
+
const range = expression.location.range;
|
|
509
|
+
const prefixEnds = expression.prefixEnds;
|
|
510
|
+
if (expression.isBulleted || !range || !prefixEnds) {
|
|
511
|
+
return toWhole(
|
|
512
|
+
expression,
|
|
513
|
+
scope,
|
|
514
|
+
createJunction(
|
|
515
|
+
expression.kind,
|
|
516
|
+
operands.map((operand) => convert(operand, scope)),
|
|
517
|
+
),
|
|
518
|
+
);
|
|
519
|
+
}
|
|
520
|
+
return operands.slice(1).reduce(
|
|
521
|
+
(prefix, operand, index) => {
|
|
522
|
+
const node =
|
|
523
|
+
index === operands.length - 2
|
|
524
|
+
? expression
|
|
525
|
+
: {
|
|
526
|
+
...expression,
|
|
527
|
+
operands: operands.slice(0, index + 2),
|
|
528
|
+
prefixEnds: prefixEnds.slice(0, index + 1),
|
|
529
|
+
location: { ...expression.location, range: { ...range, end: prefixEnds[index] } },
|
|
530
|
+
};
|
|
531
|
+
return toWhole(
|
|
532
|
+
node,
|
|
533
|
+
scope,
|
|
534
|
+
createJunction(expression.kind, [prefix, convert(operand, scope)]),
|
|
535
|
+
);
|
|
536
|
+
},
|
|
537
|
+
convert(operands[0], scope),
|
|
538
|
+
);
|
|
539
|
+
};
|
|
540
|
+
|
|
491
541
|
// These forms are translated part by part at every level; any other form below the temporal level is an atom.
|
|
492
542
|
const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
|
|
493
543
|
const level = getLevel(expression, scope, environment);
|
|
494
544
|
switch (expression.kind) {
|
|
495
545
|
case "Label":
|
|
496
546
|
return convert(expression.body, scope);
|
|
547
|
+
case "Selection":
|
|
548
|
+
return convert(expression.expression, scope);
|
|
497
549
|
case "Let":
|
|
498
550
|
return convert(expression.body, bindLetDefinitions(expression, scope, environment));
|
|
499
551
|
case "Apply": {
|
|
@@ -512,14 +564,7 @@ export const toLiveExpression = (
|
|
|
512
564
|
}
|
|
513
565
|
case "And":
|
|
514
566
|
case "Or":
|
|
515
|
-
return
|
|
516
|
-
expression,
|
|
517
|
-
scope,
|
|
518
|
-
createJunction(
|
|
519
|
-
expression.kind,
|
|
520
|
-
expression.operands.map((operand) => convert(operand, scope)),
|
|
521
|
-
),
|
|
522
|
-
);
|
|
567
|
+
return convertJunction(expression, scope);
|
|
523
568
|
case "Forall":
|
|
524
569
|
case "Exists":
|
|
525
570
|
return convertQuantifier(expression, scope);
|
package/src/obligations/index.ts
CHANGED
|
@@ -179,7 +179,7 @@ const loadMule = (
|
|
|
179
179
|
|
|
180
180
|
const schedule = (modules: Map<string, Mule>) => {
|
|
181
181
|
const dependencies = new Map(
|
|
182
|
-
[...modules].map((
|
|
182
|
+
[...modules].map((entry) => [entry[0], getDependencies(entry[1]).dependencies]),
|
|
183
183
|
);
|
|
184
184
|
const seen = new Set<string>();
|
|
185
185
|
const order: Mule[] = [];
|
|
@@ -351,10 +351,7 @@ const instantiate = (
|
|
|
351
351
|
substitutes.set(name, at({ kind: "Opaque", name }, { location }));
|
|
352
352
|
}
|
|
353
353
|
const anonymized = new Map(
|
|
354
|
-
[...substitutes].map(([
|
|
355
|
-
name,
|
|
356
|
-
pipeline.anonymizer.expr(instanceScope, expression),
|
|
357
|
-
]),
|
|
354
|
+
[...substitutes].map((entry) => [entry[0], pipeline.anonymizer.expr(instanceScope, entry[1])]),
|
|
358
355
|
);
|
|
359
356
|
const body = substituteUnits(
|
|
360
357
|
shift((instanceScope?.size ?? 0) - (module.depth ?? 0)),
|
|
@@ -430,26 +430,26 @@ const createPrinter = (hyps: Hyp[] = [], options: PrinterOptions = {}) => {
|
|
|
430
430
|
);
|
|
431
431
|
case "Choose": {
|
|
432
432
|
const domainDoc = expression.domain && printExpr(expression.domain);
|
|
433
|
-
return withNames(context, [expression.name], (
|
|
433
|
+
return withNames(context, [expression.name], (names) =>
|
|
434
434
|
createBig(
|
|
435
435
|
domainDoc
|
|
436
436
|
? format(
|
|
437
437
|
"@[<b2>CHOOSE @[<b2>%s \\in@ %a@] :@ %a@]",
|
|
438
|
-
|
|
438
|
+
names[0],
|
|
439
439
|
domainDoc,
|
|
440
440
|
printExpr(expression.body),
|
|
441
441
|
)
|
|
442
|
-
: format("@[<b2>CHOOSE %s :@ %a@]",
|
|
442
|
+
: format("@[<b2>CHOOSE %s :@ %a@]", names[0], printExpr(expression.body)),
|
|
443
443
|
),
|
|
444
444
|
);
|
|
445
445
|
}
|
|
446
446
|
case "SetSt": {
|
|
447
447
|
const domainDoc = printExpr(expression.domain);
|
|
448
|
-
return withNames(context, [expression.name], (
|
|
448
|
+
return withNames(context, [expression.name], (names) =>
|
|
449
449
|
createAtom(
|
|
450
450
|
format(
|
|
451
451
|
"@[<b3>{@[<b2>%s \\in@ %a@] :@ %a}@]",
|
|
452
|
-
|
|
452
|
+
names[0],
|
|
453
453
|
domainDoc,
|
|
454
454
|
printExpr(expression.body),
|
|
455
455
|
),
|
|
@@ -643,6 +643,8 @@ export const createModuleConverter = (
|
|
|
643
643
|
},
|
|
644
644
|
{ location },
|
|
645
645
|
);
|
|
646
|
+
case "Selection":
|
|
647
|
+
return recurse(expression.expression);
|
|
646
648
|
case "Subexpression": {
|
|
647
649
|
const [head, ...selectors] = expression.selectors;
|
|
648
650
|
if (head.kind !== "Name") throw new TlaProofError("Unexpected subexpression reference");
|