tla-ts 0.0.4 → 0.0.5-dev.552d313
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 +38 -127
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +46 -12
- package/dist/index.d.ts +46 -12
- 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 +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +43 -22
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +361 -181
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +207 -141
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +21 -22
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +39 -23
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +166 -111
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
|
@@ -0,0 +1,321 @@
|
|
|
1
|
+
// tlapm's expansions of temporal operators (Expr.Tla_norm), constant detection (Expr.Constness), and
|
|
2
|
+
// the time of a fact (Expr.Temporal_props): a fact holds always when it is closed under [].
|
|
3
|
+
|
|
4
|
+
import {
|
|
5
|
+
adjoin,
|
|
6
|
+
adjoinAll,
|
|
7
|
+
applyBuiltin,
|
|
8
|
+
at,
|
|
9
|
+
getFresh,
|
|
10
|
+
getLocalDefn,
|
|
11
|
+
getScopeAt,
|
|
12
|
+
mapChildren,
|
|
13
|
+
type Builtin,
|
|
14
|
+
type Expr,
|
|
15
|
+
type Hyp,
|
|
16
|
+
type Scope,
|
|
17
|
+
type Time,
|
|
18
|
+
} from "./expression";
|
|
19
|
+
|
|
20
|
+
const isApplied = (expression: Expr, builtins: Builtin[]) =>
|
|
21
|
+
expression.kind === "Apply" &&
|
|
22
|
+
expression.operator.kind === "Internal" &&
|
|
23
|
+
builtins.includes(expression.operator.builtin);
|
|
24
|
+
|
|
25
|
+
const applyUnchanged = (expression: Expr) => applyBuiltin("UNCHANGED", [expression], expression);
|
|
26
|
+
|
|
27
|
+
const getEquality = (expression: Expr) =>
|
|
28
|
+
applyBuiltin("Eq", [applyBuiltin("Prime", [expression], expression), expression], expression);
|
|
29
|
+
|
|
30
|
+
// E_tla_norm.rewrite_unch: UNCHANGED <<x, <<y>>>> as x' = x /\ y' = y.
|
|
31
|
+
export const rewriteUnchanged = (expression: Expr): Expr => {
|
|
32
|
+
const flatten = (inner: Expr): Expr[] =>
|
|
33
|
+
inner.kind === "Tuple" ? inner.elements.flatMap(flatten) : [inner];
|
|
34
|
+
const items = flatten(expression);
|
|
35
|
+
if (items.length === 0) return at({ kind: "Internal", builtin: "TRUE" }, expression);
|
|
36
|
+
if (items.length === 1) return getEquality(items[0]);
|
|
37
|
+
return at({ kind: "List", bullet: "And", items: items.map(getEquality) }, expression);
|
|
38
|
+
};
|
|
39
|
+
|
|
40
|
+
// Each visitor rewrites the outermost match and leaves the rest of the tree as it is.
|
|
41
|
+
const rewrite =
|
|
42
|
+
(match: (expression: Expr, recurse: (inner: Expr) => Expr) => Expr | undefined) =>
|
|
43
|
+
(expression: Expr): Expr => {
|
|
44
|
+
const recurse = rewrite(match);
|
|
45
|
+
return match(expression, recurse) ?? mapChildren(expression, recurse);
|
|
46
|
+
};
|
|
47
|
+
|
|
48
|
+
export const expandLeadsto = rewrite((expression, recurse) =>
|
|
49
|
+
expression.kind === "Apply" && isApplied(expression, ["Leadsto"])
|
|
50
|
+
? applyBuiltin(
|
|
51
|
+
"BoxTrue",
|
|
52
|
+
[
|
|
53
|
+
applyBuiltin(
|
|
54
|
+
"Implies",
|
|
55
|
+
[
|
|
56
|
+
recurse(expression.args[0]),
|
|
57
|
+
applyBuiltin("Diamond", [recurse(expression.args[1])], expression),
|
|
58
|
+
],
|
|
59
|
+
expression,
|
|
60
|
+
),
|
|
61
|
+
],
|
|
62
|
+
expression,
|
|
63
|
+
)
|
|
64
|
+
: undefined,
|
|
65
|
+
);
|
|
66
|
+
|
|
67
|
+
export const expandFairness = rewrite((expression) => {
|
|
68
|
+
if (expression.kind !== "Fair") return undefined;
|
|
69
|
+
const action = expression.action;
|
|
70
|
+
const subscript = expression.subscript;
|
|
71
|
+
const enabled = applyBuiltin(
|
|
72
|
+
"ENABLED",
|
|
73
|
+
[at({ kind: "Sub", modal: "Dia", action, subscript }, action)],
|
|
74
|
+
action,
|
|
75
|
+
);
|
|
76
|
+
const outer = expression.fairness === "Weak" ? "Diamond" : "BoxTrue";
|
|
77
|
+
const inner = expression.fairness === "Weak" ? "BoxTrue" : "Diamond";
|
|
78
|
+
return applyBuiltin(
|
|
79
|
+
"Implies",
|
|
80
|
+
[
|
|
81
|
+
applyBuiltin(outer, [applyBuiltin(inner, [enabled], action)], action),
|
|
82
|
+
applyBuiltin(
|
|
83
|
+
"BoxTrue",
|
|
84
|
+
[at({ kind: "Tsub", modal: "Dia", action, subscript }, action)],
|
|
85
|
+
action,
|
|
86
|
+
),
|
|
87
|
+
],
|
|
88
|
+
action,
|
|
89
|
+
);
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
export const expandAction = rewrite((expression, recurse) => {
|
|
93
|
+
if (expression.kind !== "Sub" && expression.kind !== "Tsub") return undefined;
|
|
94
|
+
const action = recurse(expression.action);
|
|
95
|
+
const subscript = recurse(expression.subscript);
|
|
96
|
+
const step =
|
|
97
|
+
expression.modal === "Box"
|
|
98
|
+
? applyBuiltin("Disj", [action, applyUnchanged(subscript)], expression)
|
|
99
|
+
: applyBuiltin(
|
|
100
|
+
"Conj",
|
|
101
|
+
[action, applyBuiltin("Neg", [applyUnchanged(subscript)], expression)],
|
|
102
|
+
expression,
|
|
103
|
+
);
|
|
104
|
+
if (expression.kind === "Sub") return step;
|
|
105
|
+
return applyBuiltin(expression.modal === "Box" ? "BoxTrue" : "Diamond", [step], expression);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
// Only getTime uses this, so the locations rewriteUnchanged gives do not matter.
|
|
109
|
+
const expandUnchanged = rewrite((expression) =>
|
|
110
|
+
expression.kind === "Apply" && isApplied(expression, ["UNCHANGED"])
|
|
111
|
+
? rewriteUnchanged(expression.args[0])
|
|
112
|
+
: undefined,
|
|
113
|
+
);
|
|
114
|
+
|
|
115
|
+
const TEMPORAL_BUILTINS: Builtin[] = [
|
|
116
|
+
"Prime",
|
|
117
|
+
"StrongPrime",
|
|
118
|
+
"Leadsto",
|
|
119
|
+
"ENABLED",
|
|
120
|
+
"UNCHANGED",
|
|
121
|
+
"Cdot",
|
|
122
|
+
"Actplus",
|
|
123
|
+
"BoxTrue",
|
|
124
|
+
"BoxFalse",
|
|
125
|
+
"Diamond",
|
|
126
|
+
];
|
|
127
|
+
|
|
128
|
+
const constantBodies = new WeakMap<Expr, boolean>();
|
|
129
|
+
|
|
130
|
+
const isConstantHyp = (scope: Scope | undefined, hyp: Hyp) => {
|
|
131
|
+
switch (hyp.kind) {
|
|
132
|
+
case "Fresh":
|
|
133
|
+
return hyp.level === "Constant";
|
|
134
|
+
case "Defn":
|
|
135
|
+
return hyp.definition.kind === "Operator" && isConstant(scope, hyp.definition.body);
|
|
136
|
+
case "Fact":
|
|
137
|
+
return isConstant(scope, hyp.expression);
|
|
138
|
+
case "Flex":
|
|
139
|
+
return false;
|
|
140
|
+
}
|
|
141
|
+
};
|
|
142
|
+
|
|
143
|
+
const bindConstants = (scope: Scope | undefined, names: string[]) =>
|
|
144
|
+
adjoinAll(
|
|
145
|
+
scope,
|
|
146
|
+
names.map((name) => getFresh(name, "Constant")),
|
|
147
|
+
);
|
|
148
|
+
|
|
149
|
+
export const isConstant = (scope: Scope | undefined, expression: Expr): boolean => {
|
|
150
|
+
const recurse = (inner: Expr) => isConstant(scope, inner);
|
|
151
|
+
switch (expression.kind) {
|
|
152
|
+
case "Ix": {
|
|
153
|
+
const found = getScopeAt(scope, expression.index - 1);
|
|
154
|
+
const hyp = found?.hyp;
|
|
155
|
+
if (hyp?.kind === "Fresh") return hyp.level === "Constant";
|
|
156
|
+
if (hyp?.kind !== "Defn" || hyp.definition.kind !== "Operator" || hyp.isConstnessUnset)
|
|
157
|
+
return false;
|
|
158
|
+
const body = hyp.definition.body;
|
|
159
|
+
const cached = constantBodies.get(body);
|
|
160
|
+
if (cached !== undefined) return cached;
|
|
161
|
+
const result = isConstant(found?.rest, body);
|
|
162
|
+
constantBodies.set(body, result);
|
|
163
|
+
return result;
|
|
164
|
+
}
|
|
165
|
+
case "Opaque":
|
|
166
|
+
case "String":
|
|
167
|
+
case "Num":
|
|
168
|
+
case "At":
|
|
169
|
+
return true;
|
|
170
|
+
case "Internal":
|
|
171
|
+
return !TEMPORAL_BUILTINS.includes(expression.builtin);
|
|
172
|
+
case "Tquant":
|
|
173
|
+
case "Sub":
|
|
174
|
+
case "Tsub":
|
|
175
|
+
case "Fair":
|
|
176
|
+
return false;
|
|
177
|
+
case "Lambda":
|
|
178
|
+
return isConstant(
|
|
179
|
+
bindConstants(
|
|
180
|
+
scope,
|
|
181
|
+
expression.params.map((param) => param.name),
|
|
182
|
+
),
|
|
183
|
+
expression.body,
|
|
184
|
+
);
|
|
185
|
+
case "Sequent": {
|
|
186
|
+
const inner = expression.sequent.context.reduce<{
|
|
187
|
+
scope: Scope | undefined;
|
|
188
|
+
isGood: boolean;
|
|
189
|
+
}>(
|
|
190
|
+
(state, hyp) => ({
|
|
191
|
+
scope: adjoin(state.scope, hyp),
|
|
192
|
+
isGood: state.isGood && isConstantHyp(state.scope, hyp),
|
|
193
|
+
}),
|
|
194
|
+
{ scope, isGood: true },
|
|
195
|
+
);
|
|
196
|
+
return inner.isGood && isConstant(inner.scope, expression.sequent.active);
|
|
197
|
+
}
|
|
198
|
+
case "Bang":
|
|
199
|
+
case "With":
|
|
200
|
+
case "Dot":
|
|
201
|
+
case "Parens":
|
|
202
|
+
return recurse(expression.expression);
|
|
203
|
+
case "Apply":
|
|
204
|
+
return recurse(expression.operator) && expression.args.every(recurse);
|
|
205
|
+
case "Let": {
|
|
206
|
+
const inner = expression.definitions.reduce<{ scope: Scope | undefined; isGood: boolean }>(
|
|
207
|
+
(state, definition) => ({
|
|
208
|
+
scope: adjoin(state.scope, getLocalDefn(definition)),
|
|
209
|
+
isGood:
|
|
210
|
+
state.isGood &&
|
|
211
|
+
definition.kind === "Operator" &&
|
|
212
|
+
isConstant(state.scope, definition.body),
|
|
213
|
+
}),
|
|
214
|
+
{ scope, isGood: true },
|
|
215
|
+
);
|
|
216
|
+
return inner.isGood && isConstant(inner.scope, expression.body);
|
|
217
|
+
}
|
|
218
|
+
case "Quant":
|
|
219
|
+
case "Fcn":
|
|
220
|
+
case "SetOf": {
|
|
221
|
+
const body = expression.kind === "SetOf" ? expression.element : expression.body;
|
|
222
|
+
return (
|
|
223
|
+
expression.bounds.every(
|
|
224
|
+
(bound) => bound.domain.kind !== "Domain" || recurse(bound.domain.expression),
|
|
225
|
+
) &&
|
|
226
|
+
isConstant(
|
|
227
|
+
bindConstants(
|
|
228
|
+
scope,
|
|
229
|
+
expression.bounds.map((bound) => bound.name),
|
|
230
|
+
),
|
|
231
|
+
body,
|
|
232
|
+
)
|
|
233
|
+
);
|
|
234
|
+
}
|
|
235
|
+
case "Choose":
|
|
236
|
+
case "SetSt":
|
|
237
|
+
return (
|
|
238
|
+
(expression.domain === undefined || recurse(expression.domain)) &&
|
|
239
|
+
isConstant(bindConstants(scope, [expression.name]), expression.body)
|
|
240
|
+
);
|
|
241
|
+
case "If":
|
|
242
|
+
return (
|
|
243
|
+
recurse(expression.condition) &&
|
|
244
|
+
recurse(expression.consequent) &&
|
|
245
|
+
recurse(expression.alternative)
|
|
246
|
+
);
|
|
247
|
+
case "List":
|
|
248
|
+
return expression.items.every(recurse);
|
|
249
|
+
case "Tuple":
|
|
250
|
+
case "SetEnum":
|
|
251
|
+
return expression.elements.every(recurse);
|
|
252
|
+
case "Product":
|
|
253
|
+
return expression.factors.every(recurse);
|
|
254
|
+
case "FcnApp":
|
|
255
|
+
return recurse(expression.function) && expression.args.every(recurse);
|
|
256
|
+
case "Rect":
|
|
257
|
+
case "Record":
|
|
258
|
+
return expression.fields.every((field) => recurse(field.value));
|
|
259
|
+
case "Arrow":
|
|
260
|
+
return recurse(expression.domain) && recurse(expression.range);
|
|
261
|
+
case "Except":
|
|
262
|
+
return (
|
|
263
|
+
recurse(expression.function) &&
|
|
264
|
+
expression.specs.every(
|
|
265
|
+
(spec) =>
|
|
266
|
+
spec.trail.every((point) => point.kind === "Dot" || recurse(point.expression)) &&
|
|
267
|
+
recurse(spec.value),
|
|
268
|
+
)
|
|
269
|
+
);
|
|
270
|
+
case "Case":
|
|
271
|
+
return (
|
|
272
|
+
expression.arms.every((arm) => recurse(arm.condition) && recurse(arm.body)) &&
|
|
273
|
+
(expression.other === undefined || recurse(expression.other))
|
|
274
|
+
);
|
|
275
|
+
}
|
|
276
|
+
};
|
|
277
|
+
|
|
278
|
+
// Temporal_props.box_closure: whether the formula is equivalent to [] of itself, judged by its
|
|
279
|
+
// shape. Under a negation or on the left of =>, <> takes the place of [].
|
|
280
|
+
const isClosed = (scope: Scope | undefined, expression: Expr, isBox: boolean): boolean => {
|
|
281
|
+
if (isConstant(scope, expression)) return true;
|
|
282
|
+
if (expression.kind === "Internal")
|
|
283
|
+
return ["Eq", "Neq", "UNCHANGED", "TRUE", "FALSE"].includes(expression.builtin);
|
|
284
|
+
if (expression.kind === "List")
|
|
285
|
+
return expression.items.every((item) => isClosed(scope, item, isBox));
|
|
286
|
+
if (expression.kind === "Sequent") {
|
|
287
|
+
return isClosed(adjoinAll(scope, expression.sequent.context), expression.sequent.active, isBox);
|
|
288
|
+
}
|
|
289
|
+
if (expression.kind !== "Apply") return false;
|
|
290
|
+
const args = expression.args;
|
|
291
|
+
if (isApplied(expression, ["BoxTrue", "BoxFalse"]) && isBox) return true;
|
|
292
|
+
if (isApplied(expression, ["Diamond"]) && !isBox) return true;
|
|
293
|
+
if (args.length === 1 && isApplied(expression, ["BoxTrue", "BoxFalse", "Diamond", "Prime"]))
|
|
294
|
+
return isClosed(scope, args[0], isBox);
|
|
295
|
+
if (args.length === 1 && isApplied(expression, ["Neg"])) return isClosed(scope, args[0], !isBox);
|
|
296
|
+
if (args.length === 2 && isApplied(expression, ["Conj", "Disj"]))
|
|
297
|
+
return isClosed(scope, args[0], isBox) && isClosed(scope, args[1], isBox);
|
|
298
|
+
if (args.length === 2 && isApplied(expression, ["Implies"]))
|
|
299
|
+
return isClosed(scope, args[0], !isBox) && isClosed(scope, args[1], isBox);
|
|
300
|
+
if (args.length === 2 && isApplied(expression, ["Equiv"]))
|
|
301
|
+
return [true, false].every(
|
|
302
|
+
(isFlipped) =>
|
|
303
|
+
isClosed(scope, args[0], isBox !== isFlipped) &&
|
|
304
|
+
isClosed(scope, args[1], isBox === isFlipped),
|
|
305
|
+
);
|
|
306
|
+
return (
|
|
307
|
+
isClosed(scope, expression.operator, isBox) && args.every((arg) => isClosed(scope, arg, isBox))
|
|
308
|
+
);
|
|
309
|
+
};
|
|
310
|
+
|
|
311
|
+
export const getTime = (scope: Scope | undefined, expression: Expr): Time =>
|
|
312
|
+
isClosed(scope, expandLeadsto(expandFairness(expandAction(expandUnchanged(expression)))), true)
|
|
313
|
+
? "Always"
|
|
314
|
+
: "Now";
|
|
315
|
+
|
|
316
|
+
// Temporal_props.check_time_change: a proof stays in the always scope while no fact it assumes
|
|
317
|
+
// holds only now.
|
|
318
|
+
export const getScopeTime = (context: Hyp[], time: Time): Time =>
|
|
319
|
+
time === "Always" && context.some((hyp) => hyp.kind === "Fact" && hyp.time === "Now")
|
|
320
|
+
? "Now"
|
|
321
|
+
: time;
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
// tlapm's E_tuply_declarations: declarations such as <<x, y>> \in S become declarations of names.
|
|
2
2
|
|
|
3
|
-
import type { Bound, BoundDomain, Defn, Expr } from "./
|
|
3
|
+
import type { Bound, BoundDomain, Defn, Expr } from "./expression";
|
|
4
4
|
|
|
5
5
|
export type TuplyBound =
|
|
6
6
|
| { kind: "Name"; name: string; domain: BoundDomain }
|
|
@@ -63,74 +63,58 @@ export const expandQuant = (
|
|
|
63
63
|
else groups.push([bound]);
|
|
64
64
|
});
|
|
65
65
|
return groups.reduceRight((inner: Expr, group): Expr => {
|
|
66
|
+
const quantify = (quantified: Bound[], quantifiedBody = inner): Expr => ({
|
|
67
|
+
kind: "Quant",
|
|
68
|
+
quantifier,
|
|
69
|
+
bounds: quantified,
|
|
70
|
+
body: quantifiedBody,
|
|
71
|
+
location: inner.location,
|
|
72
|
+
});
|
|
66
73
|
const first = group[0];
|
|
67
74
|
if (first.kind === "Name") {
|
|
68
|
-
return
|
|
69
|
-
kind
|
|
70
|
-
|
|
71
|
-
bounds: group.flatMap((bound) => (bound.kind === "Name" ? [getNamedBound(bound)] : [])),
|
|
72
|
-
body: inner,
|
|
73
|
-
location: inner.location,
|
|
74
|
-
};
|
|
75
|
+
return quantify(
|
|
76
|
+
group.flatMap((bound) => (bound.kind === "Name" ? [getNamedBound(bound)] : [])),
|
|
77
|
+
);
|
|
75
78
|
}
|
|
76
79
|
const factors = getFactors(first.domain, first.names);
|
|
77
|
-
if (factors)
|
|
78
|
-
return {
|
|
79
|
-
kind: "Quant",
|
|
80
|
-
quantifier,
|
|
81
|
-
bounds: getFactorBounds(first.names, factors),
|
|
82
|
-
body: inner,
|
|
83
|
-
location: inner.location,
|
|
84
|
-
};
|
|
85
|
-
}
|
|
80
|
+
if (factors) return quantify(getFactorBounds(first.names, factors));
|
|
86
81
|
const membership: Expr = {
|
|
87
82
|
kind: "Apply",
|
|
88
83
|
operator: { kind: "Internal", builtin: quantifier === "Exists" ? "Mem" : "Notmem" },
|
|
89
84
|
args: [getNamesTuple(first.names), first.domain],
|
|
90
85
|
};
|
|
91
|
-
return {
|
|
92
|
-
kind: "
|
|
93
|
-
quantifier,
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
kind: "List",
|
|
97
|
-
bullet: quantifier === "Exists" ? "And" : "Or",
|
|
98
|
-
items: [membership, inner],
|
|
99
|
-
},
|
|
100
|
-
location: inner.location,
|
|
101
|
-
};
|
|
86
|
+
return quantify(getUnbounded(first.names), {
|
|
87
|
+
kind: "List",
|
|
88
|
+
bullet: quantifier === "Exists" ? "And" : "Or",
|
|
89
|
+
items: [membership, inner],
|
|
90
|
+
});
|
|
102
91
|
}, body);
|
|
103
92
|
};
|
|
104
93
|
|
|
105
94
|
// CHOOSE <<x, y>> \in A \X B: P binds t \in A \X B with x == t[1], y == t[2], and any other
|
|
106
|
-
// domain binds t with \E x, y: t = <<x, y>> /\ P.
|
|
107
|
-
const
|
|
108
|
-
|
|
95
|
+
// domain binds t with \E x, y: t = <<x, y>> /\ P. {<<x, y>> \in S: P} binds t the same way.
|
|
96
|
+
export const expandChoose = (
|
|
97
|
+
binder: { kind: "Choose"; domain: Expr | undefined } | { kind: "SetSt"; domain: Expr },
|
|
109
98
|
names: string[],
|
|
110
|
-
domain: Expr | undefined,
|
|
111
99
|
body: Expr,
|
|
112
|
-
): Expr =>
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
kind: "
|
|
121
|
-
|
|
122
|
-
|
|
100
|
+
): Expr => {
|
|
101
|
+
const name = `${binder.kind.toLowerCase()}#${names[0]}`;
|
|
102
|
+
return {
|
|
103
|
+
...binder,
|
|
104
|
+
name,
|
|
105
|
+
body: getFactors(binder.domain, names)
|
|
106
|
+
? { kind: "Let", definitions: getItemDefinitions(name, names), body }
|
|
107
|
+
: {
|
|
108
|
+
kind: "Quant",
|
|
109
|
+
quantifier: "Exists",
|
|
110
|
+
bounds: getUnbounded(names),
|
|
111
|
+
body: {
|
|
112
|
+
kind: "List",
|
|
113
|
+
bullet: "And",
|
|
114
|
+
items: [getEquality(getOpaque(name), getNamesTuple(names)), body],
|
|
115
|
+
},
|
|
123
116
|
},
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
export const expandChoose = (names: string[], domain: Expr | undefined, body: Expr): Expr => {
|
|
127
|
-
const name = `choose#${names[0]}`;
|
|
128
|
-
return { kind: "Choose", name, domain, body: getChooseBody(name, names, domain, body) };
|
|
129
|
-
};
|
|
130
|
-
|
|
131
|
-
export const expandSetSt = (names: string[], domain: Expr, body: Expr): Expr => {
|
|
132
|
-
const name = `setst#${names[0]}`;
|
|
133
|
-
return { kind: "SetSt", name, domain, body: getChooseBody(name, names, domain, body) };
|
|
117
|
+
};
|
|
134
118
|
};
|
|
135
119
|
|
|
136
120
|
// A set or function constructor binds each tuple as fcn#x, with its names defined in a LET around
|
|
@@ -157,8 +141,8 @@ const expandConstructorBounds = (bounds: TuplyBound[], value: Expr, isSetOf: boo
|
|
|
157
141
|
kind: "Operator",
|
|
158
142
|
name: choice,
|
|
159
143
|
body: expandChoose(
|
|
144
|
+
{ kind: "Choose", domain: undefined },
|
|
160
145
|
bound.names,
|
|
161
|
-
undefined,
|
|
162
146
|
getEquality(getOpaque(name), getNamesTuple(bound.names)),
|
|
163
147
|
),
|
|
164
148
|
},
|
package/src/parallel-worker.ts
CHANGED
|
@@ -1,5 +1,3 @@
|
|
|
1
|
-
import { createCanonicalizer } from "./canonical";
|
|
2
|
-
import { createSearch } from "./check";
|
|
3
1
|
import { createEnvironment } from "./environment";
|
|
4
2
|
import {
|
|
5
3
|
createFingerprintTable,
|
|
@@ -7,20 +5,21 @@ import {
|
|
|
7
5
|
isSharedFingerprintsFull,
|
|
8
6
|
writeStateFingerprint,
|
|
9
7
|
} from "./fingerprints";
|
|
10
|
-
import type {
|
|
11
|
-
|
|
12
|
-
LevelMessage,
|
|
13
|
-
Port,
|
|
14
|
-
StartMessage,
|
|
15
|
-
WorkerMessage,
|
|
16
|
-
} from "./parallel";
|
|
8
|
+
import type { CoordinatorMessage, LevelMessage, StartMessage, WorkerMessage } from "./parallel";
|
|
9
|
+
import { createSearch } from "./search";
|
|
17
10
|
import { getSuccessors, type Successor } from "./successors";
|
|
18
|
-
import { getTlcStringOrder,
|
|
19
|
-
import { OUT_DEGREE_BUCKETS } from "./tlc
|
|
11
|
+
import { getTlcStringOrder, getTlcVariableOrder } from "./tlc/order";
|
|
12
|
+
import { OUT_DEGREE_BUCKETS } from "./tlc/summary";
|
|
20
13
|
import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
|
|
21
|
-
import {
|
|
14
|
+
import {
|
|
15
|
+
createCanonicalizer,
|
|
16
|
+
getRankedStringCount,
|
|
17
|
+
setStringOrder,
|
|
18
|
+
setValueVersion,
|
|
19
|
+
type Value,
|
|
20
|
+
} from "./values";
|
|
21
|
+
import { getParentPort, type Port } from "./worker";
|
|
22
22
|
|
|
23
|
-
const WORKER_THREADS_MODULE = "node:worker_threads";
|
|
24
23
|
const LOCKED = -1;
|
|
25
24
|
|
|
26
25
|
interface Expansion {
|
|
@@ -36,17 +35,7 @@ interface Expansion {
|
|
|
36
35
|
fingerprintStates: Value[][];
|
|
37
36
|
}
|
|
38
37
|
|
|
39
|
-
const
|
|
40
|
-
if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
|
|
41
|
-
return globalThis as unknown as Port;
|
|
42
|
-
}
|
|
43
|
-
const threads: typeof import("node:worker_threads") = await import(
|
|
44
|
-
/* @vite-ignore */ /* webpackIgnore: true */ WORKER_THREADS_MODULE
|
|
45
|
-
);
|
|
46
|
-
return threads.parentPort as unknown as Port;
|
|
47
|
-
};
|
|
48
|
-
|
|
49
|
-
const run = (start: StartMessage, parent: Port) => {
|
|
38
|
+
const runWorker = (start: StartMessage, parent: Port) => {
|
|
50
39
|
const modules = new Map(start.modules);
|
|
51
40
|
const loadModule = (name: string) => modules.get(name);
|
|
52
41
|
const classes = new Map(start.classes);
|
|
@@ -66,12 +55,12 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
66
55
|
});
|
|
67
56
|
const environment = specification.environment;
|
|
68
57
|
const search = createSearch(start.config, environment, () =>
|
|
69
|
-
|
|
58
|
+
getTlcVariableOrder(start.source, loadModule),
|
|
70
59
|
);
|
|
71
60
|
const nextAction = search?.spec.next;
|
|
72
61
|
if (!search || nextAction === undefined)
|
|
73
62
|
return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
|
|
74
|
-
const
|
|
63
|
+
const workerIndex = start.index;
|
|
75
64
|
const canonicalize = createCanonicalizer();
|
|
76
65
|
const decode = createStateDecoder(environment.variables.length);
|
|
77
66
|
const shared = { fingerprints: start.fingerprints };
|
|
@@ -91,8 +80,8 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
91
80
|
// A worker that runs out of states asks a peer for some by writing its index + 1 to the peer's
|
|
92
81
|
// request word. The peer sends half of the states it hasn't started, keeps expanding, and wakes
|
|
93
82
|
// the workers waiting to ask it next.
|
|
94
|
-
const
|
|
95
|
-
const thief = Atomics.load(requests,
|
|
83
|
+
const answerRequest = (expansion: Expansion, request: number) => {
|
|
84
|
+
const thief = Atomics.load(requests, workerIndex) - 1;
|
|
96
85
|
const given = Math.floor((expansion.end - expansion.origin - 1) / 2);
|
|
97
86
|
const encoder = createStateEncoder();
|
|
98
87
|
const states = expansion.states.slice(expansion.end - given, expansion.end);
|
|
@@ -100,21 +89,21 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
100
89
|
if (isEncoded) expansion.end -= given;
|
|
101
90
|
const loot = isEncoded ? encoder.finish() : createStateEncoder().finish();
|
|
102
91
|
start.ports[thief]?.postMessage(loot, [loot.words.buffer]);
|
|
103
|
-
Atomics.store(requests,
|
|
104
|
-
Atomics.notify(requests,
|
|
92
|
+
Atomics.store(requests, workerIndex, request);
|
|
93
|
+
Atomics.notify(requests, workerIndex);
|
|
105
94
|
};
|
|
106
95
|
|
|
107
96
|
// A worker answers any request before it pauses or runs out of states, and takes no more until
|
|
108
97
|
// it resumes.
|
|
109
|
-
const
|
|
110
|
-
Atomics.store(remaining,
|
|
111
|
-
if (Atomics.compareExchange(requests,
|
|
112
|
-
|
|
98
|
+
const lockRequests = (expansion: Expansion) => {
|
|
99
|
+
Atomics.store(remaining, workerIndex, 0);
|
|
100
|
+
if (Atomics.compareExchange(requests, workerIndex, 0, LOCKED) === 0) return;
|
|
101
|
+
answerRequest(expansion, LOCKED);
|
|
113
102
|
};
|
|
114
103
|
|
|
115
|
-
const
|
|
116
|
-
Atomics.store(remaining,
|
|
117
|
-
Atomics.store(requests,
|
|
104
|
+
const unlockRequests = (expansion: Expansion) => {
|
|
105
|
+
Atomics.store(remaining, workerIndex, expansion.end - expansion.origin);
|
|
106
|
+
Atomics.store(requests, workerIndex, 0);
|
|
118
107
|
};
|
|
119
108
|
|
|
120
109
|
// The worker pauses before a successor when the shared table needs to grow, and resumes there.
|
|
@@ -122,8 +111,8 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
122
111
|
for (; expansion.origin < expansion.end; expansion.origin++) {
|
|
123
112
|
const state = expansion.states[expansion.origin];
|
|
124
113
|
if (!expansion.successors) {
|
|
125
|
-
if (Atomics.load(requests,
|
|
126
|
-
Atomics.store(remaining,
|
|
114
|
+
if (Atomics.load(requests, workerIndex) > 0) answerRequest(expansion, 0);
|
|
115
|
+
Atomics.store(remaining, workerIndex, expansion.end - expansion.origin - 1);
|
|
127
116
|
expansion.successors = getSuccessors(nextAction, state, environment, search.spec.scope);
|
|
128
117
|
expansion.generated += expansion.successors.length;
|
|
129
118
|
if (expansion.successors.length === 0 && start.config.checkDeadlock) return undefined;
|
|
@@ -173,7 +162,7 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
173
162
|
: best;
|
|
174
163
|
}, undefined);
|
|
175
164
|
if (victim === undefined) return false;
|
|
176
|
-
const request = Atomics.compareExchange(requests, victim, 0,
|
|
165
|
+
const request = Atomics.compareExchange(requests, victim, 0, workerIndex + 1);
|
|
177
166
|
if (request === LOCKED) skipped.add(victim);
|
|
178
167
|
if (request > 0) Atomics.wait(requests, victim, request);
|
|
179
168
|
if (request !== 0) continue;
|
|
@@ -185,7 +174,7 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
185
174
|
expansion.states = decode(loot).map(canonicalize);
|
|
186
175
|
expansion.origin = 0;
|
|
187
176
|
expansion.end = expansion.states.length;
|
|
188
|
-
|
|
177
|
+
unlockRequests(expansion);
|
|
189
178
|
return true;
|
|
190
179
|
}
|
|
191
180
|
};
|
|
@@ -193,7 +182,7 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
193
182
|
const report = (message: WorkerMessage) =>
|
|
194
183
|
parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
|
|
195
184
|
|
|
196
|
-
const runLevel = async (
|
|
185
|
+
const runLevel = async (): Promise<LevelMessage | undefined> => {
|
|
197
186
|
const expansion: Expansion = {
|
|
198
187
|
states: frontier.states,
|
|
199
188
|
origin: 0,
|
|
@@ -209,22 +198,21 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
209
198
|
for (;;) {
|
|
210
199
|
const status = expand(expansion);
|
|
211
200
|
if (status === undefined) return undefined;
|
|
212
|
-
|
|
201
|
+
lockRequests(expansion);
|
|
213
202
|
if (status === "paused") {
|
|
214
203
|
const resumed = new Promise<void>((resolve) => (waiters.resume = resolve));
|
|
215
204
|
report({ type: "paused" });
|
|
216
205
|
await resumed;
|
|
217
|
-
|
|
206
|
+
unlockRequests(expansion);
|
|
218
207
|
continue;
|
|
219
208
|
}
|
|
220
209
|
if (!(await steal(expansion))) break;
|
|
221
210
|
}
|
|
222
211
|
if (getRankedStringCount() !== startupStrings) return undefined;
|
|
223
212
|
frontier.states = expansion.next;
|
|
224
|
-
Atomics.store(remaining,
|
|
213
|
+
Atomics.store(remaining, workerIndex, frontier.states.length);
|
|
225
214
|
return {
|
|
226
215
|
type: "level",
|
|
227
|
-
level,
|
|
228
216
|
generated: expansion.generated,
|
|
229
217
|
added: expansion.next.length,
|
|
230
218
|
outDegrees: expansion.outDegrees,
|
|
@@ -232,21 +220,21 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
232
220
|
};
|
|
233
221
|
};
|
|
234
222
|
|
|
235
|
-
const
|
|
236
|
-
runLevel(
|
|
223
|
+
const startLevel = () => {
|
|
224
|
+
runLevel().then(
|
|
237
225
|
(message) => report(message ?? { type: "abort" }),
|
|
238
226
|
() => report({ type: "abort" }),
|
|
239
227
|
);
|
|
240
228
|
};
|
|
241
229
|
parent.addEventListener("message", (event) => {
|
|
242
230
|
const message = event.data as CoordinatorMessage;
|
|
243
|
-
if (message.type === "level")
|
|
231
|
+
if (message.type === "level") startLevel();
|
|
244
232
|
if (message.type === "resize") {
|
|
245
233
|
shared.fingerprints = message.fingerprints;
|
|
246
234
|
waiters.resume();
|
|
247
235
|
}
|
|
248
236
|
});
|
|
249
|
-
Atomics.store(remaining,
|
|
237
|
+
Atomics.store(remaining, workerIndex, frontier.states.length);
|
|
250
238
|
report({ type: "ready" });
|
|
251
239
|
};
|
|
252
240
|
|
|
@@ -256,7 +244,7 @@ void getParentPort().then((parent) => {
|
|
|
256
244
|
if (message.type !== "start") return;
|
|
257
245
|
parent.removeEventListener?.("message", onStart);
|
|
258
246
|
try {
|
|
259
|
-
|
|
247
|
+
runWorker(message, parent);
|
|
260
248
|
} catch {
|
|
261
249
|
parent.postMessage({ type: "abort" } satisfies WorkerMessage);
|
|
262
250
|
}
|