tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.b254db0
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/README.md +33 -143
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -47
- package/dist/run-cli.js +37 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/codegen.ts +5 -3
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +54 -19
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +265 -55
- package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
- package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
- package/src/{obligations.ts → obligations/index.ts} +29 -13
- package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
- package/src/{obligation-module.ts → obligations/module.ts} +56 -33
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +159 -97
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +100 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +503 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +521 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +557 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +25 -0
- package/src/prove/prove.ts +505 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +222 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +166 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +773 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +437 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +334 -75
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +80 -35
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,236 @@
|
|
|
1
|
+
// tlapm's fingerprints file, ported from src/backend/fpfile.ml.
|
|
2
|
+
|
|
3
|
+
import {
|
|
4
|
+
cpSync,
|
|
5
|
+
existsSync,
|
|
6
|
+
mkdirSync,
|
|
7
|
+
readdirSync,
|
|
8
|
+
readFileSync,
|
|
9
|
+
renameSync,
|
|
10
|
+
rmSync,
|
|
11
|
+
statSync,
|
|
12
|
+
writeFileSync,
|
|
13
|
+
} from "node:fs";
|
|
14
|
+
import { basename, join } from "node:path";
|
|
15
|
+
import { version } from "../package.json";
|
|
16
|
+
import { TlaProofError } from "./errors";
|
|
17
|
+
import { block, isBlock, readMarshaled, writeMarshaled, type OcamlValue } from "./ocaml-marshal";
|
|
18
|
+
import type { ProofAttempt } from "./prove/prove";
|
|
19
|
+
|
|
20
|
+
// One optional result per prover, in V13.str's order.
|
|
21
|
+
export type FingerprintTable = Map<string, OcamlValue[]>;
|
|
22
|
+
|
|
23
|
+
const MAGIC_NUMBER = 20210223;
|
|
24
|
+
|
|
25
|
+
const RECORD_SIZE = 23;
|
|
26
|
+
|
|
27
|
+
// Each prover's field in V13.str and constructor in V13.meth.
|
|
28
|
+
const PROVERS: Record<string, { field: number; tag: number }> = {
|
|
29
|
+
zenon: { field: 1, tag: 1 },
|
|
30
|
+
isabelle: { field: 2, tag: 0 },
|
|
31
|
+
smt: { field: 10, tag: 8 },
|
|
32
|
+
z3: { field: 11, tag: 9 },
|
|
33
|
+
ls4: { field: 17, tag: 16 },
|
|
34
|
+
};
|
|
35
|
+
|
|
36
|
+
const FAIL_METHOD = 5;
|
|
37
|
+
|
|
38
|
+
const REASONS = ["false", "timeout"];
|
|
39
|
+
|
|
40
|
+
// Stored as the tlapm, Zenon and Isabelle versions, which --safefp compares.
|
|
41
|
+
const VERSION = `tla-ts ${version}`;
|
|
42
|
+
|
|
43
|
+
const CHECKED_VERSIONS = new Map([
|
|
44
|
+
[PROVERS.zenon.field, 3],
|
|
45
|
+
[PROVERS.isabelle.field, 4],
|
|
46
|
+
]);
|
|
47
|
+
|
|
48
|
+
const HISTORY_SIZE = 10;
|
|
49
|
+
|
|
50
|
+
const getField = (value: OcamlValue | undefined, index: number) =>
|
|
51
|
+
value !== undefined && isBlock(value) ? value.fields[index] : undefined;
|
|
52
|
+
|
|
53
|
+
const getFloat = (value: OcamlValue | undefined) =>
|
|
54
|
+
value !== undefined && typeof value === "object" && "float" in value ? value.float : Infinity;
|
|
55
|
+
|
|
56
|
+
// Hashtbl.hash on a string.
|
|
57
|
+
const hashKey = (key: string) => {
|
|
58
|
+
const bytes = new TextEncoder().encode(key);
|
|
59
|
+
const rotate = (value: number, shift: number) => (value << shift) | (value >>> (32 - shift));
|
|
60
|
+
const mixed = Array.from(
|
|
61
|
+
{ length: Math.ceil(bytes.length / 4) },
|
|
62
|
+
(_, index) =>
|
|
63
|
+
bytes[index * 4] |
|
|
64
|
+
(bytes[index * 4 + 1] << 8) |
|
|
65
|
+
(bytes[index * 4 + 2] << 16) |
|
|
66
|
+
(bytes[index * 4 + 3] << 24),
|
|
67
|
+
).reduce((hash, word) => {
|
|
68
|
+
const data = Math.imul(rotate(Math.imul(word, 0xcc9e2d51), 15), 0x1b873593);
|
|
69
|
+
return (Math.imul(rotate(hash ^ data, 13), 5) + 0xe6546b64) | 0;
|
|
70
|
+
}, 0);
|
|
71
|
+
const first = Math.imul(mixed ^ bytes.length ^ ((mixed ^ bytes.length) >>> 16), 0x85ebca6b);
|
|
72
|
+
const second = Math.imul(first ^ (first >>> 13), 0xc2b2ae35);
|
|
73
|
+
return (second ^ (second >>> 16)) & 0x3fffffff;
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
const readBucket = (entry: OcamlValue | undefined): [OcamlValue, OcamlValue][] =>
|
|
77
|
+
entry !== undefined && isBlock(entry)
|
|
78
|
+
? [[entry.fields[0], entry.fields[1]], ...readBucket(entry.fields[2])]
|
|
79
|
+
: [];
|
|
80
|
+
|
|
81
|
+
// Fpfile.load_fingerprints. Each bucket lists the latest fingerprint first.
|
|
82
|
+
export const loadFingerprints = (table: FingerprintTable, path: string, isSafe: boolean) => {
|
|
83
|
+
const bytes = readFileSync(path);
|
|
84
|
+
const magic = readMarshaled(bytes, 0);
|
|
85
|
+
const fp = readMarshaled(bytes, magic.next).value;
|
|
86
|
+
if (magic.value !== MAGIC_NUMBER || !isBlock(fp) || fp.tag !== 0)
|
|
87
|
+
throw new TlaProofError("corrupted fingerprint file");
|
|
88
|
+
const buckets = getField(getField(fp, 0), 1);
|
|
89
|
+
const isTrusted = (sti: OcamlValue, field: number) => {
|
|
90
|
+
const index = CHECKED_VERSIONS.get(field);
|
|
91
|
+
return !isSafe || index === undefined || getField(getField(sti, 0), index) === VERSION;
|
|
92
|
+
};
|
|
93
|
+
table.clear();
|
|
94
|
+
(buckets !== undefined && isBlock(buckets) ? buckets.fields : [])
|
|
95
|
+
.flatMap((bucket) => readBucket(bucket).toReversed())
|
|
96
|
+
.forEach(([key, record]) => {
|
|
97
|
+
if (typeof key !== "string" || !isBlock(record))
|
|
98
|
+
throw new TlaProofError("corrupted fingerprint file");
|
|
99
|
+
table.set(
|
|
100
|
+
key,
|
|
101
|
+
record.fields.map((sti, field) => (isTrusted(sti, field) ? sti : 0)),
|
|
102
|
+
);
|
|
103
|
+
});
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
const decodeResult = (prover: string, sti: OcamlValue | undefined): ProofAttempt | undefined => {
|
|
107
|
+
const status = getField(sti, 0);
|
|
108
|
+
const outcome = getField(status, 0);
|
|
109
|
+
const argument = getField(getField(status, 1), 0);
|
|
110
|
+
if (outcome === undefined || outcome === 1) return undefined;
|
|
111
|
+
const seconds = getFloat(getField(prover === "isabelle" ? getField(argument, 0) : argument, 0));
|
|
112
|
+
const tactic = prover === "isabelle" ? getField(argument, 1) : undefined;
|
|
113
|
+
const reason = getField(getField(outcome, 0), 0);
|
|
114
|
+
return {
|
|
115
|
+
method: {
|
|
116
|
+
prover,
|
|
117
|
+
timeLimitMs: seconds * 1000,
|
|
118
|
+
...(typeof tactic === "string" && { tactic }),
|
|
119
|
+
},
|
|
120
|
+
isProved: outcome === 0,
|
|
121
|
+
isReused: false,
|
|
122
|
+
...(reason !== undefined && {
|
|
123
|
+
reason: typeof reason === "number" ? REASONS[reason] : String(getField(reason, 0)),
|
|
124
|
+
}),
|
|
125
|
+
};
|
|
126
|
+
};
|
|
127
|
+
|
|
128
|
+
// Fpfile.fp_writes, whose date counts months from 0.
|
|
129
|
+
const encodeResult = (attempt: ProofAttempt) => {
|
|
130
|
+
const now = new Date();
|
|
131
|
+
const method = attempt.method;
|
|
132
|
+
const timeout = { float: method.rlimit ?? method.timeLimitMs / 1000 };
|
|
133
|
+
const argument =
|
|
134
|
+
method.prover === "zenon"
|
|
135
|
+
? block(0, timeout, FAIL_METHOD)
|
|
136
|
+
: method.prover === "isabelle"
|
|
137
|
+
? block(0, block(0, timeout), method.tactic ?? "auto")
|
|
138
|
+
: block(0, timeout);
|
|
139
|
+
const reasonIndex = REASONS.indexOf(attempt.reason ?? "");
|
|
140
|
+
const reason =
|
|
141
|
+
attempt.reason === undefined
|
|
142
|
+
? 0
|
|
143
|
+
: block(0, reasonIndex === -1 ? block(0, attempt.reason) : reasonIndex);
|
|
144
|
+
return block(
|
|
145
|
+
0,
|
|
146
|
+
block(
|
|
147
|
+
0,
|
|
148
|
+
block(
|
|
149
|
+
0,
|
|
150
|
+
attempt.isProved ? 0 : block(0, reason),
|
|
151
|
+
block(PROVERS[method.prover].tag, argument),
|
|
152
|
+
),
|
|
153
|
+
block(
|
|
154
|
+
0,
|
|
155
|
+
now.getFullYear(),
|
|
156
|
+
now.getMonth(),
|
|
157
|
+
now.getDate(),
|
|
158
|
+
now.getHours(),
|
|
159
|
+
now.getMinutes(),
|
|
160
|
+
now.getSeconds(),
|
|
161
|
+
),
|
|
162
|
+
VERSION,
|
|
163
|
+
VERSION,
|
|
164
|
+
VERSION,
|
|
165
|
+
),
|
|
166
|
+
);
|
|
167
|
+
};
|
|
168
|
+
|
|
169
|
+
const encodeTable = (table: FingerprintTable) => {
|
|
170
|
+
const length = 2 ** Math.max(9, Math.ceil(Math.log2(table.size / 2)));
|
|
171
|
+
const buckets: OcamlValue[] = Array.from({ length }, () => 0);
|
|
172
|
+
table.forEach((record, fingerprint) => {
|
|
173
|
+
const index = hashKey(fingerprint) & (length - 1);
|
|
174
|
+
buckets[index] = block(0, fingerprint, block(0, ...record), buckets[index]);
|
|
175
|
+
});
|
|
176
|
+
return block(0, block(0, table.size, block(0, ...buckets), 0, 512));
|
|
177
|
+
};
|
|
178
|
+
|
|
179
|
+
const pad = (value: number) => String(value).padStart(2, "0");
|
|
180
|
+
|
|
181
|
+
// Fpfile.fp_init.
|
|
182
|
+
export const saveHistory = (path: string, sources: string[]) => {
|
|
183
|
+
const now = new Date();
|
|
184
|
+
const history = `${path}.history`;
|
|
185
|
+
const directory = join(
|
|
186
|
+
history,
|
|
187
|
+
`${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}_${pad(now.getMinutes())}_${pad(now.getSeconds())}`,
|
|
188
|
+
);
|
|
189
|
+
mkdirSync(directory, { recursive: true });
|
|
190
|
+
[path, ...sources]
|
|
191
|
+
.filter((file) => existsSync(file))
|
|
192
|
+
.forEach((file) => cpSync(file, join(directory, basename(file)), { preserveTimestamps: true }));
|
|
193
|
+
readdirSync(history)
|
|
194
|
+
.map((name) => join(history, name))
|
|
195
|
+
.sort((left, right) => statSync(right).mtimeMs - statSync(left).mtimeMs)
|
|
196
|
+
.slice(HISTORY_SIZE)
|
|
197
|
+
.forEach((old) => rmSync(old, { recursive: true, force: true }));
|
|
198
|
+
};
|
|
199
|
+
|
|
200
|
+
// Fpfile.query: what each prover concluded for each fingerprint. Saving them, as fp_writes,
|
|
201
|
+
// add_to_table and fp_close_and_consolidate do, keeps each record and result loaded unchanged, with
|
|
202
|
+
// its date, versions and other provers' results.
|
|
203
|
+
export const getKnownResults = (table: FingerprintTable) => {
|
|
204
|
+
const storedResults = new Map<ProofAttempt, OcamlValue>();
|
|
205
|
+
const storedRecords = new Map<Map<string, ProofAttempt>, OcamlValue[]>();
|
|
206
|
+
const results = new Map(
|
|
207
|
+
[...table].map(([fingerprint, record]) => {
|
|
208
|
+
const attempts = new Map(
|
|
209
|
+
Object.entries(PROVERS).flatMap(([prover, known]) => {
|
|
210
|
+
const result = decodeResult(prover, getField(record[known.field], 0));
|
|
211
|
+
if (!result) return [];
|
|
212
|
+
storedResults.set(result, record[known.field]);
|
|
213
|
+
return [[prover, result]];
|
|
214
|
+
}),
|
|
215
|
+
);
|
|
216
|
+
storedRecords.set(attempts, record);
|
|
217
|
+
return [fingerprint, attempts];
|
|
218
|
+
}),
|
|
219
|
+
);
|
|
220
|
+
const save = (path: string) => {
|
|
221
|
+
table.clear();
|
|
222
|
+
results.forEach((attempts, fingerprint) => {
|
|
223
|
+
const record = [...(storedRecords.get(attempts) ?? Array<OcamlValue>(RECORD_SIZE).fill(0))];
|
|
224
|
+
attempts.forEach((attempt, prover) => {
|
|
225
|
+
record[PROVERS[prover].field] = storedResults.get(attempt) ?? encodeResult(attempt);
|
|
226
|
+
});
|
|
227
|
+
table.set(fingerprint, record);
|
|
228
|
+
});
|
|
229
|
+
writeFileSync(
|
|
230
|
+
`${path}.tmp`,
|
|
231
|
+
Buffer.concat([writeMarshaled(MAGIC_NUMBER), writeMarshaled(encodeTable(table))]),
|
|
232
|
+
);
|
|
233
|
+
renameSync(`${path}.tmp`, path);
|
|
234
|
+
};
|
|
235
|
+
return { results, save };
|
|
236
|
+
};
|
package/src/tlc-random.ts
CHANGED
|
@@ -182,24 +182,14 @@ const createShiftTable = (length: number) => {
|
|
|
182
182
|
|
|
183
183
|
// Extending a fingerprint by a byte is linear over GF(2), so extending it by a value's bytes
|
|
184
184
|
// XORs the value's own fingerprint from zero into the fingerprint shifted by their length.
|
|
185
|
-
// The fingerprinter caches each distinct
|
|
186
|
-
//
|
|
187
|
-
// `words`, an Int32Array over a
|
|
185
|
+
// The fingerprinter caches each distinct function or set it meets, nested ones included, for one
|
|
186
|
+
// pass over the stored states, as states share most of their values. It reads a state's variables
|
|
187
|
+
// in `order` and writes each fingerprint's low and high words into `words`, an Int32Array over a
|
|
188
|
+
// little-endian BigInt64Array.
|
|
188
189
|
export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
|
|
189
190
|
const shiftTables = new Map<number, Int32Array>();
|
|
190
191
|
const indices = new Map<Value, number>();
|
|
191
192
|
const contributions: number[] = [];
|
|
192
|
-
const getContribution = (value: Value) => {
|
|
193
|
-
const cached = indices.get(value);
|
|
194
|
-
if (cached !== undefined) return cached;
|
|
195
|
-
const length = getFingerprintLength(value);
|
|
196
|
-
high = 0;
|
|
197
|
-
low = 0;
|
|
198
|
-
extendValue(value);
|
|
199
|
-
indices.set(value, contributions.length);
|
|
200
|
-
contributions.push(length, high, low);
|
|
201
|
-
return contributions.length - 3;
|
|
202
|
-
};
|
|
203
193
|
const getShiftTable = (length: number) => {
|
|
204
194
|
const cached = shiftTables.get(length);
|
|
205
195
|
if (cached) return cached;
|
|
@@ -207,29 +197,62 @@ export const createTlcFingerprinter = (order: number[], words: Int32Array) => {
|
|
|
207
197
|
shiftTables.set(length, table);
|
|
208
198
|
return table;
|
|
209
199
|
};
|
|
210
|
-
|
|
200
|
+
// Extends the fingerprint by a value's bytes and returns how many there are.
|
|
201
|
+
const extendElement = (value: Value): number => {
|
|
202
|
+
if (typeof value !== "object" || isModelValue(value)) {
|
|
203
|
+
extendValue(value);
|
|
204
|
+
return getFingerprintLength(value);
|
|
205
|
+
}
|
|
206
|
+
const contribution = getContribution(value);
|
|
207
|
+
const shifted = { high, low };
|
|
208
|
+
const table = getShiftTable(contributions[contribution]);
|
|
209
|
+
high = contributions[contribution + 1];
|
|
210
|
+
low = contributions[contribution + 2];
|
|
211
|
+
for (let position = 0; position < 8; position++) {
|
|
212
|
+
const word = position < 4 ? shifted.low : shifted.high;
|
|
213
|
+
const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
|
|
214
|
+
high ^= table[entry];
|
|
215
|
+
low ^= table[entry + 1];
|
|
216
|
+
}
|
|
217
|
+
return contributions[contribution];
|
|
218
|
+
};
|
|
219
|
+
const getContribution = (value: Value) => {
|
|
220
|
+
const cached = indices.get(value);
|
|
221
|
+
if (cached !== undefined) return cached;
|
|
211
222
|
const outer = { high, low };
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
const
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
const entry = (position * 256 + ((word >>> ((position & 3) * 8)) & 0xff)) * 2;
|
|
223
|
-
extended.high ^= table[entry];
|
|
224
|
-
extended.low ^= table[entry + 1];
|
|
223
|
+
high = 0;
|
|
224
|
+
low = 0;
|
|
225
|
+
const length = { value: 5 };
|
|
226
|
+
if (isFunctionValue(value)) {
|
|
227
|
+
const functionValue = toFiniteFunction(value);
|
|
228
|
+
extendByte(FCN_RCD_VALUE);
|
|
229
|
+
extendInt(functionValue.domain.length);
|
|
230
|
+
for (let index = 0; index < functionValue.domain.length; index++) {
|
|
231
|
+
length.value += extendElement(functionValue.domain[index]);
|
|
232
|
+
length.value += extendElement(functionValue.range[index]);
|
|
225
233
|
}
|
|
226
|
-
|
|
227
|
-
|
|
234
|
+
} else {
|
|
235
|
+
const elements = toFiniteSet(value).elements;
|
|
236
|
+
extendByte(SET_ENUM_VALUE);
|
|
237
|
+
extendInt(elements.length);
|
|
238
|
+
for (const element of elements) length.value += extendElement(element);
|
|
228
239
|
}
|
|
240
|
+
const contribution = contributions.length;
|
|
241
|
+
indices.set(value, contribution);
|
|
242
|
+
contributions.push(length.value, high, low);
|
|
243
|
+
high = outer.high;
|
|
244
|
+
low = outer.low;
|
|
245
|
+
return contribution;
|
|
246
|
+
};
|
|
247
|
+
return (state: Value[], position: number) => {
|
|
248
|
+
const outer = { high, low };
|
|
249
|
+
high = INITIAL_HIGH;
|
|
250
|
+
low = INITIAL_LOW;
|
|
251
|
+
for (const index of order) extendElement(state[index]);
|
|
252
|
+
words[2 * position] = low;
|
|
253
|
+
words[2 * position + 1] = high;
|
|
229
254
|
high = outer.high;
|
|
230
255
|
low = outer.low;
|
|
231
|
-
words[2 * position] = fingerprint.low;
|
|
232
|
-
words[2 * position + 1] = fingerprint.high;
|
|
233
256
|
};
|
|
234
257
|
};
|
|
235
258
|
|
package/src/tlc-version.ts
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
import { existsSync, readFileSync } from "node:fs";
|
|
2
|
-
import { strFromU8, unzipSync } from "fflate";
|
|
3
2
|
|
|
4
3
|
// The TLC whose output tla-ts reproduces: the 1.7.4 release, or the master builds that tla-ts
|
|
5
4
|
// follows for any other tla2tools.jar.
|
|
@@ -7,12 +6,14 @@ export type TlcVersion = "1.7.4" | "master";
|
|
|
7
6
|
|
|
8
7
|
const MANIFEST = "META-INF/MANIFEST.MF";
|
|
9
8
|
|
|
10
|
-
// The version of a tla2tools.jar, from the Git tag that its manifest records.
|
|
11
|
-
|
|
9
|
+
// The version of a tla2tools.jar, from the Git tag that its manifest records. fflate loads
|
|
10
|
+
// node:worker_threads, so only a run with a jar imports it.
|
|
11
|
+
export const getTlcVersion = async (jar: string | undefined): Promise<TlcVersion> => {
|
|
12
12
|
if (jar === undefined || !existsSync(jar)) return "master";
|
|
13
|
-
const
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
13
|
+
const fflate = await import("fflate");
|
|
14
|
+
const manifest = fflate.unzipSync(readFileSync(jar), {
|
|
15
|
+
filter: (file) => file.name === MANIFEST,
|
|
16
|
+
})[MANIFEST];
|
|
17
|
+
const tag = manifest && /^X-Git-Tag: *(\S*)/m.exec(fflate.strFromU8(manifest))?.[1];
|
|
17
18
|
return tag === "v1.7.4" ? "1.7.4" : "master";
|
|
18
19
|
};
|
package/src/values.ts
CHANGED
|
@@ -234,7 +234,13 @@ const compareFunctions = (left: FunctionValue, right: FunctionValue) => {
|
|
|
234
234
|
const rightRange = right.range;
|
|
235
235
|
if (leftRange === rightRange) return 0;
|
|
236
236
|
for (let index = 0; index < leftRange.length; index++) {
|
|
237
|
-
const
|
|
237
|
+
const leftValue = leftRange[index];
|
|
238
|
+
const rightValue = rightRange[index];
|
|
239
|
+
// V8 can't inline the recursive compareValues here, so two numbers skip the call.
|
|
240
|
+
const valueComparison =
|
|
241
|
+
typeof leftValue === "number" && typeof rightValue === "number"
|
|
242
|
+
? leftValue - rightValue
|
|
243
|
+
: compareValues(leftValue, rightValue);
|
|
238
244
|
if (valueComparison !== 0) return valueComparison;
|
|
239
245
|
}
|
|
240
246
|
return 0;
|
|
@@ -619,9 +625,14 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
|
619
625
|
// TLC prints and words errors about an equal function by its Java class, so a value can stand for
|
|
620
626
|
// another in a state only if each function in it has the same class.
|
|
621
627
|
const createSameValueCheck = (isClassSensitive: boolean) => {
|
|
622
|
-
const areSameValues = (left: Value[], right: Value[]) =>
|
|
623
|
-
left === right
|
|
624
|
-
(left.length
|
|
628
|
+
const areSameValues = (left: Value[], right: Value[]) => {
|
|
629
|
+
if (left === right) return true;
|
|
630
|
+
if (left.length !== right.length) return false;
|
|
631
|
+
for (let index = 0; index < left.length; index++) {
|
|
632
|
+
if (!isSame(left[index], right[index])) return false;
|
|
633
|
+
}
|
|
634
|
+
return true;
|
|
635
|
+
};
|
|
625
636
|
const isSame = (left: Value, right: Value): boolean => {
|
|
626
637
|
if (left === right) return true;
|
|
627
638
|
if (typeof left !== "object" || typeof right !== "object") return false;
|
|
@@ -1025,10 +1036,7 @@ export const markNormalized = (value: Value): void => {
|
|
|
1025
1036
|
};
|
|
1026
1037
|
|
|
1027
1038
|
export const isEqualLikeTlc = (left: Value, right: Value) =>
|
|
1028
|
-
computeLikeTlcOnFailure(
|
|
1029
|
-
() => valuesEqual(left, right),
|
|
1030
|
-
() => equalsLikeTlc(left, right),
|
|
1031
|
-
);
|
|
1039
|
+
computeLikeTlcOnFailure(valuesEqual, equalsLikeTlc, left, right);
|
|
1032
1040
|
|
|
1033
1041
|
const isStrictlySorted = (elements: Value[]) => {
|
|
1034
1042
|
for (let index = 1; index < elements.length; index++) {
|
|
@@ -1052,9 +1060,11 @@ export const createSet = (elements: Value[]): SetValue => {
|
|
|
1052
1060
|
// TLC builds a set enumeration without sorting it, so one whose elements it can't compare still
|
|
1053
1061
|
// evaluates.
|
|
1054
1062
|
export const createEnumeratedSet = (elements: Value[]): SetValue | MixedSetValue =>
|
|
1055
|
-
computeLikeTlcOnFailure<SetValue | MixedSetValue>(
|
|
1056
|
-
|
|
1057
|
-
() => ({ kind: "MixedSet", elements }),
|
|
1063
|
+
computeLikeTlcOnFailure<Value[], undefined, SetValue | MixedSetValue>(
|
|
1064
|
+
createSet,
|
|
1065
|
+
(mixed) => ({ kind: "MixedSet", elements: mixed }),
|
|
1066
|
+
elements,
|
|
1067
|
+
undefined,
|
|
1058
1068
|
);
|
|
1059
1069
|
|
|
1060
1070
|
export const EMPTY_SET = createSortedSet([]);
|
|
@@ -1596,6 +1606,38 @@ const getCombinedSets = (value: ObjectValue) =>
|
|
|
1596
1606
|
? [value.range]
|
|
1597
1607
|
: undefined;
|
|
1598
1608
|
|
|
1609
|
+
// Whether a value TLC builds alike at each evaluation and that enumerating, comparing or
|
|
1610
|
+
// fingerprinting it leaves alike, so that one evaluation can stand for the next. It holds no UNION or
|
|
1611
|
+
// \cup, which streams until TLC caches it, no lambda, which fingerprinting turns into a record, and
|
|
1612
|
+
// no record a comparison reorders.
|
|
1613
|
+
export const isSettledValue = (value: Value): boolean => {
|
|
1614
|
+
if (typeof value !== "object") return true;
|
|
1615
|
+
switch (value.kind) {
|
|
1616
|
+
case "ModelValue":
|
|
1617
|
+
case "Interval":
|
|
1618
|
+
return true;
|
|
1619
|
+
case "Set":
|
|
1620
|
+
return value.elements.every(isSettledValue);
|
|
1621
|
+
case "Function":
|
|
1622
|
+
return (
|
|
1623
|
+
value.functionClass !== "lambda" &&
|
|
1624
|
+
value.writtenKeys === undefined &&
|
|
1625
|
+
value.domain.every(isSettledValue) &&
|
|
1626
|
+
value.range.every(isSettledValue)
|
|
1627
|
+
);
|
|
1628
|
+
case "SetOperation":
|
|
1629
|
+
return (
|
|
1630
|
+
value.operator !== "\\cup" && isSettledValue(value.left) && isSettledValue(value.right)
|
|
1631
|
+
);
|
|
1632
|
+
case "FilteredSet":
|
|
1633
|
+
return isSettledValue(value.base);
|
|
1634
|
+
case "ProductSet":
|
|
1635
|
+
return value.factors.every(isSettledValue);
|
|
1636
|
+
default:
|
|
1637
|
+
return false;
|
|
1638
|
+
}
|
|
1639
|
+
};
|
|
1640
|
+
|
|
1599
1641
|
// Whether a set streams its elements in another order than the normalized set, so that a set of
|
|
1600
1642
|
// tuples, records, or functions it is a component of has to stream too.
|
|
1601
1643
|
const isStreamedApart = (value: Value): boolean => {
|
|
@@ -1870,17 +1912,20 @@ export const setTrace: { sets: Value[] | undefined; callStack?: TracedCallStack
|
|
|
1870
1912
|
};
|
|
1871
1913
|
|
|
1872
1914
|
// Takes a fast path, and computes as TLC does where it fails. TLC never takes the fast path, so
|
|
1873
|
-
// the failure's leftovers in the replay's trace go first.
|
|
1874
|
-
|
|
1875
|
-
|
|
1876
|
-
|
|
1915
|
+
// the failure's leftovers in the replay's trace go first. Both paths take their operands as
|
|
1916
|
+
// arguments, so a hot caller passes functions it doesn't allocate.
|
|
1917
|
+
export const computeLikeTlcOnFailure = <Left, Right, Result>(
|
|
1918
|
+
compute: (left: Left, right: Right) => Result,
|
|
1919
|
+
computeLikeTlc: (left: Left, right: Right, error: TlaEvaluationError) => Result,
|
|
1920
|
+
left: Left,
|
|
1921
|
+
right: Right,
|
|
1877
1922
|
): Result => {
|
|
1878
1923
|
const sets = setTrace.sets;
|
|
1879
1924
|
const callStack = setTrace.callStack;
|
|
1880
1925
|
const depth = sets?.length ?? 0;
|
|
1881
1926
|
const trace = callStack && { ...callStack, length: callStack.expressions.length };
|
|
1882
1927
|
try {
|
|
1883
|
-
return compute();
|
|
1928
|
+
return compute(left, right);
|
|
1884
1929
|
} catch (error) {
|
|
1885
1930
|
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
1886
1931
|
if (sets) sets.length = depth;
|
|
@@ -1889,7 +1934,7 @@ export const computeLikeTlcOnFailure = <Result>(
|
|
|
1889
1934
|
callStack.isFrozen = trace.isFrozen;
|
|
1890
1935
|
callStack.fingerprint = trace.fingerprint;
|
|
1891
1936
|
}
|
|
1892
|
-
return computeLikeTlc(error);
|
|
1937
|
+
return computeLikeTlc(left, right, error);
|
|
1893
1938
|
}
|
|
1894
1939
|
};
|
|
1895
1940
|
|
|
@@ -1902,19 +1947,20 @@ export const isElementOf = (element: Value, set: Value): boolean => {
|
|
|
1902
1947
|
return isElement;
|
|
1903
1948
|
};
|
|
1904
1949
|
|
|
1950
|
+
const isInSortedSet = (element: Value, set: SetValue) => findIndex(set.elements, element) !== -1;
|
|
1951
|
+
|
|
1952
|
+
const isInSortedSetLikeTlc = (element: Value, set: SetValue) =>
|
|
1953
|
+
normalizedSets.has(set)
|
|
1954
|
+
? searchLikeTlc(element, set.elements).isFound
|
|
1955
|
+
: isElementOfLikeTlc(element, set.elements);
|
|
1956
|
+
|
|
1905
1957
|
const isElementOfSet = (element: Value, set: Value): boolean => {
|
|
1906
1958
|
if (!isSetValue(set)) throw new TlaEvaluationError(describeNonSetMembership(element, set));
|
|
1907
1959
|
switch (set.kind) {
|
|
1908
1960
|
case "Set":
|
|
1909
1961
|
// SetEnumValue.member compares the element with the set's.
|
|
1910
1962
|
cacheSet(element);
|
|
1911
|
-
return computeLikeTlcOnFailure(
|
|
1912
|
-
() => findIndex(set.elements, element) !== -1,
|
|
1913
|
-
() =>
|
|
1914
|
-
normalizedSets.has(set)
|
|
1915
|
-
? searchLikeTlc(element, set.elements).isFound
|
|
1916
|
-
: isElementOfLikeTlc(element, set.elements),
|
|
1917
|
-
);
|
|
1963
|
+
return computeLikeTlcOnFailure(isInSortedSet, isInSortedSetLikeTlc, element, set);
|
|
1918
1964
|
case "MixedSet":
|
|
1919
1965
|
return isElementOfLikeTlc(element, set.elements);
|
|
1920
1966
|
case "Interval":
|
|
@@ -2126,6 +2172,15 @@ export const createNonIntegerKeyError = (argument: Value) =>
|
|
|
2126
2172
|
// binary search with compareTo.
|
|
2127
2173
|
const LINEAR_SEARCH_LIMIT = 32;
|
|
2128
2174
|
|
|
2175
|
+
const failKeyLikeTlc = (domain: Value[], argument: Value, error: TlaEvaluationError): never => {
|
|
2176
|
+
if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
|
|
2177
|
+
domain.forEach((key) => equalsLikeTlc(key, argument));
|
|
2178
|
+
} else {
|
|
2179
|
+
findIndex(domain, argument, compareLikeTlc);
|
|
2180
|
+
}
|
|
2181
|
+
throw error;
|
|
2182
|
+
};
|
|
2183
|
+
|
|
2129
2184
|
// TLC looks a key up by the Java class of the function: a tuple or a record rejects a key of the
|
|
2130
2185
|
// wrong type, and another function rejects a non-integer for a domain it keeps as an interval, which
|
|
2131
2186
|
// TLC 1.7.4 doesn't. A key of another type than the domain's keys otherwise fails TLC's comparison.
|
|
@@ -2148,17 +2203,7 @@ const findKeyIndexLikeTlc = (
|
|
|
2148
2203
|
}
|
|
2149
2204
|
const identical = findIdenticalKey(domain, argument);
|
|
2150
2205
|
if (identical !== -1) return identical;
|
|
2151
|
-
return computeLikeTlcOnFailure(
|
|
2152
|
-
() => findIndex(domain, argument),
|
|
2153
|
-
(error) => {
|
|
2154
|
-
if (valueVersion.is174 || domain.length < LINEAR_SEARCH_LIMIT) {
|
|
2155
|
-
domain.forEach((key) => equalsLikeTlc(key, argument));
|
|
2156
|
-
} else {
|
|
2157
|
-
findIndex(domain, argument, compareLikeTlc);
|
|
2158
|
-
}
|
|
2159
|
-
throw error;
|
|
2160
|
-
},
|
|
2161
|
-
);
|
|
2206
|
+
return computeLikeTlcOnFailure(findIndex, failKeyLikeTlc, domain, argument);
|
|
2162
2207
|
};
|
|
2163
2208
|
|
|
2164
2209
|
export const applyFunction = (
|
package/src/worker.ts
ADDED
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
// Worker threads as Web Workers, or as Node's worker_threads where there are none.
|
|
2
|
+
|
|
3
|
+
const WORKER_THREADS_MODULE = "node:worker_threads";
|
|
4
|
+
|
|
5
|
+
export interface Port {
|
|
6
|
+
postMessage: (message: unknown, transfer?: unknown[]) => void;
|
|
7
|
+
addEventListener: (type: "message", listener: (event: { data: unknown }) => void) => void;
|
|
8
|
+
removeEventListener?: (type: "message", listener: (event: { data: unknown }) => void) => void;
|
|
9
|
+
start?: () => void;
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export interface WorkerHandle {
|
|
13
|
+
postMessage: (message: unknown, transfer?: unknown[]) => void;
|
|
14
|
+
terminate: () => void;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
interface WebWorker {
|
|
18
|
+
postMessage: (message: unknown, transfer?: unknown[]) => void;
|
|
19
|
+
addEventListener: (type: string, listener: (event: { data: unknown }) => void) => void;
|
|
20
|
+
terminate: () => void;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
declare const Worker: new (url: URL, options: { type: "module" }) => WebWorker;
|
|
24
|
+
|
|
25
|
+
// Whether this runtime runs workers: Web Workers, or Node's.
|
|
26
|
+
export const isWorkerSupported = () =>
|
|
27
|
+
typeof Worker === "function" ||
|
|
28
|
+
(typeof process !== "undefined" && process.versions?.node !== undefined);
|
|
29
|
+
|
|
30
|
+
// Starts the worker at url, which the caller writes as new URL("./name.js", import.meta.url) for
|
|
31
|
+
// bundlers to find. onError receives what the worker threw.
|
|
32
|
+
export const spawnWorker = async (
|
|
33
|
+
url: URL,
|
|
34
|
+
onMessage: (message: unknown) => void,
|
|
35
|
+
onError: (error: unknown) => void,
|
|
36
|
+
): Promise<WorkerHandle> => {
|
|
37
|
+
if (typeof Worker === "function") {
|
|
38
|
+
const worker = new Worker(url, { type: "module" });
|
|
39
|
+
worker.addEventListener("message", (event) => onMessage(event.data));
|
|
40
|
+
worker.addEventListener("error", onError);
|
|
41
|
+
return worker;
|
|
42
|
+
}
|
|
43
|
+
const threads: typeof import("node:worker_threads") = await import(
|
|
44
|
+
/* @vite-ignore */ /* webpackIgnore: true */ WORKER_THREADS_MODULE
|
|
45
|
+
);
|
|
46
|
+
const worker = new threads.Worker(url);
|
|
47
|
+
worker.on("message", onMessage);
|
|
48
|
+
worker.on("error", onError);
|
|
49
|
+
return {
|
|
50
|
+
postMessage: (message, transfer) =>
|
|
51
|
+
worker.postMessage(message, transfer as Parameters<typeof worker.postMessage>[1]),
|
|
52
|
+
terminate: () => void worker.terminate(),
|
|
53
|
+
};
|
|
54
|
+
};
|
|
55
|
+
|
|
56
|
+
// The port a worker receives its messages on and posts its own to.
|
|
57
|
+
export const getParentPort = async () => {
|
|
58
|
+
if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
|
|
59
|
+
return globalThis as unknown as Port;
|
|
60
|
+
}
|
|
61
|
+
const threads: typeof import("node:worker_threads") = await import(
|
|
62
|
+
/* @vite-ignore */ /* webpackIgnore: true */ WORKER_THREADS_MODULE
|
|
63
|
+
);
|
|
64
|
+
return threads.parentPort as unknown as Port;
|
|
65
|
+
};
|
package/dist/parallel.cjs
DELETED
|
@@ -1,12 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* @license tla-ts
|
|
3
|
-
*
|
|
4
|
-
* Copyright (c) Aiden Bai
|
|
5
|
-
*
|
|
6
|
-
* This source code is licensed under the MIT license found in the
|
|
7
|
-
* LICENSE file in the root directory of this source tree.
|
|
8
|
-
*/
|
|
9
|
-
const e=require("./transfer.cjs"),t=async e=>{if(typeof Worker==`function`){let t=new Worker(new URL(`./parallel-worker.js`,require("url").pathToFileURL(__filename).href),{type:`module`});return t.addEventListener(`message`,t=>e(t.data)),t.addEventListener(`error`,()=>e({type:`abort`})),t}let t=new(await(import(
|
|
10
|
-
/* @vite-ignore */
|
|
11
|
-
/* webpackIgnore: true */
|
|
12
|
-
`node:worker_threads`))).Worker(new URL(`./parallel-worker.js`,require("url").pathToFileURL(__filename).href));return t.on(`message`,e),t.on(`error`,()=>e({type:`abort`})),{postMessage:(e,n)=>t.postMessage(e,n),terminate:()=>void t.terminate()}},n=async n=>{let r=typeof n.config==`string`?e.Z(n.config,n.version):n.config,i=n.onPrint??console.log,a={count:0},o=e=>[e.kind,`name`in e?e.name:``,`count`in e?e.count:``,`text`in e?e.text:``].join(` `),s=/* @__PURE__ */ new Set,c=e=>{s.add(o(e)),n.onProgress?.(e)},l=()=>{let t={count:a.count};return e.l({...n,config:r,onPrint:e=>t.count-->0?void 0:i(e),onProgress:e=>{s.has(o(e))||n.onProgress?.(e)}})},u=n.workers??1;if(u<2||typeof SharedArrayBuffer!=`function`||n.dump!==void 0||r.view!==void 0||r.postconditions.length>0||r.possible.length>0)return l();let d=/* @__PURE__ */ new Map,f=e=>{let t=n.loadModule?.(e);return d.set(e,t),t},p=/* @__PURE__ */ new Map,m=e=>{let t=n.loadClass?.(e);return p.set(e,t),t};e.Y(e.x(n.source,r,f)),e.X(n.version);let h=e.J(),g=e.y(r,{source:n.source,loadModule:f,loadClass:m,print:e=>{a.count++,i(e)},files:{readFile:n.readFile,writeFile:n.writeFile},isTool:n.isTool,isTraceRecorded:n.isTraceRecorded,isSanyReported:n.isSanyReported,isWarningEnabled:n.isWarningEnabled,version:n.version});e.p(g,r,c);let _=g.environment,v=e.u(r,_,()=>e.S(n.source,f),c);if(e.d(g.assumptions,_)||!v||v.spec.init===void 0||v.spec.next===void 0||v.properties.liveness.length>0||e.N(_))return l();let y=e.G(),b={fingerprints:e.i()},x=/* @__PURE__ */ new Int32Array(2),S=Array.from({length:u},e.n),C={generatedStates:0,distinctStates:0,queuedStates:0,depth:0,initialStates:void 0,outDegrees:Array.from({length:32},()=>0)},w=[],T=()=>({status:`success`,violation:void 0,failure:void 0,...C,fingerprintDistance:e.g(C.distinctStates,C.generatedStates,()=>{let e=new BigInt64Array(C.distinctStates);return w.reduce((t,n)=>(e.set(n,t),t+n.length),0),e})}),E=t=>{let n=[];for(let r of e.P(t,_,v.spec.scope))if(e.f(C.generatedStates,c),y(r),C.generatedStates++,e.c(v.getFingerprintState(r),x),e.s(b.fingerprints)&&(b.fingerprints=e.a(b.fingerprints)),e.o(b.fingerprints,x[0],x[1])){if(v.findViolatedInvariant(r)||v.findFailedInitialPredicate(r))return!1;if(v.satisfiesConstraints(r)){if(!S[n.length%u].encode(r))return!1;n.push(r),C.distinctStates++}}return w.push(BigInt64Array.from(n,e=>_.runtime.getFingerprint(e))),!0};c({kind:`initial-states-started`});try{if(!E(v.spec.init))return l()}catch(t){if(!(t instanceof e.st))throw t;return l()}if(e.J()!==h)return l();if(C.depth=C.generatedStates===0?0:1,C.initialStates={generated:C.generatedStates,distinct:C.distinctStates},c({kind:`initial-states-computed`,initialStates:C.initialStates}),C.distinctStates===0)return T();let D=[],O={count:u,resolve:e=>{}},k=e=>{D.push(e),(e.type===`abort`||D.length===O.count)&&O.resolve(D.splice(0))},A=e=>new Promise(t=>{O.count=e,O.resolve=t}),j=A(u),M=new Int32Array(new SharedArrayBuffer(u*4)),N=new Int32Array(new SharedArrayBuffer(u*4)),P=await Promise.all(Array.from({length:u},()=>t(k))),F=()=>P.forEach(e=>e.terminate()),I=/* @__PURE__ */ new Map,L=(e,t)=>{let n=e<t?`${e}:${t}`:`${t}:${e}`,r=I.get(n)??new MessageChannel;return I.set(n,r),e<t?r.port1:r.port2};P.forEach((e,t)=>{let i=Array.from({length:u},(e,n)=>n===t?void 0:L(t,n)),a=S[t].finish(),o={type:`start`,source:n.source,config:r,modules:[...d],classes:[...p],index:t,ports:i,seed:a,isTool:n.isTool,isTraceRecorded:n.isTraceRecorded,isWarningEnabled:n.isWarningEnabled,version:n.version,fingerprints:b.fingerprints,requests:M,remaining:N};e.postMessage(o,[...i.filter(e=>e!==void 0),a.words.buffer])});let R=e=>e.some(e=>e.type===`abort`),z=e=>P.forEach(t=>t.postMessage(e)),B=async t=>{let n=t.filter(e=>e.type===`paused`).length;if(n===0||R(t))return t;b.fingerprints=e.a(b.fingerprints);let r=A(n);return z({type:`resize`,fingerprints:b.fingerprints}),[...t.filter(e=>e.type!==`paused`),...await B(await r)]};if(R(await j))return F(),l();for(let e=1;;e++){let t=A(u);M.forEach((e,t)=>Atomics.store(M,t,0)),z({type:`level`,level:e});let n=await B(await t);if(R(n))return F(),l();let r=n.flatMap(e=>e.type===`level`?[e]:[]),i=r.reduce((e,t)=>e+t.added,0);if(C.generatedStates+=r.reduce((e,t)=>e+t.generated,0),C.distinctStates+=i,r.forEach(e=>{e.outDegrees.forEach((e,t)=>C.outDegrees[t]+=e),w.push(e.fingerprints)}),i===0)return F(),T();C.depth++}};Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return n}});
|