tla-ts 0.0.4 → 0.0.5-dev.5b2dea1
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 +84 -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
|
@@ -49,7 +49,7 @@ export interface LivenessChecker {
|
|
|
49
49
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
50
50
|
}
|
|
51
51
|
|
|
52
|
-
|
|
52
|
+
interface SearchGraph {
|
|
53
53
|
getFingerprint: (successor: LiveSuccessor) => number;
|
|
54
54
|
getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
|
|
55
55
|
}
|
|
@@ -63,7 +63,7 @@ interface Pool<Data extends Int32Array | Uint8Array> {
|
|
|
63
63
|
}
|
|
64
64
|
|
|
65
65
|
// TLC's behavior graph for one solution: a node per state, or per state and tableau node.
|
|
66
|
-
interface
|
|
66
|
+
interface BehaviorGraph {
|
|
67
67
|
solution: Solution;
|
|
68
68
|
// One id per distinct action check across the solutions.
|
|
69
69
|
actionIds: Int32Array;
|
|
@@ -79,10 +79,11 @@ interface Check {
|
|
|
79
79
|
edgeActions: Pool<Uint8Array>;
|
|
80
80
|
stateResults: Pool<Uint8Array>;
|
|
81
81
|
initial: number[];
|
|
82
|
-
// The nodes of each state in the order
|
|
82
|
+
// The nodes of each state in the order they are recorded, a list through nextSiblings.
|
|
83
83
|
firstNodes: Pool<Int32Array>;
|
|
84
84
|
lastNodes: Pool<Int32Array>;
|
|
85
85
|
nextSiblings: number[];
|
|
86
|
+
nodeIds: NodeTable;
|
|
86
87
|
isDone: boolean[];
|
|
87
88
|
errorNode: number | undefined;
|
|
88
89
|
}
|
|
@@ -140,39 +141,59 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
140
141
|
|
|
141
142
|
const NO_NODE = -1;
|
|
142
143
|
|
|
144
|
+
// A Map holds at most 2^24 entries, so each tableau node of a state finds its node in an
|
|
145
|
+
// open-addressing table of (state plus one, tableau node, node) triples.
|
|
146
|
+
interface NodeTable {
|
|
147
|
+
slots: Int32Array;
|
|
148
|
+
size: number;
|
|
149
|
+
shift: number;
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
const getNodeSlot = (table: NodeTable, state: number, tableauNode: number) => {
|
|
153
|
+
const mask = table.slots.length / 3 - 1;
|
|
154
|
+
const hash = Math.imul(Math.imul(state, 0x9e3779b1) ^ tableauNode, 0x85ebca6b) >>> table.shift;
|
|
155
|
+
for (let index = hash; ; index = (index + 1) & mask) {
|
|
156
|
+
const slot = index * 3;
|
|
157
|
+
const stored = table.slots[slot];
|
|
158
|
+
if (stored === 0 || (stored === state + 1 && table.slots[slot + 1] === tableauNode)) {
|
|
159
|
+
return slot;
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
};
|
|
163
|
+
|
|
143
164
|
const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
144
165
|
|
|
145
166
|
const UNWRITTEN = -1;
|
|
146
167
|
|
|
147
|
-
const isWritten = (
|
|
148
|
-
(
|
|
168
|
+
const isWritten = (behavior: BehaviorGraph, node: number) =>
|
|
169
|
+
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
149
170
|
|
|
150
|
-
const
|
|
151
|
-
const start =
|
|
152
|
-
return
|
|
171
|
+
const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
|
|
172
|
+
const start = behavior.edgeStarts[node];
|
|
173
|
+
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
153
174
|
};
|
|
154
175
|
|
|
155
|
-
const getStateResult = (
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
176
|
+
const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
|
|
177
|
+
behavior.stateResults.data[
|
|
178
|
+
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
179
|
+
] === 1;
|
|
180
|
+
|
|
181
|
+
// A node owns one entry in each per-node array of its graph.
|
|
182
|
+
const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
183
|
+
behavior.nodeStates.push(state);
|
|
184
|
+
behavior.nodeTableaux.push(tableauNode);
|
|
185
|
+
behavior.edgeStarts.push(UNWRITTEN);
|
|
186
|
+
behavior.edgeCounts.push(0);
|
|
187
|
+
behavior.nextSiblings.push(NO_NODE);
|
|
188
|
+
return behavior.nodeStates.length - 1;
|
|
167
189
|
};
|
|
168
190
|
|
|
169
|
-
|
|
170
|
-
const getStateNodes = (check: Check, state: number) => {
|
|
191
|
+
const getStateNodes = (behavior: BehaviorGraph, state: number) => {
|
|
171
192
|
const nodes: number[] = [];
|
|
172
193
|
for (
|
|
173
|
-
let node =
|
|
194
|
+
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
174
195
|
node !== NO_NODE;
|
|
175
|
-
node =
|
|
196
|
+
node = behavior.nextSiblings[node]
|
|
176
197
|
) {
|
|
177
198
|
nodes.push(node);
|
|
178
199
|
}
|
|
@@ -191,7 +212,7 @@ export const createLivenessChecker = (
|
|
|
191
212
|
properties: TemporalProperty[],
|
|
192
213
|
temporals: ScopedExpression[],
|
|
193
214
|
environment: Environment,
|
|
194
|
-
|
|
215
|
+
search: SearchGraph,
|
|
195
216
|
): LivenessChecker | undefined => {
|
|
196
217
|
if (properties.length === 0) return undefined;
|
|
197
218
|
const fairness = temporals.map((item) =>
|
|
@@ -208,7 +229,7 @@ export const createLivenessChecker = (
|
|
|
208
229
|
throw createTautologyError();
|
|
209
230
|
}
|
|
210
231
|
const actionIds = new Map<string, number>();
|
|
211
|
-
const
|
|
232
|
+
const behaviors = solutions.map((solution): BehaviorGraph => ({
|
|
212
233
|
solution,
|
|
213
234
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
214
235
|
const key = getTermKey(predicate);
|
|
@@ -227,6 +248,7 @@ export const createLivenessChecker = (
|
|
|
227
248
|
firstNodes: createPool(createNodes),
|
|
228
249
|
lastNodes: createPool(createNodes),
|
|
229
250
|
nextSiblings: [],
|
|
251
|
+
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
230
252
|
isDone: [],
|
|
231
253
|
errorNode: undefined,
|
|
232
254
|
}));
|
|
@@ -260,15 +282,20 @@ export const createLivenessChecker = (
|
|
|
260
282
|
evaluation.environment,
|
|
261
283
|
isShared ? getStateCache(state) : new Map(),
|
|
262
284
|
);
|
|
263
|
-
const checkState = (
|
|
285
|
+
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
264
286
|
evaluateFrom(source, () =>
|
|
265
|
-
Uint8Array.from(
|
|
287
|
+
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
266
288
|
evaluateState(predicate, state) ? 1 : 0,
|
|
267
289
|
),
|
|
268
290
|
);
|
|
269
|
-
const checkAction = (
|
|
291
|
+
const checkAction = (
|
|
292
|
+
behavior: BehaviorGraph,
|
|
293
|
+
source: number,
|
|
294
|
+
state: Value[],
|
|
295
|
+
successor: Value[],
|
|
296
|
+
) =>
|
|
270
297
|
evaluateFrom(source, () => {
|
|
271
|
-
const predicates =
|
|
298
|
+
const predicates = behavior.solution.actionChecks;
|
|
272
299
|
if (!isShared) {
|
|
273
300
|
return Uint8Array.from(predicates, (predicate) =>
|
|
274
301
|
evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
|
|
@@ -279,7 +306,7 @@ export const createLivenessChecker = (
|
|
|
279
306
|
shared.actions.set(state, results);
|
|
280
307
|
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
281
308
|
results.set(successor, known);
|
|
282
|
-
return Uint8Array.from(
|
|
309
|
+
return Uint8Array.from(behavior.actionIds, (id, position) => {
|
|
283
310
|
if (known[id] === -1) {
|
|
284
311
|
known[id] = evaluateLive(
|
|
285
312
|
predicates[position],
|
|
@@ -314,42 +341,63 @@ export const createLivenessChecker = (
|
|
|
314
341
|
tableauNode.successors[0] === node
|
|
315
342
|
);
|
|
316
343
|
};
|
|
317
|
-
const hasEmptyModel = (
|
|
318
|
-
|
|
344
|
+
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
345
|
+
behavior.solution.models.some(
|
|
319
346
|
(model) =>
|
|
320
347
|
model.eventuallyAlways.length === 0 &&
|
|
321
348
|
model.infinitelyOftenStates.length === 0 &&
|
|
322
349
|
model.infinitelyOftenActions.length === 0,
|
|
323
350
|
);
|
|
324
351
|
|
|
325
|
-
const getNodeId = (
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
352
|
+
const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
353
|
+
if (!behavior.solution.tableau) return state;
|
|
354
|
+
const slots = behavior.nodeIds.slots;
|
|
355
|
+
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
356
|
+
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
357
|
+
};
|
|
358
|
+
const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
359
|
+
const node = pushNode(behavior, state, tableauNode);
|
|
360
|
+
const table = behavior.nodeIds;
|
|
361
|
+
if (++table.size * 2 > table.slots.length / 3) {
|
|
362
|
+
const old = table.slots;
|
|
363
|
+
table.slots = new Int32Array(old.length * 2);
|
|
364
|
+
table.shift--;
|
|
365
|
+
for (let slot = 0; slot < old.length; slot += 3) {
|
|
366
|
+
if (old[slot] !== 0) {
|
|
367
|
+
table.slots.set(
|
|
368
|
+
old.subarray(slot, slot + 3),
|
|
369
|
+
getNodeSlot(table, old[slot] - 1, old[slot + 1]),
|
|
370
|
+
);
|
|
371
|
+
}
|
|
372
|
+
}
|
|
373
|
+
}
|
|
374
|
+
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
375
|
+
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
376
|
+
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
377
|
+
else behavior.nextSiblings[last] = node;
|
|
378
|
+
writeToPool(behavior.lastNodes, state, [node]);
|
|
335
379
|
return node;
|
|
336
380
|
};
|
|
337
381
|
const writeNode = (
|
|
338
|
-
|
|
382
|
+
behavior: BehaviorGraph,
|
|
339
383
|
node: number,
|
|
340
384
|
targets: number[],
|
|
341
385
|
actions: Uint8Array[],
|
|
342
386
|
stateResults: Uint8Array,
|
|
343
387
|
) => {
|
|
344
|
-
const start =
|
|
345
|
-
const actionCount =
|
|
346
|
-
writeToPool(
|
|
388
|
+
const start = behavior.edgeTargets.length;
|
|
389
|
+
const actionCount = behavior.solution.actionChecks.length;
|
|
390
|
+
writeToPool(behavior.edgeTargets, start, targets);
|
|
347
391
|
actions.forEach((results, position) =>
|
|
348
|
-
writeToPool(
|
|
392
|
+
writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
|
|
349
393
|
);
|
|
350
|
-
writeToPool(
|
|
351
|
-
|
|
352
|
-
|
|
394
|
+
writeToPool(
|
|
395
|
+
behavior.stateResults,
|
|
396
|
+
behavior.nodeStates[node] * stateResults.length,
|
|
397
|
+
stateResults,
|
|
398
|
+
);
|
|
399
|
+
behavior.edgeStarts[node] = start;
|
|
400
|
+
behavior.edgeCounts[node] = targets.length;
|
|
353
401
|
};
|
|
354
402
|
|
|
355
403
|
// TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
|
|
@@ -362,9 +410,9 @@ export const createLivenessChecker = (
|
|
|
362
410
|
}),
|
|
363
411
|
count: 0,
|
|
364
412
|
};
|
|
365
|
-
const
|
|
413
|
+
const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
|
|
366
414
|
for (
|
|
367
|
-
let slot = (
|
|
415
|
+
let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
|
|
368
416
|
;
|
|
369
417
|
slot = (slot + 1) % slots.length
|
|
370
418
|
) {
|
|
@@ -377,72 +425,76 @@ export const createLivenessChecker = (
|
|
|
377
425
|
return false;
|
|
378
426
|
}
|
|
379
427
|
};
|
|
380
|
-
const
|
|
428
|
+
const addSuccessor = (successor: LiveSuccessor) => {
|
|
381
429
|
if (table.count >= table.slots.length >> 1) {
|
|
382
430
|
const old = table.slots;
|
|
383
431
|
table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
|
|
384
|
-
for (const entry of old) if (entry)
|
|
432
|
+
for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
|
|
385
433
|
}
|
|
386
|
-
if (
|
|
434
|
+
if (insertSuccessor(table.slots, successor)) table.count++;
|
|
387
435
|
};
|
|
388
|
-
successors.forEach(
|
|
389
|
-
|
|
436
|
+
successors.forEach(addSuccessor);
|
|
437
|
+
addSuccessor({ index, state });
|
|
390
438
|
if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
|
|
391
439
|
return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
|
|
392
440
|
};
|
|
393
441
|
|
|
394
442
|
// TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
|
|
395
443
|
const expandLate = (
|
|
396
|
-
|
|
444
|
+
behavior: BehaviorGraph,
|
|
397
445
|
tableau: Tableau,
|
|
398
446
|
state: Value[],
|
|
399
447
|
index: number,
|
|
400
448
|
node: number,
|
|
401
449
|
) => {
|
|
402
|
-
const stateResults = checkState(
|
|
403
|
-
const tableauNode = tableau.nodes[
|
|
450
|
+
const stateResults = checkState(behavior, index, state);
|
|
451
|
+
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
404
452
|
const actions: Uint8Array[] = [];
|
|
405
453
|
const successors: number[] = [];
|
|
406
454
|
const selfActions =
|
|
407
455
|
tableauNode.successors.length > 0
|
|
408
|
-
? checkAction(
|
|
456
|
+
? checkAction(behavior, index, state, state)
|
|
409
457
|
: new Uint8Array(0);
|
|
410
458
|
for (const next of tableauNode.successors) {
|
|
411
459
|
if (!isConsistent(tableau, next, index, state)) continue;
|
|
412
|
-
if (
|
|
413
|
-
|
|
460
|
+
if (
|
|
461
|
+
isAccepting(tableau, next) &&
|
|
462
|
+
behavior.errorNode === undefined &&
|
|
463
|
+
hasEmptyModel(behavior)
|
|
464
|
+
) {
|
|
465
|
+
behavior.errorNode = node;
|
|
414
466
|
return;
|
|
415
467
|
}
|
|
416
|
-
const existing = getNodeId(
|
|
468
|
+
const existing = getNodeId(behavior, index, next);
|
|
417
469
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
418
|
-
const target = existing ?? recordNode(
|
|
470
|
+
const target = existing ?? recordNode(behavior, index, next);
|
|
419
471
|
successors.push(target);
|
|
420
472
|
actions.push(selfActions);
|
|
421
|
-
if (existing === undefined) expandLate(
|
|
473
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
422
474
|
}
|
|
423
|
-
for (const successor of
|
|
424
|
-
const successorActions = checkAction(
|
|
425
|
-
const isDone =
|
|
475
|
+
for (const successor of search.getSuccessors(index, state)) {
|
|
476
|
+
const successorActions = checkAction(behavior, index, state, successor.state);
|
|
477
|
+
const isDone = behavior.isDone[successor.index] === true;
|
|
426
478
|
for (const next of tableauNode.successors) {
|
|
427
479
|
if (!isConsistent(tableau, next, index, successor.state)) continue;
|
|
428
480
|
// A successor the search never stored follows a violation or an error, after which nothing
|
|
429
481
|
// checks the graph. TLC records its node, which it never expands.
|
|
430
482
|
if (successor.index === -1) continue;
|
|
431
|
-
const existing = getNodeId(
|
|
483
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
432
484
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
433
|
-
const target = existing ?? recordNode(
|
|
485
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
434
486
|
successors.push(target);
|
|
435
487
|
actions.push(successorActions);
|
|
436
488
|
if (existing === undefined && isDone) {
|
|
437
|
-
expandLate(
|
|
489
|
+
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
438
490
|
}
|
|
439
491
|
}
|
|
440
492
|
}
|
|
441
|
-
if (successors.length > 0) writeNode(
|
|
493
|
+
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
442
494
|
};
|
|
443
495
|
|
|
444
496
|
const addTableauState = (
|
|
445
|
-
|
|
497
|
+
behavior: BehaviorGraph,
|
|
446
498
|
tableau: Tableau,
|
|
447
499
|
set: LiveSuccessor[],
|
|
448
500
|
actionResults: Uint8Array[],
|
|
@@ -452,74 +504,73 @@ export const createLivenessChecker = (
|
|
|
452
504
|
const consistency = tableau.nodes.map((_, node) =>
|
|
453
505
|
set.map((successor) => isConsistent(tableau, node, index, successor.state)),
|
|
454
506
|
);
|
|
455
|
-
|
|
507
|
+
behavior.isDone[index] = true;
|
|
456
508
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
457
|
-
for (const node of getStateNodes(
|
|
509
|
+
for (const node of getStateNodes(behavior, index)) {
|
|
458
510
|
const successors: number[] = [];
|
|
459
511
|
const actions: Uint8Array[] = [];
|
|
460
512
|
set.forEach((successor, position) => {
|
|
461
|
-
const isDone =
|
|
462
|
-
for (const next of tableau.nodes[
|
|
513
|
+
const isDone = behavior.isDone[successor.index] === true;
|
|
514
|
+
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
463
515
|
if (!consistency[next][position]) continue;
|
|
464
|
-
const existing = getNodeId(
|
|
516
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
465
517
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
466
|
-
const target = existing ?? recordNode(
|
|
518
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
467
519
|
successors.push(target);
|
|
468
520
|
actions.push(actionResults[position]);
|
|
469
521
|
if (existing === undefined && isDone) {
|
|
470
|
-
expandLate(
|
|
522
|
+
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
471
523
|
}
|
|
472
524
|
}
|
|
473
525
|
});
|
|
474
|
-
writeNode(
|
|
526
|
+
writeNode(behavior, node, successors, actions, stateResults);
|
|
475
527
|
}
|
|
476
|
-
if (
|
|
528
|
+
if (behavior.errorNode === undefined) return undefined;
|
|
477
529
|
return removeRepeats(
|
|
478
|
-
getPath(
|
|
530
|
+
getPath(behavior, behavior.errorNode)
|
|
479
531
|
.reverse()
|
|
480
|
-
.map((node) =>
|
|
532
|
+
.map((node) => behavior.nodeStates[node]),
|
|
481
533
|
);
|
|
482
534
|
};
|
|
483
535
|
|
|
484
536
|
const addPlainState = (
|
|
485
|
-
|
|
537
|
+
behavior: BehaviorGraph,
|
|
486
538
|
set: LiveSuccessor[],
|
|
487
539
|
actionResults: Uint8Array[],
|
|
488
540
|
stateResults: Uint8Array,
|
|
489
541
|
index: number,
|
|
490
542
|
) => {
|
|
491
|
-
while (
|
|
543
|
+
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
492
544
|
const successors: number[] = [];
|
|
493
545
|
const actions: Uint8Array[] = [];
|
|
494
546
|
set.forEach((successor, position) => {
|
|
495
|
-
if (isWritten(
|
|
547
|
+
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
496
548
|
successors.push(successor.index);
|
|
497
549
|
actions.push(actionResults[position]);
|
|
498
550
|
});
|
|
499
|
-
writeNode(
|
|
500
|
-
return undefined;
|
|
551
|
+
writeNode(behavior, index, successors, actions, stateResults);
|
|
501
552
|
};
|
|
502
553
|
|
|
503
554
|
// The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
|
|
504
|
-
const getPath = (
|
|
505
|
-
if (
|
|
555
|
+
const getPath = (behavior: BehaviorGraph, target: number) => {
|
|
556
|
+
if (behavior.initial.includes(target)) return [target];
|
|
506
557
|
const parents = new Map<number, number>();
|
|
507
558
|
const queue: number[] = [];
|
|
508
|
-
for (const node of
|
|
509
|
-
if (!isWritten(
|
|
559
|
+
for (const node of behavior.initial) {
|
|
560
|
+
if (!isWritten(behavior, node)) continue;
|
|
510
561
|
queue.push(node);
|
|
511
562
|
parents.set(node, -1);
|
|
512
563
|
}
|
|
513
564
|
for (let position = 0; position < queue.length; position++) {
|
|
514
565
|
const current = queue[position];
|
|
515
|
-
for (const next of
|
|
516
|
-
if (next === current &&
|
|
566
|
+
for (const next of getNodeSuccessors(behavior, current)) {
|
|
567
|
+
if (next === current && behavior.solution.tableau) continue;
|
|
517
568
|
if (next === target) {
|
|
518
569
|
const path = [target];
|
|
519
570
|
for (let node = current; node !== -1; node = parents.get(node) ?? -1) path.push(node);
|
|
520
571
|
return path;
|
|
521
572
|
}
|
|
522
|
-
if (!isWritten(
|
|
573
|
+
if (!isWritten(behavior, next) || parents.has(next)) continue;
|
|
523
574
|
parents.set(next, current);
|
|
524
575
|
queue.push(next);
|
|
525
576
|
}
|
|
@@ -528,24 +579,27 @@ export const createLivenessChecker = (
|
|
|
528
579
|
};
|
|
529
580
|
|
|
530
581
|
// TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
|
|
531
|
-
const
|
|
532
|
-
|
|
582
|
+
const findLassoInModel = (
|
|
583
|
+
behavior: BehaviorGraph,
|
|
584
|
+
model: Solution["models"][number],
|
|
585
|
+
): Lasso | undefined => {
|
|
586
|
+
const solution = behavior.solution;
|
|
533
587
|
const actionCount = solution.actionChecks.length;
|
|
534
588
|
const getAction = (node: number, edge: number, position: number) =>
|
|
535
|
-
|
|
589
|
+
behavior.edgeActions.data[(behavior.edgeStarts[node] + edge) * actionCount + position] === 1;
|
|
536
590
|
const isAllowed = (node: number, edge: number) =>
|
|
537
591
|
model.eventuallyAlways.every((position) => getAction(node, edge, position));
|
|
538
|
-
const links = new Float64Array(
|
|
539
|
-
const queue =
|
|
592
|
+
const links = new Float64Array(behavior.nodeStates.length).fill(UNVISITED);
|
|
593
|
+
const queue = behavior.initial.filter((node) => isWritten(behavior, node));
|
|
540
594
|
const components: number[] = [];
|
|
541
595
|
|
|
542
596
|
const isStuttering = (node: number) => {
|
|
543
|
-
const edge =
|
|
597
|
+
const edge = getNodeSuccessors(behavior, node).indexOf(node);
|
|
544
598
|
return edge !== -1 && isAllowed(node, edge);
|
|
545
599
|
};
|
|
546
600
|
const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
|
|
547
601
|
solution.tableau !== undefined &&
|
|
548
|
-
isFulfilling(solution.tableau.nodes[
|
|
602
|
+
isFulfilling(solution.tableau.nodes[behavior.nodeTableaux[node]].particle, promise);
|
|
549
603
|
|
|
550
604
|
const checkComponent = (root: number) => {
|
|
551
605
|
const top = components.pop() ?? root;
|
|
@@ -557,18 +611,18 @@ export const createLivenessChecker = (
|
|
|
557
611
|
const membersByState = new Map<number, number[]>();
|
|
558
612
|
for (let member = top; ; member = components.pop() ?? root) {
|
|
559
613
|
members.add(member);
|
|
560
|
-
const siblings = membersByState.get(
|
|
614
|
+
const siblings = membersByState.get(behavior.nodeStates[member]);
|
|
561
615
|
if (siblings) siblings.push(member);
|
|
562
|
-
else membersByState.set(
|
|
616
|
+
else membersByState.set(behavior.nodeStates[member], [member]);
|
|
563
617
|
links[member] = MAXIMUM_LINK;
|
|
564
618
|
if (member === root) break;
|
|
565
619
|
}
|
|
566
620
|
const isStateSatisfied = model.infinitelyOftenStates.every((position) =>
|
|
567
|
-
[...members].some((node) => getStateResult(
|
|
621
|
+
[...members].some((node) => getStateResult(behavior, node, position)),
|
|
568
622
|
);
|
|
569
623
|
const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
|
|
570
624
|
[...members].some((node) =>
|
|
571
|
-
|
|
625
|
+
getNodeSuccessors(behavior, node).some(
|
|
572
626
|
(next, edge) =>
|
|
573
627
|
members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
|
|
574
628
|
),
|
|
@@ -589,9 +643,9 @@ export const createLivenessChecker = (
|
|
|
589
643
|
membersByState: Map<number, number[]>,
|
|
590
644
|
) => {
|
|
591
645
|
const prefix = removeRepeats(
|
|
592
|
-
getPath(
|
|
646
|
+
getPath(behavior, root)
|
|
593
647
|
.reverse()
|
|
594
|
-
.map((node) =>
|
|
648
|
+
.map((node) => behavior.nodeStates[node]),
|
|
595
649
|
);
|
|
596
650
|
const cycleStack: number[] = [];
|
|
597
651
|
const seen = new Set<number>([root]);
|
|
@@ -601,7 +655,7 @@ export const createLivenessChecker = (
|
|
|
601
655
|
const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
|
|
602
656
|
const current = { node: root };
|
|
603
657
|
const isMember = (node: number) => members.has(node);
|
|
604
|
-
const
|
|
658
|
+
const moveTo = (next: number) => {
|
|
605
659
|
cycleStack.push(current.node);
|
|
606
660
|
current.node = next;
|
|
607
661
|
};
|
|
@@ -609,7 +663,7 @@ export const createLivenessChecker = (
|
|
|
609
663
|
const countAtStart = remaining.count;
|
|
610
664
|
while (true) {
|
|
611
665
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
612
|
-
if (!stateDone[slot] && getStateResult(
|
|
666
|
+
if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
|
|
613
667
|
stateDone[slot] = true;
|
|
614
668
|
remaining.count--;
|
|
615
669
|
}
|
|
@@ -623,8 +677,8 @@ export const createLivenessChecker = (
|
|
|
623
677
|
if (remaining.count <= 0) break;
|
|
624
678
|
const step = { last: -1, unvisited: -1 };
|
|
625
679
|
const countBeforeActions = remaining.count;
|
|
626
|
-
const taken =
|
|
627
|
-
if (membersByState.has(
|
|
680
|
+
const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
|
|
681
|
+
if (membersByState.has(behavior.nodeStates[next])) {
|
|
628
682
|
if (!isMember(next) || !isAllowed(current.node, edge)) return false;
|
|
629
683
|
step.last = next;
|
|
630
684
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
@@ -635,7 +689,7 @@ export const createLivenessChecker = (
|
|
|
635
689
|
});
|
|
636
690
|
}
|
|
637
691
|
if (remaining.count < countBeforeActions) {
|
|
638
|
-
|
|
692
|
+
moveTo(next);
|
|
639
693
|
seen.clear();
|
|
640
694
|
return true;
|
|
641
695
|
}
|
|
@@ -644,7 +698,7 @@ export const createLivenessChecker = (
|
|
|
644
698
|
});
|
|
645
699
|
if (taken) break;
|
|
646
700
|
if (remaining.count < countAtStart) {
|
|
647
|
-
|
|
701
|
+
moveTo(step.last);
|
|
648
702
|
seen.clear();
|
|
649
703
|
break;
|
|
650
704
|
}
|
|
@@ -657,16 +711,17 @@ export const createLivenessChecker = (
|
|
|
657
711
|
}
|
|
658
712
|
current.node = previous;
|
|
659
713
|
step.unvisited =
|
|
660
|
-
|
|
661
|
-
|
|
714
|
+
getNodeSuccessors(behavior, previous).find(
|
|
715
|
+
(next) => isMember(next) && !seen.has(next),
|
|
716
|
+
) ?? -1;
|
|
662
717
|
}
|
|
663
|
-
|
|
718
|
+
moveTo(step.unvisited);
|
|
664
719
|
seen.add(step.unvisited);
|
|
665
720
|
}
|
|
666
721
|
}
|
|
667
722
|
const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
|
|
668
723
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
669
|
-
const state =
|
|
724
|
+
const state = behavior.nodeStates[cycleStack[position]];
|
|
670
725
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
671
726
|
}
|
|
672
727
|
const cycleState = prefix[prefix.length - 1];
|
|
@@ -686,13 +741,13 @@ export const createLivenessChecker = (
|
|
|
686
741
|
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
687
742
|
) => {
|
|
688
743
|
if (end === root) return [];
|
|
689
|
-
const start =
|
|
744
|
+
const start = behavior.nodeStates[end];
|
|
690
745
|
const parents = new Map<number, number>();
|
|
691
746
|
const seen = new Set<number>([start]);
|
|
692
747
|
const queue: [number, number][] = [];
|
|
693
748
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
694
749
|
for (const node of membersByState.get(state) ?? []) {
|
|
695
|
-
for (const [edge, next] of
|
|
750
|
+
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
696
751
|
if (next === node || !isAllowedEdge(node, edge)) continue;
|
|
697
752
|
if (next === root) {
|
|
698
753
|
const path: number[] = [];
|
|
@@ -704,7 +759,7 @@ export const createLivenessChecker = (
|
|
|
704
759
|
path.push(start);
|
|
705
760
|
return path;
|
|
706
761
|
}
|
|
707
|
-
const nextState =
|
|
762
|
+
const nextState = behavior.nodeStates[next];
|
|
708
763
|
if (!membersByState.has(nextState) || seen.has(nextState)) continue;
|
|
709
764
|
seen.add(nextState);
|
|
710
765
|
queue.push([nextState, state]);
|
|
@@ -745,8 +800,8 @@ export const createLivenessChecker = (
|
|
|
745
800
|
stack.push(lowLink, node, SCC_MARKER);
|
|
746
801
|
components.push(node);
|
|
747
802
|
const nextLowLink = { value: counter.link++ };
|
|
748
|
-
|
|
749
|
-
if (!isWritten(
|
|
803
|
+
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
804
|
+
if (!isWritten(behavior, next)) return;
|
|
750
805
|
if (!isAllowed(node, edge)) {
|
|
751
806
|
if (links[next] === UNVISITED) queue.push(next);
|
|
752
807
|
return;
|
|
@@ -761,21 +816,23 @@ export const createLivenessChecker = (
|
|
|
761
816
|
};
|
|
762
817
|
|
|
763
818
|
return {
|
|
764
|
-
branches:
|
|
819
|
+
branches: behaviors.length,
|
|
765
820
|
addInitialState: (index, state, tracing) => {
|
|
766
821
|
evaluation.environment = tracing ?? environment;
|
|
767
822
|
shared.states.clear();
|
|
768
823
|
shared.actions.clear();
|
|
769
824
|
try {
|
|
770
|
-
for (const
|
|
771
|
-
const tableau =
|
|
825
|
+
for (const behavior of behaviors) {
|
|
826
|
+
const tableau = behavior.solution.tableau;
|
|
772
827
|
if (!tableau) {
|
|
773
|
-
|
|
828
|
+
behavior.initial.push(index);
|
|
774
829
|
continue;
|
|
775
830
|
}
|
|
776
831
|
for (let node = 0; node < tableau.initialCount; node++) {
|
|
777
832
|
if (!isConsistent(tableau, node, undefined, state)) continue;
|
|
778
|
-
|
|
833
|
+
behavior.initial.push(
|
|
834
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
835
|
+
);
|
|
779
836
|
}
|
|
780
837
|
}
|
|
781
838
|
} finally {
|
|
@@ -788,15 +845,24 @@ export const createLivenessChecker = (
|
|
|
788
845
|
shared.actions.clear();
|
|
789
846
|
try {
|
|
790
847
|
const set = getSuccessorSet(index, state, successors);
|
|
791
|
-
for (const
|
|
848
|
+
for (const behavior of behaviors) {
|
|
792
849
|
const actionResults = set.map((successor) =>
|
|
793
|
-
checkAction(
|
|
850
|
+
checkAction(behavior, index, state, successor.state),
|
|
851
|
+
);
|
|
852
|
+
const stateResults = checkState(behavior, index, state);
|
|
853
|
+
const tableau = behavior.solution.tableau;
|
|
854
|
+
if (!tableau) {
|
|
855
|
+
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
856
|
+
continue;
|
|
857
|
+
}
|
|
858
|
+
const accepted = addTableauState(
|
|
859
|
+
behavior,
|
|
860
|
+
tableau,
|
|
861
|
+
set,
|
|
862
|
+
actionResults,
|
|
863
|
+
stateResults,
|
|
864
|
+
index,
|
|
794
865
|
);
|
|
795
|
-
const stateResults = checkState(check, index, state);
|
|
796
|
-
const tableau = check.solution.tableau;
|
|
797
|
-
const accepted = tableau
|
|
798
|
-
? addTableauState(check, tableau, set, actionResults, stateResults, index)
|
|
799
|
-
: addPlainState(check, set, actionResults, stateResults, index);
|
|
800
866
|
if (accepted) return accepted;
|
|
801
867
|
}
|
|
802
868
|
return undefined;
|
|
@@ -805,9 +871,9 @@ export const createLivenessChecker = (
|
|
|
805
871
|
}
|
|
806
872
|
},
|
|
807
873
|
findViolation: () => {
|
|
808
|
-
for (const
|
|
809
|
-
for (const model of
|
|
810
|
-
const lasso =
|
|
874
|
+
for (const behavior of behaviors) {
|
|
875
|
+
for (const model of behavior.solution.models) {
|
|
876
|
+
const lasso = findLassoInModel(behavior, model);
|
|
811
877
|
if (lasso) return lasso;
|
|
812
878
|
}
|
|
813
879
|
}
|