tla-ts 0.0.10-dev.3a85c3a9e → 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 +36 -36
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- 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 +56 -56
- package/dist/prove.js +79 -79
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -92
- package/dist/transfer.js +97 -92
- 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 +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -107
- package/src/check.ts +535 -281
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +21 -7
- package/src/cli/tlc.ts +31 -11
- 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 +101 -36
- package/src/environment.ts +131 -41
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -13
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +204 -62
- 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/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- 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 +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- 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 +84 -15
- 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 +4 -10
- 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/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +608 -139
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- 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/containers.ts +7 -1
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- 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/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
- package/src/prover/smt/solver/lp/nla-core.ts +26 -6
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
- package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- 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 +22 -44
- 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 +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- 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 +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -71
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- 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 +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- 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 +10 -6
- 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/quantifier-manager.ts +14 -9
- 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 +20 -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 +17 -7
- 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 +4 -7
- 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 +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +713 -210
- 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 +350 -195
- 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 +10 -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/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -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/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +1274 -258
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +18 -12
- package/src/sany/generator.ts +12 -6
- 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 +348 -153
- package/src/simulate.ts +250 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -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 +87 -26
- package/src/tlc/trace-spec.ts +11 -25
- 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[]> {
|
|
@@ -45,10 +46,22 @@ export interface LivenessChecker {
|
|
|
45
46
|
successors: LiveSuccessor[],
|
|
46
47
|
tracing?: Environment,
|
|
47
48
|
) => number[] | undefined;
|
|
49
|
+
storeState: (pending: number, index: number) => void;
|
|
50
|
+
getStateCounts: () => number[];
|
|
48
51
|
findViolation: () => Lasso | undefined;
|
|
49
52
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
50
53
|
}
|
|
51
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
|
+
|
|
52
65
|
export interface LiveGraph<State> {
|
|
53
66
|
branches: number;
|
|
54
67
|
addInitialState: (index: number, state: State) => void;
|
|
@@ -57,13 +70,26 @@ export interface LiveGraph<State> {
|
|
|
57
70
|
index: number,
|
|
58
71
|
state: State,
|
|
59
72
|
successors: LiveSuccessor<State>[],
|
|
73
|
+
isRerun?: boolean,
|
|
60
74
|
) => number[] | undefined;
|
|
75
|
+
storeState: (pending: number, index: number) => void;
|
|
76
|
+
getStateCounts: () => number[];
|
|
61
77
|
findViolation: () => Lasso | undefined;
|
|
62
78
|
}
|
|
63
79
|
|
|
64
80
|
export interface SearchGraph<State> {
|
|
65
81
|
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
66
|
-
|
|
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;
|
|
67
93
|
}
|
|
68
94
|
|
|
69
95
|
export interface LiveEvaluation<State> {
|
|
@@ -114,6 +140,7 @@ interface BehaviorGraph<State> {
|
|
|
114
140
|
nextSiblings: number[];
|
|
115
141
|
nodeIds: NodeTable;
|
|
116
142
|
isDone: boolean[];
|
|
143
|
+
stateCount: number;
|
|
117
144
|
errorNode: number | undefined;
|
|
118
145
|
}
|
|
119
146
|
|
|
@@ -246,13 +273,14 @@ const getLiveFormula = (
|
|
|
246
273
|
const fairness = temporals.map((item) =>
|
|
247
274
|
toLiveExpression(item.expression, item.scope, environment),
|
|
248
275
|
);
|
|
249
|
-
const
|
|
250
|
-
|
|
276
|
+
const checks = properties.map((property) =>
|
|
277
|
+
toLiveExpression(property.expression, property.scope, environment),
|
|
251
278
|
);
|
|
279
|
+
const negations = checks.map((check) => createUnary("Not", check));
|
|
252
280
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
253
281
|
const formula =
|
|
254
282
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
255
|
-
return { formula,
|
|
283
|
+
return { formula, checks };
|
|
256
284
|
};
|
|
257
285
|
|
|
258
286
|
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
@@ -307,28 +335,83 @@ export const getLiveExpressions = (solutions: Solution[]) =>
|
|
|
307
335
|
getAtomExpressions(atom).map((item) => item.expression),
|
|
308
336
|
);
|
|
309
337
|
|
|
310
|
-
|
|
311
|
-
properties: TemporalProperty[],
|
|
312
|
-
temporals: ScopedExpression[],
|
|
313
|
-
environment: Environment,
|
|
314
|
-
search: SearchGraph<Value[]>,
|
|
315
|
-
): LivenessChecker | undefined => {
|
|
316
|
-
if (properties.length === 0) return undefined;
|
|
317
|
-
const live = getLiveFormula(properties, temporals, environment);
|
|
318
|
-
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
319
|
-
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
338
|
+
const isSharingResults = (formula: LiveExpression, environment: Environment) => {
|
|
320
339
|
const formulaAtoms = new Set<LiveAtom>();
|
|
321
|
-
collectAtoms(
|
|
340
|
+
collectAtoms(formula, formulaAtoms);
|
|
322
341
|
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
323
|
-
|
|
342
|
+
return checked.every((item) => item.scope === undefined)
|
|
324
343
|
? !isExpressionImpure(
|
|
325
344
|
checked.map((item) => item.expression),
|
|
326
345
|
environment,
|
|
327
346
|
"repeated",
|
|
328
347
|
)
|
|
329
348
|
: !hasRepeatedEffects(environment);
|
|
330
|
-
|
|
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);
|
|
331
413
|
const solutions = getSolutions(live.formula);
|
|
414
|
+
const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
|
|
332
415
|
const graph = createLiveGraph(
|
|
333
416
|
solutions,
|
|
334
417
|
{
|
|
@@ -347,16 +430,22 @@ export const createLivenessChecker = (
|
|
|
347
430
|
}
|
|
348
431
|
},
|
|
349
432
|
},
|
|
350
|
-
|
|
433
|
+
{
|
|
434
|
+
getFingerprint: search.getFingerprint,
|
|
435
|
+
forEachActionSuccessors: (index, state, onSuccessors) =>
|
|
436
|
+
search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
|
|
437
|
+
},
|
|
351
438
|
environment.runtime.version !== "1.7.4",
|
|
352
439
|
);
|
|
353
440
|
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
354
441
|
if (replay === undefined) return run();
|
|
355
442
|
tracing.atoms = getInterpretedAtoms(replay);
|
|
443
|
+
tracing.replay = replay;
|
|
356
444
|
try {
|
|
357
445
|
return run();
|
|
358
446
|
} finally {
|
|
359
447
|
tracing.atoms = getInterpretedAtoms(environment);
|
|
448
|
+
tracing.replay = undefined;
|
|
360
449
|
}
|
|
361
450
|
};
|
|
362
451
|
return {
|
|
@@ -365,18 +454,12 @@ export const createLivenessChecker = (
|
|
|
365
454
|
addInitialState: (index, state, replay) =>
|
|
366
455
|
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
367
456
|
addState: (index, state, successors, replay) =>
|
|
368
|
-
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
457
|
+
traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
|
|
458
|
+
storeState: graph.storeState,
|
|
459
|
+
getStateCounts: graph.getStateCounts,
|
|
369
460
|
findViolation: graph.findViolation,
|
|
370
|
-
getViolatedProperties: (path, cycleStart) =>
|
|
371
|
-
|
|
372
|
-
properties
|
|
373
|
-
.filter(
|
|
374
|
-
(_property, position) =>
|
|
375
|
-
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
376
|
-
)
|
|
377
|
-
.map((property) => property.name),
|
|
378
|
-
),
|
|
379
|
-
],
|
|
461
|
+
getViolatedProperties: (path, cycleStart) =>
|
|
462
|
+
getViolatedProperties(properties, live.checks, path, cycleStart, environment),
|
|
380
463
|
};
|
|
381
464
|
};
|
|
382
465
|
|
|
@@ -505,6 +588,7 @@ export const createLiveGraph = <State>(
|
|
|
505
588
|
nextSiblings: [],
|
|
506
589
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
507
590
|
isDone: [],
|
|
591
|
+
stateCount: 0,
|
|
508
592
|
errorNode: undefined,
|
|
509
593
|
}));
|
|
510
594
|
const checkState = (
|
|
@@ -600,8 +684,12 @@ export const createLiveGraph = <State>(
|
|
|
600
684
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
601
685
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
602
686
|
};
|
|
603
|
-
const
|
|
604
|
-
|
|
687
|
+
const linkNode = (
|
|
688
|
+
behavior: BehaviorGraph<State>,
|
|
689
|
+
state: number,
|
|
690
|
+
tableauNode: number,
|
|
691
|
+
node: number,
|
|
692
|
+
) => {
|
|
605
693
|
const table = behavior.nodeIds;
|
|
606
694
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
607
695
|
const old = table.slots;
|
|
@@ -617,12 +705,23 @@ export const createLiveGraph = <State>(
|
|
|
617
705
|
}
|
|
618
706
|
}
|
|
619
707
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
708
|
+
if (state < 0) return node;
|
|
620
709
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
621
710
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
622
711
|
else behavior.nextSiblings[last] = node;
|
|
623
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
624
713
|
return node;
|
|
625
714
|
};
|
|
715
|
+
const hasState = (behavior: BehaviorGraph<State>, state: number) =>
|
|
716
|
+
state < 0
|
|
717
|
+
? behavior.checks.nodes.some(
|
|
718
|
+
(_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
|
|
719
|
+
)
|
|
720
|
+
: behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
|
|
721
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
722
|
+
if (!hasState(behavior, state)) behavior.stateCount++;
|
|
723
|
+
return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
|
|
724
|
+
};
|
|
626
725
|
// The action results of the edge to each target are at its position in actions.
|
|
627
726
|
const writeNode = (
|
|
628
727
|
behavior: BehaviorGraph<State>,
|
|
@@ -731,41 +830,57 @@ export const createLiveGraph = <State>(
|
|
|
731
830
|
actions.push(0);
|
|
732
831
|
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
733
832
|
}
|
|
734
|
-
const nextStates = search.getSuccessors(index, state);
|
|
735
833
|
// The results of the step to the state itself come first, then those of each successor.
|
|
736
|
-
const
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
const
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
const
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
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
|
+
}
|
|
765
874
|
}
|
|
766
875
|
}
|
|
876
|
+
stepCount += nextStates.length;
|
|
767
877
|
});
|
|
768
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
|
+
}
|
|
769
884
|
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
770
885
|
}
|
|
771
886
|
};
|
|
@@ -791,6 +906,7 @@ export const createLiveGraph = <State>(
|
|
|
791
906
|
}
|
|
792
907
|
}
|
|
793
908
|
});
|
|
909
|
+
if (!hasState(behavior, index)) behavior.stateCount++;
|
|
794
910
|
behavior.isDone[index] = true;
|
|
795
911
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
796
912
|
for (const node of getStateNodes(behavior, index)) {
|
|
@@ -840,6 +956,7 @@ export const createLiveGraph = <State>(
|
|
|
840
956
|
successors.push(successor.index);
|
|
841
957
|
actions.push(position);
|
|
842
958
|
});
|
|
959
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
843
960
|
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
844
961
|
};
|
|
845
962
|
|
|
@@ -1118,7 +1235,7 @@ export const createLiveGraph = <State>(
|
|
|
1118
1235
|
}
|
|
1119
1236
|
}
|
|
1120
1237
|
},
|
|
1121
|
-
addState: (index, state, successors) => {
|
|
1238
|
+
addState: (index, state, successors, isRerun) => {
|
|
1122
1239
|
const set = getSuccessorSet(index, state, successors);
|
|
1123
1240
|
const rows = createRows(set.length);
|
|
1124
1241
|
// The set holds the state itself, as a successor of the same index.
|
|
@@ -1143,6 +1260,15 @@ export const createLiveGraph = <State>(
|
|
|
1143
1260
|
);
|
|
1144
1261
|
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1145
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
|
+
}
|
|
1146
1272
|
if (!tableau) {
|
|
1147
1273
|
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1148
1274
|
continue;
|
|
@@ -1160,6 +1286,22 @@ export const createLiveGraph = <State>(
|
|
|
1160
1286
|
}
|
|
1161
1287
|
return undefined;
|
|
1162
1288
|
},
|
|
1289
|
+
storeState: (pending, index) => {
|
|
1290
|
+
for (const behavior of behaviors) {
|
|
1291
|
+
const tableau = behavior.solution.tableau;
|
|
1292
|
+
if (!tableau) continue;
|
|
1293
|
+
const nodes: number[] = [];
|
|
1294
|
+
for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
|
|
1295
|
+
const node = getNodeId(behavior, pending, tableauNode);
|
|
1296
|
+
if (node !== undefined) nodes.push(node);
|
|
1297
|
+
}
|
|
1298
|
+
for (const node of nodes.sort((left, right) => left - right)) {
|
|
1299
|
+
behavior.nodeStates[node] = index;
|
|
1300
|
+
linkNode(behavior, index, behavior.nodeTableaux[node], node);
|
|
1301
|
+
}
|
|
1302
|
+
}
|
|
1303
|
+
},
|
|
1304
|
+
getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
|
|
1163
1305
|
findViolation: () => {
|
|
1164
1306
|
for (const behavior of behaviors) {
|
|
1165
1307
|
for (const model of behavior.solution.models) {
|
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");
|
package/src/parallel-worker.ts
CHANGED
|
@@ -41,8 +41,14 @@ const runWorker = (start: StartMessage, parent: Port) => {
|
|
|
41
41
|
);
|
|
42
42
|
const specification = created.specification;
|
|
43
43
|
const environment = specification.environment;
|
|
44
|
-
const search = createSearch(
|
|
45
|
-
|
|
44
|
+
const search = createSearch(
|
|
45
|
+
start.config,
|
|
46
|
+
environment,
|
|
47
|
+
specification.variableLocations,
|
|
48
|
+
() => created.order.getDeclarationOrder("variable"),
|
|
49
|
+
undefined,
|
|
50
|
+
[],
|
|
51
|
+
specification.runtimeInvariants,
|
|
46
52
|
);
|
|
47
53
|
const nextAction = search?.spec.next;
|
|
48
54
|
if (!search || nextAction === undefined)
|