tla-ts 0.0.3 → 0.0.4-dev.1a3acf6
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 +46 -115
- 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 +194 -8
- package/dist/index.d.ts +194 -8
- 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 +1377 -18
- package/dist/transfer.js +1377 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +26 -30
- package/src/builtins.ts +45 -19
- package/src/bundled-modules.ts +3 -3
- package/src/check.ts +1182 -900
- package/src/cli/options.ts +109 -0
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/cli/tlc.ts +941 -0
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +9 -2
- package/src/codegen.ts +112 -51
- package/src/config.ts +254 -181
- package/src/dependencies.ts +5 -7
- package/src/environment.ts +579 -184
- package/src/errors.ts +287 -4
- package/src/evaluate.ts +1095 -365
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +49 -14
- package/src/index.ts +11 -0
- package/src/instances.ts +73 -60
- package/src/java-overrides.ts +183 -66
- package/src/json.ts +31 -36
- package/src/levels.ts +197 -54
- package/src/lexer.ts +127 -30
- package/src/liveness-checker.ts +894 -0
- package/src/liveness.ts +246 -596
- 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} +174 -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 +184 -235
- package/src/parallel.ts +156 -91
- package/src/parser.ts +490 -188
- package/src/pcal/ast.ts +755 -0
- package/src/pcal/parse.ts +1487 -0
- package/src/pcal/tokenize.ts +487 -0
- package/src/pcal/translate.ts +1151 -0
- package/src/pcal/validate.ts +444 -0
- 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 +648 -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 +39 -27
- package/src/resolve.ts +1474 -426
- package/src/runtime.ts +25 -7
- package/src/sany/builtins.ts +147 -0
- package/src/sany/generator.ts +3111 -0
- package/src/sany/levels.ts +1205 -0
- package/src/sany/lexer.ts +544 -0
- package/src/sany/linter.ts +122 -0
- package/src/sany/modules.ts +1398 -0
- package/src/sany/nodes.ts +463 -0
- package/src/sany/parse-error.ts +2161 -0
- package/src/sany/report.ts +355 -0
- package/src/sany/selectors.ts +736 -0
- package/src/sany/source.ts +247 -0
- package/src/sany/xml.ts +1016 -0
- package/src/search.ts +969 -0
- package/src/spec-description.ts +66 -29
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +215 -164
- package/src/state-graph.ts +181 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +40 -19
- package/src/successors.ts +253 -125
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +60 -32
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
- package/src/tlc/messages.ts +441 -0
- package/src/{tlc-order.ts → tlc/order.ts} +84 -16
- package/src/{tlc-random.ts → tlc/random.ts} +30 -189
- package/src/tlc/replay.ts +659 -0
- package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
- package/src/tlc/version.ts +19 -0
- package/src/transfer.ts +44 -32
- package/src/values.ts +843 -241
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -28
- package/dist/run-cli.js +0 -28
- package/src/canonical.ts +0 -39
- package/src/cli-options.ts +0 -58
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/run-cli.ts +0 -478
package/src/liveness.ts
CHANGED
|
@@ -1,14 +1,21 @@
|
|
|
1
|
-
import type
|
|
2
|
-
import { TlaConfigError, TlaEvaluationError } from "./errors";
|
|
1
|
+
import { isLocallyResolved, type Bound, type Definition, type Expression } from "./ast";
|
|
3
2
|
import {
|
|
4
|
-
|
|
3
|
+
createStackOverflowError,
|
|
4
|
+
TlaEvaluationError,
|
|
5
|
+
TlaStackOverflowError,
|
|
6
|
+
UNEXPECTED_EVAL_EXCEPTION,
|
|
7
|
+
} from "./errors";
|
|
8
|
+
import {
|
|
9
|
+
describeNode,
|
|
10
|
+
describeRange,
|
|
5
11
|
bindDefinitions,
|
|
6
12
|
bindOperatorArguments,
|
|
7
13
|
evaluate,
|
|
8
14
|
expectBoolean,
|
|
9
15
|
forEachBinding,
|
|
16
|
+
forEachBoundElement,
|
|
17
|
+
getBoundElements,
|
|
10
18
|
getDefinition,
|
|
11
|
-
isLocallyResolved,
|
|
12
19
|
lookupScope,
|
|
13
20
|
resolveApplyOperator,
|
|
14
21
|
resolveGlobalOperator,
|
|
@@ -19,78 +26,44 @@ import {
|
|
|
19
26
|
type Thunk,
|
|
20
27
|
} from "./evaluate";
|
|
21
28
|
import { mapChildren } from "./instances";
|
|
22
|
-
import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
|
|
29
|
+
import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "./levels";
|
|
23
30
|
import { isEnabled } from "./successors";
|
|
31
|
+
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
32
|
+
import { isEvalException } from "./tlc/messages";
|
|
24
33
|
import {
|
|
25
34
|
createBoolean,
|
|
26
35
|
createJunction,
|
|
27
36
|
createPair,
|
|
28
37
|
createUnary,
|
|
29
38
|
getLiveLevel,
|
|
30
|
-
getSolutions,
|
|
31
|
-
isFulfilling,
|
|
32
39
|
type LiveEnabled,
|
|
33
40
|
type LiveExpression,
|
|
34
|
-
type Solution,
|
|
35
|
-
type Tableau,
|
|
36
41
|
} from "./tableau";
|
|
37
|
-
import {
|
|
42
|
+
import type { Value } from "./values";
|
|
38
43
|
|
|
39
44
|
export interface ScopedExpression {
|
|
40
45
|
expression: Expression;
|
|
41
46
|
scope: Scope | undefined;
|
|
42
47
|
}
|
|
43
48
|
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
export interface LiveSuccessor {
|
|
49
|
-
index: number;
|
|
50
|
-
state: Value[];
|
|
49
|
+
// A part of a temporal formula, with the name TLC gives the part when the formula is a property:
|
|
50
|
+
// a conjunct's location, or the name of the definition the part is the body of.
|
|
51
|
+
interface ExpandedExpression extends ScopedExpression {
|
|
52
|
+
name: string | undefined;
|
|
51
53
|
}
|
|
52
54
|
|
|
53
|
-
export interface
|
|
54
|
-
name: string;
|
|
55
|
-
prefix: number[];
|
|
56
|
-
cycle: number[];
|
|
57
|
-
}
|
|
58
|
-
|
|
59
|
-
interface SafetyViolation {
|
|
55
|
+
export interface TemporalProperty extends ScopedExpression {
|
|
60
56
|
name: string;
|
|
61
|
-
path: number[];
|
|
62
|
-
}
|
|
63
|
-
|
|
64
|
-
export interface LivenessChecker {
|
|
65
|
-
addInitialState: (index: number, state: Value[]) => void;
|
|
66
|
-
addState: (
|
|
67
|
-
index: number,
|
|
68
|
-
state: Value[],
|
|
69
|
-
successors: LiveSuccessor[],
|
|
70
|
-
) => SafetyViolation | undefined;
|
|
71
|
-
findViolation: () => Lasso | undefined;
|
|
72
|
-
}
|
|
73
|
-
|
|
74
|
-
interface Check {
|
|
75
|
-
solution: Solution;
|
|
76
|
-
stateResults: Uint8Array[];
|
|
77
|
-
actionResults: Uint8Array[];
|
|
78
|
-
consistency: Uint8Array[];
|
|
79
|
-
product: BehaviorGraph | undefined;
|
|
80
|
-
productNodes: Map<number, number>;
|
|
81
|
-
nodesByState: Map<number, number[]>;
|
|
82
|
-
}
|
|
83
|
-
|
|
84
|
-
interface BehaviorGraph {
|
|
85
|
-
states: number[];
|
|
86
|
-
tableauNodes: number[];
|
|
87
|
-
edges: number[][];
|
|
88
|
-
initial: number[];
|
|
89
|
-
parents: number[];
|
|
90
57
|
}
|
|
91
58
|
|
|
92
59
|
const MAXIMUM_EXPANSION_DEPTH = 100;
|
|
93
60
|
|
|
61
|
+
export const createTautologyError = () =>
|
|
62
|
+
setExitCode(
|
|
63
|
+
new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)."),
|
|
64
|
+
EXIT_STATUS.livenessEvaluationFailure,
|
|
65
|
+
);
|
|
66
|
+
|
|
94
67
|
const TEMPORAL_OPERATORS = new Set(["~>", "-+->"]);
|
|
95
68
|
|
|
96
69
|
const definitionLevels = new WeakMap<Definition, number>();
|
|
@@ -104,9 +77,10 @@ const getConstantContext = (environment: Environment, scope: Scope | undefined):
|
|
|
104
77
|
next: undefined,
|
|
105
78
|
});
|
|
106
79
|
|
|
107
|
-
|
|
80
|
+
// TLC adds the message of the error that stopped it, when it has one.
|
|
81
|
+
const createCannotHandleError = (expression: Expression, inner?: string) =>
|
|
108
82
|
new TlaEvaluationError(
|
|
109
|
-
`TLC cannot handle the temporal formula
|
|
83
|
+
`TLC cannot handle the temporal formula ${describeRange(expression)}${inner === undefined ? "" : `:\n${inner}`}`,
|
|
110
84
|
);
|
|
111
85
|
|
|
112
86
|
export const getLevel = (
|
|
@@ -118,26 +92,31 @@ export const getLevel = (
|
|
|
118
92
|
const getBindingLevel = (name: string) => {
|
|
119
93
|
const binding = lookupScope(scope, name);
|
|
120
94
|
if (!binding) return undefined;
|
|
121
|
-
if (binding.kind === "Value") return
|
|
95
|
+
if (binding.kind === "Value") return CONSTANT_LEVEL;
|
|
122
96
|
if (binding.kind === "Thunk") return getLevel(binding.expression, binding.scope, environment);
|
|
123
97
|
const operator = binding.operator;
|
|
124
|
-
return operator.kind === "Closure"
|
|
98
|
+
return operator.kind === "Closure"
|
|
99
|
+
? getLevel(operator.body, operator.scope, environment)
|
|
100
|
+
: CONSTANT_LEVEL;
|
|
125
101
|
};
|
|
126
102
|
const getGlobalLevel = (name: string) => {
|
|
127
|
-
if (environment.variableIndex.has(name)) return
|
|
128
|
-
if (environment.constants.has(name)) return
|
|
103
|
+
if (environment.variableIndex.has(name)) return VARIABLE_LEVEL;
|
|
104
|
+
if (environment.constants.has(name)) return CONSTANT_LEVEL;
|
|
129
105
|
const definition = getDefinition(name, environment);
|
|
130
106
|
if (definition) return getDefinitionLevel(definition, environment);
|
|
131
107
|
const builtin = environment.builtins.get(environment.substitutions.get(name) ?? name);
|
|
132
|
-
|
|
108
|
+
if (!builtin) return undefined;
|
|
109
|
+
return builtin.isStateLevel && !builtin.isLevelConstant ? VARIABLE_LEVEL : CONSTANT_LEVEL;
|
|
133
110
|
};
|
|
134
111
|
const getNameLevel = (name: string, node: Expression) => {
|
|
135
|
-
if (shadowed.has(name)) return
|
|
136
|
-
if (isLocallyResolved(node))
|
|
137
|
-
|
|
112
|
+
if (shadowed.has(name)) return CONSTANT_LEVEL;
|
|
113
|
+
if (isLocallyResolved(node)) {
|
|
114
|
+
return getBindingLevel(name) ?? getGlobalLevel(name) ?? CONSTANT_LEVEL;
|
|
115
|
+
}
|
|
116
|
+
return getGlobalLevel(name) ?? getBindingLevel(name) ?? CONSTANT_LEVEL;
|
|
138
117
|
};
|
|
139
118
|
const getChildrenLevel = (node: Expression) => {
|
|
140
|
-
const level = { value:
|
|
119
|
+
const level = { value: CONSTANT_LEVEL };
|
|
141
120
|
mapChildren(node, (child, bound) => {
|
|
142
121
|
level.value = Math.max(
|
|
143
122
|
level.value,
|
|
@@ -159,7 +138,7 @@ export const getLevel = (
|
|
|
159
138
|
case "AngleAction":
|
|
160
139
|
return ACTION_LEVEL;
|
|
161
140
|
case "Enabled":
|
|
162
|
-
return
|
|
141
|
+
return VARIABLE_LEVEL;
|
|
163
142
|
case "Always":
|
|
164
143
|
case "Eventually":
|
|
165
144
|
case "WeakFairness":
|
|
@@ -193,21 +172,51 @@ const getDefinitionLevel = (definition: Definition, environment: Environment) =>
|
|
|
193
172
|
return level;
|
|
194
173
|
};
|
|
195
174
|
|
|
175
|
+
// TLC leaves a formula whose sets it fails to enumerate, and doesn't expect an EvalException.
|
|
176
|
+
const getUnrolledElements = (bounds: Bound[], context: Context) => {
|
|
177
|
+
try {
|
|
178
|
+
return getBoundElements(bounds, context);
|
|
179
|
+
} catch (error) {
|
|
180
|
+
if (!(error instanceof TlaEvaluationError)) throw error;
|
|
181
|
+
if (!isEvalException(error)) return undefined;
|
|
182
|
+
throw setExitCode(
|
|
183
|
+
new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`),
|
|
184
|
+
EXIT_STATUS.error,
|
|
185
|
+
);
|
|
186
|
+
}
|
|
187
|
+
};
|
|
188
|
+
|
|
196
189
|
export const expandTemporal = (
|
|
197
190
|
expression: Expression,
|
|
198
191
|
scope: Scope | undefined,
|
|
199
192
|
environment: Environment,
|
|
200
|
-
|
|
193
|
+
// Whether TLC expands the formula as a property, which unrolls each \A over a constant set.
|
|
194
|
+
isProperty: boolean,
|
|
201
195
|
expanding = new Set<Definition>(),
|
|
202
|
-
|
|
196
|
+
// Whether the expansion entered the body of an instance's definition. Like TLC, it then no
|
|
197
|
+
// longer expands an operator applied to arguments.
|
|
198
|
+
isSubstituted = false,
|
|
199
|
+
name?: string,
|
|
200
|
+
): ExpandedExpression[] => {
|
|
203
201
|
const expand = (
|
|
204
202
|
child: Expression,
|
|
205
203
|
childScope: Scope | undefined,
|
|
204
|
+
childName = name,
|
|
206
205
|
childExpanding = expanding,
|
|
207
|
-
|
|
208
|
-
|
|
206
|
+
definition?: Definition,
|
|
207
|
+
): ExpandedExpression[] =>
|
|
208
|
+
expandTemporal(
|
|
209
|
+
child,
|
|
210
|
+
childScope,
|
|
211
|
+
environment,
|
|
212
|
+
isProperty,
|
|
213
|
+
childExpanding,
|
|
214
|
+
isSubstituted ||
|
|
215
|
+
(definition !== undefined && environment.substitutedDefinitions.has(definition)),
|
|
216
|
+
childName,
|
|
217
|
+
);
|
|
209
218
|
if (expression.kind === "And") {
|
|
210
|
-
return expression.operands.flatMap((operand) => expand(operand, scope));
|
|
219
|
+
return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
|
|
211
220
|
}
|
|
212
221
|
if (expression.kind === "Label") return expand(expression.body, scope);
|
|
213
222
|
if (expression.kind === "Let") {
|
|
@@ -225,38 +234,62 @@ export const expandTemporal = (
|
|
|
225
234
|
!binding &&
|
|
226
235
|
definition?.kind === "Operator" &&
|
|
227
236
|
definition.params.length === 0 &&
|
|
228
|
-
getDefinitionLevel(definition, environment) >
|
|
237
|
+
getDefinitionLevel(definition, environment) > CONSTANT_LEVEL
|
|
229
238
|
) {
|
|
230
239
|
if (expanding.has(definition)) {
|
|
231
|
-
throw
|
|
240
|
+
throw createStackOverflowError();
|
|
232
241
|
}
|
|
233
|
-
return expand(
|
|
242
|
+
return expand(
|
|
243
|
+
definition.body,
|
|
244
|
+
undefined,
|
|
245
|
+
definition.name,
|
|
246
|
+
new Set([...expanding, definition]),
|
|
247
|
+
definition,
|
|
248
|
+
);
|
|
234
249
|
}
|
|
235
250
|
}
|
|
236
251
|
const context = getConstantContext(environment, scope);
|
|
237
|
-
|
|
252
|
+
// TLC 1.7.4 never expands an operator applied to arguments. A property expands every one it
|
|
253
|
+
// applies, but a specification only the temporal ones.
|
|
254
|
+
if (
|
|
255
|
+
expression.kind === "Apply" &&
|
|
256
|
+
environment.runtime.version !== "1.7.4" &&
|
|
257
|
+
(isProperty || getLevel(expression, scope, environment) === TEMPORAL_LEVEL)
|
|
258
|
+
) {
|
|
238
259
|
const operator = resolveApplyOperator(expression, context);
|
|
239
260
|
const definition = isLocallyResolved(expression)
|
|
240
261
|
? undefined
|
|
241
262
|
: getDefinition(expression.operator, environment);
|
|
242
|
-
|
|
243
|
-
|
|
263
|
+
const isExpandable =
|
|
264
|
+
operator?.kind === "Closure" &&
|
|
265
|
+
operator.params.length === expression.args.length &&
|
|
266
|
+
!definition?.isRecursive &&
|
|
267
|
+
!isSubstituted;
|
|
268
|
+
if (isExpandable) {
|
|
269
|
+
return expand(
|
|
270
|
+
operator.body,
|
|
271
|
+
bindOperatorArguments(operator, expression.args, context),
|
|
272
|
+
expression.operator,
|
|
273
|
+
expanding,
|
|
274
|
+
definition,
|
|
275
|
+
);
|
|
244
276
|
}
|
|
245
277
|
}
|
|
246
278
|
const isUnrolled =
|
|
247
|
-
|
|
279
|
+
isProperty &&
|
|
248
280
|
expression.kind === "Forall" &&
|
|
249
|
-
getLevel(
|
|
250
|
-
|
|
251
|
-
if (isUnrolled) {
|
|
252
|
-
const expanded:
|
|
253
|
-
|
|
254
|
-
expanded.push(...expand(expression.body, boundScope));
|
|
281
|
+
expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === CONSTANT_LEVEL);
|
|
282
|
+
const sets = isUnrolled ? getUnrolledElements(expression.bounds, context) : undefined;
|
|
283
|
+
if (isUnrolled && sets) {
|
|
284
|
+
const expanded: ExpandedExpression[] = [];
|
|
285
|
+
forEachBoundElement(expression.bounds, sets, scope, (boundScope) => {
|
|
286
|
+
expanded.push(...expand(expression.body, boundScope, describeRange(expression.body)));
|
|
255
287
|
return false;
|
|
256
288
|
});
|
|
289
|
+
if (expanded.length === 0) throw createTautologyError();
|
|
257
290
|
return expanded;
|
|
258
291
|
}
|
|
259
|
-
return [{ expression, scope }];
|
|
292
|
+
return [{ expression, scope, name }];
|
|
260
293
|
};
|
|
261
294
|
|
|
262
295
|
const bindLetDefinitions = (
|
|
@@ -271,34 +304,30 @@ const bindLetDefinitions = (
|
|
|
271
304
|
return bound;
|
|
272
305
|
};
|
|
273
306
|
|
|
274
|
-
const
|
|
275
|
-
kind: "AngleAction",
|
|
276
|
-
action,
|
|
277
|
-
subscript,
|
|
278
|
-
location: action.location,
|
|
279
|
-
});
|
|
280
|
-
|
|
281
|
-
const toLiveExpression = (
|
|
307
|
+
export const toLiveExpression = (
|
|
282
308
|
root: Expression,
|
|
283
309
|
rootScope: Scope | undefined,
|
|
284
310
|
environment: Environment,
|
|
285
311
|
): LiveExpression => {
|
|
312
|
+
const is174 = environment.runtime.version === "1.7.4";
|
|
286
313
|
const toAtom = (
|
|
287
314
|
expression: Expression,
|
|
288
315
|
scope: Scope | undefined,
|
|
289
316
|
level: number,
|
|
290
317
|
): LiveExpression => {
|
|
291
|
-
|
|
292
|
-
|
|
318
|
+
// TLC after 1.7.4 bounds the level of a formula whose parts are constant by the formula's own.
|
|
319
|
+
const atomLevel =
|
|
320
|
+
level === CONSTANT_LEVEL && !is174 ? getLevel(expression, scope, environment) : level;
|
|
321
|
+
if (atomLevel === CONSTANT_LEVEL) {
|
|
293
322
|
const value = evaluate(expression, getConstantContext(environment, scope));
|
|
294
323
|
if (typeof value !== "boolean") {
|
|
295
324
|
throw new TlaEvaluationError(
|
|
296
|
-
`TLC expected a boolean
|
|
325
|
+
`TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
|
|
297
326
|
);
|
|
298
327
|
}
|
|
299
328
|
return createBoolean(value);
|
|
300
329
|
}
|
|
301
|
-
if (atomLevel ===
|
|
330
|
+
if (atomLevel === VARIABLE_LEVEL) return { kind: "State", expression, scope };
|
|
302
331
|
return { kind: "Action", expression, unchanged: undefined, scope };
|
|
303
332
|
};
|
|
304
333
|
|
|
@@ -311,9 +340,7 @@ const toLiveExpression = (
|
|
|
311
340
|
scope: Scope | undefined,
|
|
312
341
|
) => {
|
|
313
342
|
if (expansion.depth >= MAXIMUM_EXPANSION_DEPTH) {
|
|
314
|
-
throw
|
|
315
|
-
`TLC overflowed the stack while expanding the temporal formula at ${describeLocation(expression)}`,
|
|
316
|
-
);
|
|
343
|
+
throw createStackOverflowError();
|
|
317
344
|
}
|
|
318
345
|
expansion.depth++;
|
|
319
346
|
const result = convert(body, bodyScope);
|
|
@@ -333,7 +360,9 @@ const toLiveExpression = (
|
|
|
333
360
|
? lookupScope(scope, name)
|
|
334
361
|
: undefined;
|
|
335
362
|
if (binding?.kind === "Thunk" && definitionThunks.has(binding)) {
|
|
336
|
-
return
|
|
363
|
+
return expandCall(expression, () =>
|
|
364
|
+
expand(binding.expression, binding.scope, expression, scope),
|
|
365
|
+
);
|
|
337
366
|
}
|
|
338
367
|
const operator =
|
|
339
368
|
binding?.kind === "Operator"
|
|
@@ -345,32 +374,104 @@ const toLiveExpression = (
|
|
|
345
374
|
: resolveGlobalOperator(name, environment);
|
|
346
375
|
if (operator?.kind !== "Closure") throw createCannotHandleError(expression);
|
|
347
376
|
const args = expression.kind === "Apply" ? expression.args : [];
|
|
348
|
-
|
|
377
|
+
const isRecursive =
|
|
378
|
+
!isLocallyResolved(expression) && getDefinition(name, environment)?.isRecursive === true;
|
|
379
|
+
return expandCall(
|
|
380
|
+
expression,
|
|
381
|
+
() => {
|
|
382
|
+
// TLC 1.7.4 evaluates the arguments of an operator it expands.
|
|
383
|
+
if (is174) {
|
|
384
|
+
args
|
|
385
|
+
.filter((arg) => arg.kind !== "Lambda" && arg.kind !== "OperatorReference")
|
|
386
|
+
.forEach((arg) => evaluate(arg, context));
|
|
387
|
+
}
|
|
388
|
+
return expand(
|
|
389
|
+
operator.body,
|
|
390
|
+
bindOperatorArguments(operator, args, context),
|
|
391
|
+
expression,
|
|
392
|
+
scope,
|
|
393
|
+
);
|
|
394
|
+
},
|
|
395
|
+
isRecursive,
|
|
396
|
+
);
|
|
397
|
+
};
|
|
398
|
+
|
|
399
|
+
// TLC takes an application of an operator whose expansion fails for a formula it can't handle,
|
|
400
|
+
// except that TLC after 1.7.4 fails as the expansion of a recursive operator does.
|
|
401
|
+
const expandCall = (
|
|
402
|
+
expression: Expression,
|
|
403
|
+
expandBody: () => LiveExpression,
|
|
404
|
+
isRecursive = false,
|
|
405
|
+
) => {
|
|
406
|
+
try {
|
|
407
|
+
return expandBody();
|
|
408
|
+
} catch (error) {
|
|
409
|
+
const isRethrown = error instanceof TlaStackOverflowError || (isRecursive && !is174);
|
|
410
|
+
if (!(error instanceof TlaEvaluationError) || isRethrown) throw error;
|
|
411
|
+
throw createCannotHandleError(expression);
|
|
412
|
+
}
|
|
349
413
|
};
|
|
350
414
|
|
|
351
415
|
const convertQuantifier = (
|
|
352
416
|
expression: Expression & { kind: "Forall" | "Exists" },
|
|
353
417
|
scope: Scope | undefined,
|
|
354
418
|
) => {
|
|
419
|
+
const level = getLevel(expression, scope, environment);
|
|
355
420
|
const isConstant = expression.bounds.every(
|
|
356
|
-
(bound) => getLevel(bound.set, scope, environment) ===
|
|
421
|
+
(bound) => getLevel(bound.set, scope, environment) === CONSTANT_LEVEL,
|
|
357
422
|
);
|
|
358
|
-
if (!isConstant)
|
|
423
|
+
if (!isConstant) {
|
|
424
|
+
if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
|
|
425
|
+
throw createCannotHandleError(expression);
|
|
426
|
+
}
|
|
359
427
|
const operands: LiveExpression[] = [];
|
|
360
|
-
forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
|
|
361
|
-
operands.push(convert(expression.body, boundScope));
|
|
362
|
-
return false;
|
|
363
|
-
});
|
|
364
428
|
const isForall = expression.kind === "Forall";
|
|
429
|
+
// TLC takes a quantified formula whose body fails for one it can't handle, and under \A it adds
|
|
430
|
+
// the message of a failure that isn't an EvalException.
|
|
431
|
+
try {
|
|
432
|
+
forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
|
|
433
|
+
operands.push(convert(expression.body, boundScope));
|
|
434
|
+
return false;
|
|
435
|
+
});
|
|
436
|
+
} catch (error) {
|
|
437
|
+
if (!(error instanceof TlaEvaluationError) || error instanceof TlaStackOverflowError) {
|
|
438
|
+
throw error;
|
|
439
|
+
}
|
|
440
|
+
if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
|
|
441
|
+
throw createCannotHandleError(
|
|
442
|
+
expression,
|
|
443
|
+
isForall && !isEvalException(error) ? error.message : undefined,
|
|
444
|
+
);
|
|
445
|
+
}
|
|
365
446
|
if (operands.length === 0) return createBoolean(isForall);
|
|
366
|
-
|
|
367
|
-
const level = getLiveLevel(result);
|
|
368
|
-
return level > ACTION_LEVEL ? result : toAtom(expression, scope, level);
|
|
447
|
+
return toWhole(expression, scope, createJunction(isForall ? "And" : "Or", operands));
|
|
369
448
|
};
|
|
370
449
|
|
|
450
|
+
// TLC takes a formula whose translated parts are below temporal level whole, at their level.
|
|
451
|
+
const toWhole = (expression: Expression, scope: Scope | undefined, parts: LiveExpression) => {
|
|
452
|
+
const level = getLiveLevel(parts);
|
|
453
|
+
return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
|
|
454
|
+
};
|
|
455
|
+
|
|
456
|
+
// The formulas below temporal level whose parts TLC's Liveness.astToLive translates, as one
|
|
457
|
+
// that is constant, such as a quantifier over the empty set, can make the formula constant.
|
|
458
|
+
const isTranslatedWhole = (expression: Expression) =>
|
|
459
|
+
expression.kind === "Label" ||
|
|
460
|
+
expression.kind === "Let" ||
|
|
461
|
+
expression.kind === "And" ||
|
|
462
|
+
expression.kind === "Or" ||
|
|
463
|
+
expression.kind === "Forall" ||
|
|
464
|
+
expression.kind === "Exists" ||
|
|
465
|
+
expression.kind === "If" ||
|
|
466
|
+
(expression.kind === "Apply" &&
|
|
467
|
+
((expression.operator === "~" && !isLocallyResolved(expression)) ||
|
|
468
|
+
expression.operator === "=>"));
|
|
469
|
+
|
|
371
470
|
const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
|
|
372
471
|
const level = getLevel(expression, scope, environment);
|
|
373
|
-
if (level <= ACTION_LEVEL
|
|
472
|
+
if (level <= ACTION_LEVEL && !isTranslatedWhole(expression)) {
|
|
473
|
+
return toAtom(expression, scope, level);
|
|
474
|
+
}
|
|
374
475
|
switch (expression.kind) {
|
|
375
476
|
case "Label":
|
|
376
477
|
return convert(expression.body, scope);
|
|
@@ -391,38 +492,51 @@ const toLiveExpression = (
|
|
|
391
492
|
);
|
|
392
493
|
}
|
|
393
494
|
if (expression.operator === "~" && !isLocallyResolved(expression)) {
|
|
394
|
-
return createUnary("Not", convert(args[0], scope));
|
|
495
|
+
return toWhole(expression, scope, createUnary("Not", convert(args[0], scope)));
|
|
395
496
|
}
|
|
396
497
|
if (expression.operator === "=>") {
|
|
397
|
-
return
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
convert(args[1], scope),
|
|
498
|
+
return toWhole(
|
|
499
|
+
expression,
|
|
500
|
+
scope,
|
|
501
|
+
createPair("Or", createUnary("Not", convert(args[0], scope)), convert(args[1], scope)),
|
|
401
502
|
);
|
|
402
503
|
}
|
|
403
504
|
return convertCall(expression, scope);
|
|
404
505
|
}
|
|
405
506
|
case "And":
|
|
406
507
|
case "Or":
|
|
407
|
-
return
|
|
408
|
-
expression
|
|
409
|
-
|
|
508
|
+
return toWhole(
|
|
509
|
+
expression,
|
|
510
|
+
scope,
|
|
511
|
+
createJunction(
|
|
512
|
+
expression.kind,
|
|
513
|
+
expression.operands.map((operand) => convert(operand, scope)),
|
|
514
|
+
),
|
|
410
515
|
);
|
|
411
516
|
case "Forall":
|
|
412
517
|
case "Exists":
|
|
413
518
|
return convertQuantifier(expression, scope);
|
|
414
519
|
case "If": {
|
|
415
|
-
|
|
520
|
+
// TLC 1.7.4 translates both branches whatever the guard.
|
|
521
|
+
if (!is174 && getLevel(expression.condition, scope, environment) === CONSTANT_LEVEL) {
|
|
416
522
|
const condition = evaluate(expression.condition, getConstantContext(environment, scope));
|
|
417
523
|
if (typeof condition === "boolean") {
|
|
418
524
|
return convert(condition ? expression.consequent : expression.alternative, scope);
|
|
419
525
|
}
|
|
420
526
|
}
|
|
421
527
|
const condition = convert(expression.condition, scope);
|
|
422
|
-
return
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
createPair(
|
|
528
|
+
return toWhole(
|
|
529
|
+
expression,
|
|
530
|
+
scope,
|
|
531
|
+
createPair(
|
|
532
|
+
"Or",
|
|
533
|
+
createPair("And", condition, convert(expression.consequent, scope)),
|
|
534
|
+
createPair(
|
|
535
|
+
"And",
|
|
536
|
+
createUnary("Not", condition),
|
|
537
|
+
convert(expression.alternative, scope),
|
|
538
|
+
),
|
|
539
|
+
),
|
|
426
540
|
);
|
|
427
541
|
}
|
|
428
542
|
case "Always":
|
|
@@ -430,7 +544,12 @@ const toLiveExpression = (
|
|
|
430
544
|
return createUnary(expression.kind, convert(expression.expression, scope));
|
|
431
545
|
case "WeakFairness":
|
|
432
546
|
case "StrongFairness": {
|
|
433
|
-
const step =
|
|
547
|
+
const step: Expression = {
|
|
548
|
+
kind: "AngleAction",
|
|
549
|
+
action: expression.action,
|
|
550
|
+
subscript: expression.subscript,
|
|
551
|
+
location: expression.action.location,
|
|
552
|
+
};
|
|
434
553
|
const enabled: LiveEnabled = { kind: "Enabled", step: expression.enabled ?? step, scope };
|
|
435
554
|
const disabled = createUnary("Not", enabled);
|
|
436
555
|
const taken: LiveExpression = {
|
|
@@ -464,7 +583,7 @@ const toLiveExpression = (
|
|
|
464
583
|
return convert(root, rootScope);
|
|
465
584
|
};
|
|
466
585
|
|
|
467
|
-
const evaluateLive = (
|
|
586
|
+
export const evaluateLive = (
|
|
468
587
|
expression: LiveExpression,
|
|
469
588
|
state: Value[],
|
|
470
589
|
next: Value[] | undefined,
|
|
@@ -512,7 +631,7 @@ const evaluateLive = (
|
|
|
512
631
|
}
|
|
513
632
|
};
|
|
514
633
|
|
|
515
|
-
const evaluateOnLasso = (
|
|
634
|
+
export const evaluateOnLasso = (
|
|
516
635
|
expression: LiveExpression,
|
|
517
636
|
path: Value[][],
|
|
518
637
|
cycleStart: number,
|
|
@@ -547,472 +666,3 @@ const evaluateOnLasso = (
|
|
|
547
666
|
);
|
|
548
667
|
}
|
|
549
668
|
};
|
|
550
|
-
|
|
551
|
-
const liveKeys = new WeakMap<LiveExpression, string>();
|
|
552
|
-
|
|
553
|
-
const atomCount = { value: 0 };
|
|
554
|
-
|
|
555
|
-
const getLiveKey = (expression: LiveExpression): string => {
|
|
556
|
-
const cached = liveKeys.get(expression);
|
|
557
|
-
if (cached !== undefined) return cached;
|
|
558
|
-
const key =
|
|
559
|
-
expression.kind === "Boolean"
|
|
560
|
-
? String(expression.value)
|
|
561
|
-
: "body" in expression
|
|
562
|
-
? `${expression.kind}(${getLiveKey(expression.body)})`
|
|
563
|
-
: "operands" in expression
|
|
564
|
-
? `${expression.kind}(${expression.operands.map(getLiveKey).join(",")})`
|
|
565
|
-
: `${expression.kind}#${atomCount.value++}`;
|
|
566
|
-
liveKeys.set(expression, key);
|
|
567
|
-
return key;
|
|
568
|
-
};
|
|
569
|
-
|
|
570
|
-
const isSameState = (left: Value[], right: Value[]) =>
|
|
571
|
-
left.every((value, position) => isSameValue(value, right[position]));
|
|
572
|
-
|
|
573
|
-
const getStronglyConnectedComponents = (
|
|
574
|
-
nodeCount: number,
|
|
575
|
-
getSuccessors: (node: number) => number[],
|
|
576
|
-
visit: (component: number[], successors: (node: number) => number[]) => boolean,
|
|
577
|
-
) => {
|
|
578
|
-
const order = new Int32Array(nodeCount).fill(-1);
|
|
579
|
-
const lowLink = new Int32Array(nodeCount);
|
|
580
|
-
const onStack = new Uint8Array(nodeCount);
|
|
581
|
-
const stack: number[] = [];
|
|
582
|
-
const counter = { value: 0 };
|
|
583
|
-
const successorCache = new Map<number, number[]>();
|
|
584
|
-
const getCachedSuccessors = (node: number) => {
|
|
585
|
-
const cached = successorCache.get(node);
|
|
586
|
-
if (cached) return cached;
|
|
587
|
-
const successors = getSuccessors(node);
|
|
588
|
-
successorCache.set(node, successors);
|
|
589
|
-
return successors;
|
|
590
|
-
};
|
|
591
|
-
for (let root = 0; root < nodeCount; root++) {
|
|
592
|
-
if (order[root] !== -1) continue;
|
|
593
|
-
const frames: { node: number; position: number }[] = [];
|
|
594
|
-
const open = (node: number) => {
|
|
595
|
-
order[node] = counter.value;
|
|
596
|
-
lowLink[node] = counter.value++;
|
|
597
|
-
stack.push(node);
|
|
598
|
-
onStack[node] = 1;
|
|
599
|
-
frames.push({ node, position: 0 });
|
|
600
|
-
};
|
|
601
|
-
open(root);
|
|
602
|
-
while (frames.length > 0) {
|
|
603
|
-
const frame = frames[frames.length - 1];
|
|
604
|
-
const successors = getCachedSuccessors(frame.node);
|
|
605
|
-
if (frame.position < successors.length) {
|
|
606
|
-
const target = successors[frame.position++];
|
|
607
|
-
if (order[target] === -1) open(target);
|
|
608
|
-
else if (onStack[target])
|
|
609
|
-
lowLink[frame.node] = Math.min(lowLink[frame.node], order[target]);
|
|
610
|
-
continue;
|
|
611
|
-
}
|
|
612
|
-
frames.pop();
|
|
613
|
-
const parent = frames[frames.length - 1];
|
|
614
|
-
if (parent) lowLink[parent.node] = Math.min(lowLink[parent.node], lowLink[frame.node]);
|
|
615
|
-
if (lowLink[frame.node] !== order[frame.node]) continue;
|
|
616
|
-
const component: number[] = [];
|
|
617
|
-
while (true) {
|
|
618
|
-
const member = stack.pop();
|
|
619
|
-
if (member === undefined) break;
|
|
620
|
-
onStack[member] = 0;
|
|
621
|
-
component.push(member);
|
|
622
|
-
if (member === frame.node) break;
|
|
623
|
-
}
|
|
624
|
-
const isFound = visit(component, getCachedSuccessors);
|
|
625
|
-
component.forEach((member) => successorCache.delete(member));
|
|
626
|
-
if (isFound) return;
|
|
627
|
-
}
|
|
628
|
-
}
|
|
629
|
-
};
|
|
630
|
-
|
|
631
|
-
const getShortestPath = (
|
|
632
|
-
from: number,
|
|
633
|
-
to: number,
|
|
634
|
-
members: Set<number>,
|
|
635
|
-
getSuccessors: (node: number) => number[],
|
|
636
|
-
) => {
|
|
637
|
-
if (from === to) return [from];
|
|
638
|
-
const parents = new Map<number, number>([[from, -1]]);
|
|
639
|
-
const queue = [from];
|
|
640
|
-
for (let position = 0; position < queue.length; position++) {
|
|
641
|
-
for (const target of getSuccessors(queue[position])) {
|
|
642
|
-
if (parents.has(target) || !members.has(target)) continue;
|
|
643
|
-
parents.set(target, queue[position]);
|
|
644
|
-
if (target === to) {
|
|
645
|
-
const path: number[] = [];
|
|
646
|
-
for (let node = to; node !== -1; node = parents.get(node) ?? -1) path.push(node);
|
|
647
|
-
return path.reverse();
|
|
648
|
-
}
|
|
649
|
-
queue.push(target);
|
|
650
|
-
}
|
|
651
|
-
}
|
|
652
|
-
return [from];
|
|
653
|
-
};
|
|
654
|
-
|
|
655
|
-
const removeRepeats = (path: number[]) =>
|
|
656
|
-
path.filter((node, position) => position === 0 || path[position - 1] !== node);
|
|
657
|
-
|
|
658
|
-
export const createLivenessChecker = (
|
|
659
|
-
properties: TemporalProperty[],
|
|
660
|
-
temporals: ScopedExpression[],
|
|
661
|
-
environment: Environment,
|
|
662
|
-
): LivenessChecker | undefined => {
|
|
663
|
-
if (properties.length === 0) return undefined;
|
|
664
|
-
const fairness = temporals.map((item) =>
|
|
665
|
-
toLiveExpression(item.expression, item.scope, environment),
|
|
666
|
-
);
|
|
667
|
-
const negations = properties.map((property) =>
|
|
668
|
-
createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
|
|
669
|
-
);
|
|
670
|
-
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
671
|
-
const formula =
|
|
672
|
-
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
673
|
-
const solutions = getSolutions(formula);
|
|
674
|
-
if (solutions.length === 0) {
|
|
675
|
-
throw new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)");
|
|
676
|
-
}
|
|
677
|
-
const checks = solutions.map((solution): Check => ({
|
|
678
|
-
solution,
|
|
679
|
-
stateResults: [],
|
|
680
|
-
actionResults: [],
|
|
681
|
-
consistency: [],
|
|
682
|
-
product: solution.tableau && {
|
|
683
|
-
states: [],
|
|
684
|
-
tableauNodes: [],
|
|
685
|
-
edges: [],
|
|
686
|
-
initial: [],
|
|
687
|
-
parents: [],
|
|
688
|
-
},
|
|
689
|
-
productNodes: new Map(),
|
|
690
|
-
nodesByState: new Map(),
|
|
691
|
-
}));
|
|
692
|
-
const actionKeys = new Map<string, number>();
|
|
693
|
-
const actionIds = checks.map((check) =>
|
|
694
|
-
check.solution.actionChecks.map((predicate) => {
|
|
695
|
-
const key = getLiveKey(predicate);
|
|
696
|
-
const known = actionKeys.get(key);
|
|
697
|
-
if (known !== undefined) return known;
|
|
698
|
-
actionKeys.set(key, actionKeys.size);
|
|
699
|
-
return actionKeys.size - 1;
|
|
700
|
-
}),
|
|
701
|
-
);
|
|
702
|
-
const states: Value[][] = [];
|
|
703
|
-
const targets: number[][] = [];
|
|
704
|
-
const edgeStates: Value[][][] = [];
|
|
705
|
-
const initial: number[] = [];
|
|
706
|
-
|
|
707
|
-
const isConsistent = (
|
|
708
|
-
predicates: LiveExpression[],
|
|
709
|
-
state: Value[],
|
|
710
|
-
cache: Map<LiveExpression, boolean>,
|
|
711
|
-
) =>
|
|
712
|
-
predicates.every((predicate) => evaluateLive(predicate, state, undefined, environment, cache));
|
|
713
|
-
|
|
714
|
-
const getProductNode = (
|
|
715
|
-
check: Check,
|
|
716
|
-
product: BehaviorGraph,
|
|
717
|
-
state: number,
|
|
718
|
-
tableauNode: number,
|
|
719
|
-
parent: number,
|
|
720
|
-
) => {
|
|
721
|
-
const key = state * (check.solution.tableau?.nodes.length ?? 1) + tableauNode;
|
|
722
|
-
const existing = check.productNodes.get(key);
|
|
723
|
-
if (existing !== undefined) return { node: existing, isNew: false };
|
|
724
|
-
const node = product.states.length;
|
|
725
|
-
check.productNodes.set(key, node);
|
|
726
|
-
product.states.push(state);
|
|
727
|
-
product.tableauNodes.push(tableauNode);
|
|
728
|
-
product.edges.push([]);
|
|
729
|
-
product.parents.push(parent);
|
|
730
|
-
const siblings = check.nodesByState.get(state);
|
|
731
|
-
if (siblings) siblings.push(node);
|
|
732
|
-
else check.nodesByState.set(state, [node]);
|
|
733
|
-
return { node, isNew: true };
|
|
734
|
-
};
|
|
735
|
-
|
|
736
|
-
const getAttribution = (path: number[], cycleStart: number) => {
|
|
737
|
-
const lasso = path.map((state) => states[state]);
|
|
738
|
-
return (
|
|
739
|
-
properties.find(
|
|
740
|
-
(_, position) =>
|
|
741
|
-
!evaluateOnLasso(negations[position].body, lasso, cycleStart, 0, environment),
|
|
742
|
-
) ?? properties[0]
|
|
743
|
-
).name;
|
|
744
|
-
};
|
|
745
|
-
|
|
746
|
-
const expandProduct = (check: Check, product: BehaviorGraph, tableau: Tableau, state: number) => {
|
|
747
|
-
const hasEmptyModel = check.solution.models.some(
|
|
748
|
-
(model) =>
|
|
749
|
-
model.eventuallyAlways.length === 0 &&
|
|
750
|
-
model.infinitelyOftenStates.length === 0 &&
|
|
751
|
-
model.infinitelyOftenActions.length === 0,
|
|
752
|
-
);
|
|
753
|
-
const nodeCount = tableau.nodes.length;
|
|
754
|
-
const pending = (check.nodesByState.get(state) ?? []).map((node) => ({ node, isDone: false }));
|
|
755
|
-
while (pending.length > 0) {
|
|
756
|
-
const item = pending.pop();
|
|
757
|
-
if (!item) break;
|
|
758
|
-
const source = product.states[item.node];
|
|
759
|
-
const successors = tableau.nodes[product.tableauNodes[item.node]].successors;
|
|
760
|
-
const isAccepted =
|
|
761
|
-
item.isDone &&
|
|
762
|
-
hasEmptyModel &&
|
|
763
|
-
successors.some((successor) => {
|
|
764
|
-
const node = tableau.nodes[successor];
|
|
765
|
-
return node.particle.length === 0 && node.successors.every((next) => next === successor);
|
|
766
|
-
});
|
|
767
|
-
if (isAccepted) {
|
|
768
|
-
const path = removeRepeats(
|
|
769
|
-
getPrefix(product, item.node).map((node) => product.states[node]),
|
|
770
|
-
);
|
|
771
|
-
return { name: getAttribution(path, path.length - 1), path };
|
|
772
|
-
}
|
|
773
|
-
const consistency = check.consistency[source];
|
|
774
|
-
targets[source].forEach((target, edgeIndex) => {
|
|
775
|
-
for (const successor of successors) {
|
|
776
|
-
if (!consistency[edgeIndex * nodeCount + successor]) continue;
|
|
777
|
-
const created = getProductNode(check, product, target, successor, item.node);
|
|
778
|
-
product.edges[item.node].push(created.node, edgeIndex);
|
|
779
|
-
if (created.isNew && targets[target] !== undefined) {
|
|
780
|
-
pending.push({ node: created.node, isDone: true });
|
|
781
|
-
}
|
|
782
|
-
}
|
|
783
|
-
});
|
|
784
|
-
}
|
|
785
|
-
return undefined;
|
|
786
|
-
};
|
|
787
|
-
|
|
788
|
-
const addInitialState = (index: number, state: Value[]) => {
|
|
789
|
-
initial.push(index);
|
|
790
|
-
states[index] = state;
|
|
791
|
-
for (const check of checks) {
|
|
792
|
-
const tableau = check.solution.tableau;
|
|
793
|
-
const product = check.product;
|
|
794
|
-
if (!tableau || !product) continue;
|
|
795
|
-
const cache = new Map<LiveExpression, boolean>();
|
|
796
|
-
for (let node = 0; node < tableau.initialCount; node++) {
|
|
797
|
-
if (!isConsistent(tableau.nodes[node].statePredicates, state, cache)) continue;
|
|
798
|
-
product.initial.push(getProductNode(check, product, index, node, -1).node);
|
|
799
|
-
}
|
|
800
|
-
}
|
|
801
|
-
};
|
|
802
|
-
|
|
803
|
-
const addState = (index: number, state: Value[], successors: LiveSuccessor[]) => {
|
|
804
|
-
environment.runtime.setLivenessSource(index);
|
|
805
|
-
states[index] = state;
|
|
806
|
-
const edges: LiveSuccessor[] = [];
|
|
807
|
-
const edgesByTarget = new Map<number, LiveSuccessor[]>();
|
|
808
|
-
for (const successor of [...successors, { index, state }]) {
|
|
809
|
-
const sameTarget = edgesByTarget.get(successor.index);
|
|
810
|
-
const isDuplicate =
|
|
811
|
-
sameTarget !== undefined &&
|
|
812
|
-
(successor.index < index ||
|
|
813
|
-
sameTarget.some((edge) => isSameState(edge.state, successor.state)));
|
|
814
|
-
if (isDuplicate) continue;
|
|
815
|
-
edges.push(successor);
|
|
816
|
-
if (sameTarget) sameTarget.push(successor);
|
|
817
|
-
else edgesByTarget.set(successor.index, [successor]);
|
|
818
|
-
}
|
|
819
|
-
targets[index] = edges.map((edge) => edge.index);
|
|
820
|
-
edgeStates[index] = edges.map((edge) => edge.state);
|
|
821
|
-
const stateCache = new Map<LiveExpression, boolean>();
|
|
822
|
-
const successorCaches = edges.map(() => new Map<LiveExpression, boolean>());
|
|
823
|
-
for (const check of checks) {
|
|
824
|
-
const solution = check.solution;
|
|
825
|
-
check.stateResults[index] = Uint8Array.from(solution.stateChecks, (predicate) =>
|
|
826
|
-
evaluateLive(predicate, state, undefined, environment, stateCache) ? 1 : 0,
|
|
827
|
-
);
|
|
828
|
-
const tableau = solution.tableau;
|
|
829
|
-
const product = check.product;
|
|
830
|
-
if (!tableau || !product) continue;
|
|
831
|
-
const nodeCount = tableau.nodes.length;
|
|
832
|
-
const consistency = new Uint8Array(edges.length * nodeCount);
|
|
833
|
-
edges.forEach((edge, edgeIndex) => {
|
|
834
|
-
tableau.nodes.forEach((node, nodeIndex) => {
|
|
835
|
-
const isTrue = isConsistent(node.statePredicates, edge.state, successorCaches[edgeIndex]);
|
|
836
|
-
consistency[edgeIndex * nodeCount + nodeIndex] = isTrue ? 1 : 0;
|
|
837
|
-
});
|
|
838
|
-
});
|
|
839
|
-
check.consistency[index] = consistency;
|
|
840
|
-
const accepted = expandProduct(check, product, tableau, index);
|
|
841
|
-
if (accepted) return accepted;
|
|
842
|
-
}
|
|
843
|
-
return undefined;
|
|
844
|
-
};
|
|
845
|
-
|
|
846
|
-
const computeActionResults = (source: number) => {
|
|
847
|
-
environment.runtime.setLivenessSource(source);
|
|
848
|
-
const state = states[source];
|
|
849
|
-
const successors = edgeStates[source];
|
|
850
|
-
const values = successors.map(() => new Int8Array(actionKeys.size).fill(-1));
|
|
851
|
-
checks.forEach((check, checkIndex) => {
|
|
852
|
-
const solution = check.solution;
|
|
853
|
-
const ids = actionIds[checkIndex];
|
|
854
|
-
const stateResults = check.stateResults[source];
|
|
855
|
-
const stateCache = new Map(
|
|
856
|
-
solution.stateChecks.map((predicate, position) => [
|
|
857
|
-
predicate,
|
|
858
|
-
stateResults[position] === 1,
|
|
859
|
-
]),
|
|
860
|
-
);
|
|
861
|
-
const actionCount = solution.actionChecks.length;
|
|
862
|
-
const actions = new Uint8Array(successors.length * actionCount);
|
|
863
|
-
successors.forEach((successor, edgeIndex) => {
|
|
864
|
-
const known = values[edgeIndex];
|
|
865
|
-
for (let position = 0; position < actionCount; position++) {
|
|
866
|
-
const actionId = ids[position];
|
|
867
|
-
if (known[actionId] === -1) {
|
|
868
|
-
const predicate = solution.actionChecks[position];
|
|
869
|
-
known[actionId] = evaluateLive(predicate, state, successor, environment, stateCache)
|
|
870
|
-
? 1
|
|
871
|
-
: 0;
|
|
872
|
-
}
|
|
873
|
-
actions[edgeIndex * actionCount + position] = known[actionId];
|
|
874
|
-
}
|
|
875
|
-
});
|
|
876
|
-
check.actionResults[source] = actions;
|
|
877
|
-
});
|
|
878
|
-
};
|
|
879
|
-
|
|
880
|
-
const getActionResults = (check: Check, source: number) => {
|
|
881
|
-
if (check.actionResults[source] === undefined) computeActionResults(source);
|
|
882
|
-
return check.actionResults[source];
|
|
883
|
-
};
|
|
884
|
-
|
|
885
|
-
const getGraph = (check: Check): BehaviorGraph =>
|
|
886
|
-
check.product ?? {
|
|
887
|
-
states: states.map((_, index) => index),
|
|
888
|
-
tableauNodes: states.map(() => -1),
|
|
889
|
-
edges: Array.from({ length: states.length }, (_, index) =>
|
|
890
|
-
(targets[index] ?? []).flatMap((target, edgeIndex) => [target, edgeIndex]),
|
|
891
|
-
),
|
|
892
|
-
initial,
|
|
893
|
-
parents: [],
|
|
894
|
-
};
|
|
895
|
-
|
|
896
|
-
const getPrefix = (graph: BehaviorGraph, entry: number) => {
|
|
897
|
-
if (graph.parents.length > 0) {
|
|
898
|
-
const path: number[] = [];
|
|
899
|
-
for (let node = entry; node !== -1; node = graph.parents[node]) path.push(node);
|
|
900
|
-
return path.reverse();
|
|
901
|
-
}
|
|
902
|
-
const parents = new Map<number, number>(graph.initial.map((node) => [node, -1]));
|
|
903
|
-
const queue = [...graph.initial];
|
|
904
|
-
for (let position = 0; position < queue.length && !parents.has(entry); position++) {
|
|
905
|
-
const edges = graph.edges[queue[position]];
|
|
906
|
-
for (let offset = 0; offset < edges.length; offset += 2) {
|
|
907
|
-
if (parents.has(edges[offset])) continue;
|
|
908
|
-
parents.set(edges[offset], queue[position]);
|
|
909
|
-
queue.push(edges[offset]);
|
|
910
|
-
}
|
|
911
|
-
}
|
|
912
|
-
const path: number[] = [];
|
|
913
|
-
for (let node = entry; node !== -1; node = parents.get(node) ?? -1) path.push(node);
|
|
914
|
-
return path.reverse();
|
|
915
|
-
};
|
|
916
|
-
|
|
917
|
-
const findInCheck = (check: Check): Lasso | undefined => {
|
|
918
|
-
const solution = check.solution;
|
|
919
|
-
const tableau = solution.tableau;
|
|
920
|
-
const graph = getGraph(check);
|
|
921
|
-
const actionCount = solution.actionChecks.length;
|
|
922
|
-
const getAction = (node: number, edgeIndex: number, position: number) =>
|
|
923
|
-
getActionResults(check, graph.states[node])[edgeIndex * actionCount + position] === 1;
|
|
924
|
-
for (const model of solution.models) {
|
|
925
|
-
const isAllowed = (node: number, edgeIndex: number) =>
|
|
926
|
-
model.eventuallyAlways.every((position) => getAction(node, edgeIndex, position));
|
|
927
|
-
const getSuccessors = (node: number) => {
|
|
928
|
-
const edges = graph.edges[node];
|
|
929
|
-
const successors: number[] = [];
|
|
930
|
-
for (let offset = 0; offset < edges.length; offset += 2) {
|
|
931
|
-
if (isAllowed(node, edges[offset + 1])) successors.push(edges[offset]);
|
|
932
|
-
}
|
|
933
|
-
return successors;
|
|
934
|
-
};
|
|
935
|
-
const lasso = { value: undefined as Lasso | undefined };
|
|
936
|
-
getStronglyConnectedComponents(
|
|
937
|
-
graph.states.length,
|
|
938
|
-
getSuccessors,
|
|
939
|
-
(component, successors) => {
|
|
940
|
-
const members = new Set(component);
|
|
941
|
-
if (component.length === 1 && !successors(component[0]).includes(component[0]))
|
|
942
|
-
return false;
|
|
943
|
-
const stateWitnesses = model.infinitelyOftenStates.map((position) =>
|
|
944
|
-
component.find((node) => check.stateResults[graph.states[node]][position] === 1),
|
|
945
|
-
);
|
|
946
|
-
const actionWitnesses = model.infinitelyOftenActions.map((position) => {
|
|
947
|
-
for (const node of component) {
|
|
948
|
-
const edges = graph.edges[node];
|
|
949
|
-
for (let offset = 0; offset < edges.length; offset += 2) {
|
|
950
|
-
const isWitness =
|
|
951
|
-
members.has(edges[offset]) &&
|
|
952
|
-
isAllowed(node, edges[offset + 1]) &&
|
|
953
|
-
getAction(node, edges[offset + 1], position);
|
|
954
|
-
if (isWitness) return [node, edges[offset]];
|
|
955
|
-
}
|
|
956
|
-
}
|
|
957
|
-
return undefined;
|
|
958
|
-
});
|
|
959
|
-
const promiseWitnesses = solution.promises.map((promise) =>
|
|
960
|
-
component.find(
|
|
961
|
-
(node) =>
|
|
962
|
-
tableau !== undefined &&
|
|
963
|
-
isFulfilling(tableau.nodes[graph.tableauNodes[node]].particle, promise),
|
|
964
|
-
),
|
|
965
|
-
);
|
|
966
|
-
const isViolation =
|
|
967
|
-
stateWitnesses.every((witness) => witness !== undefined) &&
|
|
968
|
-
actionWitnesses.every((witness) => witness !== undefined) &&
|
|
969
|
-
promiseWitnesses.every((witness) => witness !== undefined);
|
|
970
|
-
if (!isViolation) return false;
|
|
971
|
-
const entry = component[component.length - 1];
|
|
972
|
-
const waypoints = [
|
|
973
|
-
...stateWitnesses.flatMap((witness) => witness ?? []),
|
|
974
|
-
...actionWitnesses.flatMap((witness) => witness ?? []),
|
|
975
|
-
...promiseWitnesses.flatMap((witness) => witness ?? []),
|
|
976
|
-
];
|
|
977
|
-
const cycle = [entry];
|
|
978
|
-
for (const waypoint of waypoints) {
|
|
979
|
-
cycle.push(
|
|
980
|
-
...getShortestPath(cycle[cycle.length - 1], waypoint, members, successors).slice(1),
|
|
981
|
-
);
|
|
982
|
-
}
|
|
983
|
-
if (cycle.length === 1 && !successors(entry).includes(entry)) {
|
|
984
|
-
cycle.push(successors(entry).find((node) => members.has(node)) ?? entry);
|
|
985
|
-
}
|
|
986
|
-
const closing = getShortestPath(cycle[cycle.length - 1], entry, members, successors);
|
|
987
|
-
cycle.push(...closing.slice(1, -1));
|
|
988
|
-
const prefix = removeRepeats(getPrefix(graph, entry).map((node) => graph.states[node]));
|
|
989
|
-
const cycleStates = removeRepeats(cycle.map((node) => graph.states[node]));
|
|
990
|
-
if (cycleStates.length > 1 && cycleStates[cycleStates.length - 1] === cycleStates[0]) {
|
|
991
|
-
cycleStates.pop();
|
|
992
|
-
}
|
|
993
|
-
prefix.pop();
|
|
994
|
-
lasso.value = {
|
|
995
|
-
name: getAttribution([...prefix, ...cycleStates], prefix.length),
|
|
996
|
-
prefix,
|
|
997
|
-
cycle: cycleStates,
|
|
998
|
-
};
|
|
999
|
-
return true;
|
|
1000
|
-
},
|
|
1001
|
-
);
|
|
1002
|
-
if (lasso.value) return lasso.value;
|
|
1003
|
-
}
|
|
1004
|
-
return undefined;
|
|
1005
|
-
};
|
|
1006
|
-
|
|
1007
|
-
return {
|
|
1008
|
-
addInitialState,
|
|
1009
|
-
addState,
|
|
1010
|
-
findViolation: () => {
|
|
1011
|
-
for (const check of checks) {
|
|
1012
|
-
const lasso = findInCheck(check);
|
|
1013
|
-
if (lasso) return lasso;
|
|
1014
|
-
}
|
|
1015
|
-
return undefined;
|
|
1016
|
-
},
|
|
1017
|
-
};
|
|
1018
|
-
};
|