tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.22c041b
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 +77 -122
- 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 +44 -12
- package/dist/index.d.ts +44 -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 +17 -15
- 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 +135 -120
- 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} +169 -142
- 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 +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 +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 +16 -20
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +38 -22
- 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 +119 -71
- 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,7 +79,7 @@ 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[];
|
|
@@ -165,35 +165,35 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
165
165
|
|
|
166
166
|
const UNWRITTEN = -1;
|
|
167
167
|
|
|
168
|
-
const isWritten = (
|
|
169
|
-
(
|
|
168
|
+
const isWritten = (behavior: BehaviorGraph, node: number) =>
|
|
169
|
+
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
170
170
|
|
|
171
|
-
const
|
|
172
|
-
const start =
|
|
173
|
-
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]);
|
|
174
174
|
};
|
|
175
175
|
|
|
176
|
-
const getStateResult = (
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
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;
|
|
188
189
|
};
|
|
189
190
|
|
|
190
|
-
|
|
191
|
-
const getStateNodes = (check: Check, state: number) => {
|
|
191
|
+
const getStateNodes = (behavior: BehaviorGraph, state: number) => {
|
|
192
192
|
const nodes: number[] = [];
|
|
193
193
|
for (
|
|
194
|
-
let node =
|
|
194
|
+
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
195
195
|
node !== NO_NODE;
|
|
196
|
-
node =
|
|
196
|
+
node = behavior.nextSiblings[node]
|
|
197
197
|
) {
|
|
198
198
|
nodes.push(node);
|
|
199
199
|
}
|
|
@@ -212,7 +212,7 @@ export const createLivenessChecker = (
|
|
|
212
212
|
properties: TemporalProperty[],
|
|
213
213
|
temporals: ScopedExpression[],
|
|
214
214
|
environment: Environment,
|
|
215
|
-
|
|
215
|
+
search: SearchGraph,
|
|
216
216
|
): LivenessChecker | undefined => {
|
|
217
217
|
if (properties.length === 0) return undefined;
|
|
218
218
|
const fairness = temporals.map((item) =>
|
|
@@ -229,7 +229,7 @@ export const createLivenessChecker = (
|
|
|
229
229
|
throw createTautologyError();
|
|
230
230
|
}
|
|
231
231
|
const actionIds = new Map<string, number>();
|
|
232
|
-
const
|
|
232
|
+
const behaviors = solutions.map((solution): BehaviorGraph => ({
|
|
233
233
|
solution,
|
|
234
234
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
235
235
|
const key = getTermKey(predicate);
|
|
@@ -282,15 +282,20 @@ export const createLivenessChecker = (
|
|
|
282
282
|
evaluation.environment,
|
|
283
283
|
isShared ? getStateCache(state) : new Map(),
|
|
284
284
|
);
|
|
285
|
-
const checkState = (
|
|
285
|
+
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
286
286
|
evaluateFrom(source, () =>
|
|
287
|
-
Uint8Array.from(
|
|
287
|
+
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
288
288
|
evaluateState(predicate, state) ? 1 : 0,
|
|
289
289
|
),
|
|
290
290
|
);
|
|
291
|
-
const checkAction = (
|
|
291
|
+
const checkAction = (
|
|
292
|
+
behavior: BehaviorGraph,
|
|
293
|
+
source: number,
|
|
294
|
+
state: Value[],
|
|
295
|
+
successor: Value[],
|
|
296
|
+
) =>
|
|
292
297
|
evaluateFrom(source, () => {
|
|
293
|
-
const predicates =
|
|
298
|
+
const predicates = behavior.solution.actionChecks;
|
|
294
299
|
if (!isShared) {
|
|
295
300
|
return Uint8Array.from(predicates, (predicate) =>
|
|
296
301
|
evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
|
|
@@ -301,7 +306,7 @@ export const createLivenessChecker = (
|
|
|
301
306
|
shared.actions.set(state, results);
|
|
302
307
|
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
303
308
|
results.set(successor, known);
|
|
304
|
-
return Uint8Array.from(
|
|
309
|
+
return Uint8Array.from(behavior.actionIds, (id, position) => {
|
|
305
310
|
if (known[id] === -1) {
|
|
306
311
|
known[id] = evaluateLive(
|
|
307
312
|
predicates[position],
|
|
@@ -336,23 +341,23 @@ export const createLivenessChecker = (
|
|
|
336
341
|
tableauNode.successors[0] === node
|
|
337
342
|
);
|
|
338
343
|
};
|
|
339
|
-
const hasEmptyModel = (
|
|
340
|
-
|
|
344
|
+
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
345
|
+
behavior.solution.models.some(
|
|
341
346
|
(model) =>
|
|
342
347
|
model.eventuallyAlways.length === 0 &&
|
|
343
348
|
model.infinitelyOftenStates.length === 0 &&
|
|
344
349
|
model.infinitelyOftenActions.length === 0,
|
|
345
350
|
);
|
|
346
351
|
|
|
347
|
-
const getNodeId = (
|
|
348
|
-
if (!
|
|
349
|
-
const slots =
|
|
350
|
-
const slot = getNodeSlot(
|
|
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);
|
|
351
356
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
352
357
|
};
|
|
353
|
-
const recordNode = (
|
|
354
|
-
const node = pushNode(
|
|
355
|
-
const table =
|
|
358
|
+
const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
359
|
+
const node = pushNode(behavior, state, tableauNode);
|
|
360
|
+
const table = behavior.nodeIds;
|
|
356
361
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
357
362
|
const old = table.slots;
|
|
358
363
|
table.slots = new Int32Array(old.length * 2);
|
|
@@ -367,28 +372,32 @@ export const createLivenessChecker = (
|
|
|
367
372
|
}
|
|
368
373
|
}
|
|
369
374
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
370
|
-
const last =
|
|
371
|
-
if (last === NO_NODE) writeToPool(
|
|
372
|
-
else
|
|
373
|
-
writeToPool(
|
|
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]);
|
|
374
379
|
return node;
|
|
375
380
|
};
|
|
376
381
|
const writeNode = (
|
|
377
|
-
|
|
382
|
+
behavior: BehaviorGraph,
|
|
378
383
|
node: number,
|
|
379
384
|
targets: number[],
|
|
380
385
|
actions: Uint8Array[],
|
|
381
386
|
stateResults: Uint8Array,
|
|
382
387
|
) => {
|
|
383
|
-
const start =
|
|
384
|
-
const actionCount =
|
|
385
|
-
writeToPool(
|
|
388
|
+
const start = behavior.edgeTargets.length;
|
|
389
|
+
const actionCount = behavior.solution.actionChecks.length;
|
|
390
|
+
writeToPool(behavior.edgeTargets, start, targets);
|
|
386
391
|
actions.forEach((results, position) =>
|
|
387
|
-
writeToPool(
|
|
392
|
+
writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
|
|
393
|
+
);
|
|
394
|
+
writeToPool(
|
|
395
|
+
behavior.stateResults,
|
|
396
|
+
behavior.nodeStates[node] * stateResults.length,
|
|
397
|
+
stateResults,
|
|
388
398
|
);
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
check.edgeCounts[node] = targets.length;
|
|
399
|
+
behavior.edgeStarts[node] = start;
|
|
400
|
+
behavior.edgeCounts[node] = targets.length;
|
|
392
401
|
};
|
|
393
402
|
|
|
394
403
|
// TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
|
|
@@ -401,9 +410,9 @@ export const createLivenessChecker = (
|
|
|
401
410
|
}),
|
|
402
411
|
count: 0,
|
|
403
412
|
};
|
|
404
|
-
const
|
|
413
|
+
const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
|
|
405
414
|
for (
|
|
406
|
-
let slot = (
|
|
415
|
+
let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
|
|
407
416
|
;
|
|
408
417
|
slot = (slot + 1) % slots.length
|
|
409
418
|
) {
|
|
@@ -416,72 +425,76 @@ export const createLivenessChecker = (
|
|
|
416
425
|
return false;
|
|
417
426
|
}
|
|
418
427
|
};
|
|
419
|
-
const
|
|
428
|
+
const addSuccessor = (successor: LiveSuccessor) => {
|
|
420
429
|
if (table.count >= table.slots.length >> 1) {
|
|
421
430
|
const old = table.slots;
|
|
422
431
|
table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
|
|
423
|
-
for (const entry of old) if (entry)
|
|
432
|
+
for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
|
|
424
433
|
}
|
|
425
|
-
if (
|
|
434
|
+
if (insertSuccessor(table.slots, successor)) table.count++;
|
|
426
435
|
};
|
|
427
|
-
successors.forEach(
|
|
428
|
-
|
|
436
|
+
successors.forEach(addSuccessor);
|
|
437
|
+
addSuccessor({ index, state });
|
|
429
438
|
if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
|
|
430
439
|
return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
|
|
431
440
|
};
|
|
432
441
|
|
|
433
442
|
// TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
|
|
434
443
|
const expandLate = (
|
|
435
|
-
|
|
444
|
+
behavior: BehaviorGraph,
|
|
436
445
|
tableau: Tableau,
|
|
437
446
|
state: Value[],
|
|
438
447
|
index: number,
|
|
439
448
|
node: number,
|
|
440
449
|
) => {
|
|
441
|
-
const stateResults = checkState(
|
|
442
|
-
const tableauNode = tableau.nodes[
|
|
450
|
+
const stateResults = checkState(behavior, index, state);
|
|
451
|
+
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
443
452
|
const actions: Uint8Array[] = [];
|
|
444
453
|
const successors: number[] = [];
|
|
445
454
|
const selfActions =
|
|
446
455
|
tableauNode.successors.length > 0
|
|
447
|
-
? checkAction(
|
|
456
|
+
? checkAction(behavior, index, state, state)
|
|
448
457
|
: new Uint8Array(0);
|
|
449
458
|
for (const next of tableauNode.successors) {
|
|
450
459
|
if (!isConsistent(tableau, next, index, state)) continue;
|
|
451
|
-
if (
|
|
452
|
-
|
|
460
|
+
if (
|
|
461
|
+
isAccepting(tableau, next) &&
|
|
462
|
+
behavior.errorNode === undefined &&
|
|
463
|
+
hasEmptyModel(behavior)
|
|
464
|
+
) {
|
|
465
|
+
behavior.errorNode = node;
|
|
453
466
|
return;
|
|
454
467
|
}
|
|
455
|
-
const existing = getNodeId(
|
|
468
|
+
const existing = getNodeId(behavior, index, next);
|
|
456
469
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
457
|
-
const target = existing ?? recordNode(
|
|
470
|
+
const target = existing ?? recordNode(behavior, index, next);
|
|
458
471
|
successors.push(target);
|
|
459
472
|
actions.push(selfActions);
|
|
460
|
-
if (existing === undefined) expandLate(
|
|
473
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
461
474
|
}
|
|
462
|
-
for (const successor of
|
|
463
|
-
const successorActions = checkAction(
|
|
464
|
-
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;
|
|
465
478
|
for (const next of tableauNode.successors) {
|
|
466
479
|
if (!isConsistent(tableau, next, index, successor.state)) continue;
|
|
467
480
|
// A successor the search never stored follows a violation or an error, after which nothing
|
|
468
481
|
// checks the graph. TLC records its node, which it never expands.
|
|
469
482
|
if (successor.index === -1) continue;
|
|
470
|
-
const existing = getNodeId(
|
|
483
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
471
484
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
472
|
-
const target = existing ?? recordNode(
|
|
485
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
473
486
|
successors.push(target);
|
|
474
487
|
actions.push(successorActions);
|
|
475
488
|
if (existing === undefined && isDone) {
|
|
476
|
-
expandLate(
|
|
489
|
+
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
477
490
|
}
|
|
478
491
|
}
|
|
479
492
|
}
|
|
480
|
-
if (successors.length > 0) writeNode(
|
|
493
|
+
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
481
494
|
};
|
|
482
495
|
|
|
483
496
|
const addTableauState = (
|
|
484
|
-
|
|
497
|
+
behavior: BehaviorGraph,
|
|
485
498
|
tableau: Tableau,
|
|
486
499
|
set: LiveSuccessor[],
|
|
487
500
|
actionResults: Uint8Array[],
|
|
@@ -491,74 +504,73 @@ export const createLivenessChecker = (
|
|
|
491
504
|
const consistency = tableau.nodes.map((_, node) =>
|
|
492
505
|
set.map((successor) => isConsistent(tableau, node, index, successor.state)),
|
|
493
506
|
);
|
|
494
|
-
|
|
507
|
+
behavior.isDone[index] = true;
|
|
495
508
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
496
|
-
for (const node of getStateNodes(
|
|
509
|
+
for (const node of getStateNodes(behavior, index)) {
|
|
497
510
|
const successors: number[] = [];
|
|
498
511
|
const actions: Uint8Array[] = [];
|
|
499
512
|
set.forEach((successor, position) => {
|
|
500
|
-
const isDone =
|
|
501
|
-
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) {
|
|
502
515
|
if (!consistency[next][position]) continue;
|
|
503
|
-
const existing = getNodeId(
|
|
516
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
504
517
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
505
|
-
const target = existing ?? recordNode(
|
|
518
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
506
519
|
successors.push(target);
|
|
507
520
|
actions.push(actionResults[position]);
|
|
508
521
|
if (existing === undefined && isDone) {
|
|
509
|
-
expandLate(
|
|
522
|
+
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
510
523
|
}
|
|
511
524
|
}
|
|
512
525
|
});
|
|
513
|
-
writeNode(
|
|
526
|
+
writeNode(behavior, node, successors, actions, stateResults);
|
|
514
527
|
}
|
|
515
|
-
if (
|
|
528
|
+
if (behavior.errorNode === undefined) return undefined;
|
|
516
529
|
return removeRepeats(
|
|
517
|
-
getPath(
|
|
530
|
+
getPath(behavior, behavior.errorNode)
|
|
518
531
|
.reverse()
|
|
519
|
-
.map((node) =>
|
|
532
|
+
.map((node) => behavior.nodeStates[node]),
|
|
520
533
|
);
|
|
521
534
|
};
|
|
522
535
|
|
|
523
536
|
const addPlainState = (
|
|
524
|
-
|
|
537
|
+
behavior: BehaviorGraph,
|
|
525
538
|
set: LiveSuccessor[],
|
|
526
539
|
actionResults: Uint8Array[],
|
|
527
540
|
stateResults: Uint8Array,
|
|
528
541
|
index: number,
|
|
529
542
|
) => {
|
|
530
|
-
while (
|
|
543
|
+
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
531
544
|
const successors: number[] = [];
|
|
532
545
|
const actions: Uint8Array[] = [];
|
|
533
546
|
set.forEach((successor, position) => {
|
|
534
|
-
if (isWritten(
|
|
547
|
+
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
535
548
|
successors.push(successor.index);
|
|
536
549
|
actions.push(actionResults[position]);
|
|
537
550
|
});
|
|
538
|
-
writeNode(
|
|
539
|
-
return undefined;
|
|
551
|
+
writeNode(behavior, index, successors, actions, stateResults);
|
|
540
552
|
};
|
|
541
553
|
|
|
542
554
|
// The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
|
|
543
|
-
const getPath = (
|
|
544
|
-
if (
|
|
555
|
+
const getPath = (behavior: BehaviorGraph, target: number) => {
|
|
556
|
+
if (behavior.initial.includes(target)) return [target];
|
|
545
557
|
const parents = new Map<number, number>();
|
|
546
558
|
const queue: number[] = [];
|
|
547
|
-
for (const node of
|
|
548
|
-
if (!isWritten(
|
|
559
|
+
for (const node of behavior.initial) {
|
|
560
|
+
if (!isWritten(behavior, node)) continue;
|
|
549
561
|
queue.push(node);
|
|
550
562
|
parents.set(node, -1);
|
|
551
563
|
}
|
|
552
564
|
for (let position = 0; position < queue.length; position++) {
|
|
553
565
|
const current = queue[position];
|
|
554
|
-
for (const next of
|
|
555
|
-
if (next === current &&
|
|
566
|
+
for (const next of getNodeSuccessors(behavior, current)) {
|
|
567
|
+
if (next === current && behavior.solution.tableau) continue;
|
|
556
568
|
if (next === target) {
|
|
557
569
|
const path = [target];
|
|
558
570
|
for (let node = current; node !== -1; node = parents.get(node) ?? -1) path.push(node);
|
|
559
571
|
return path;
|
|
560
572
|
}
|
|
561
|
-
if (!isWritten(
|
|
573
|
+
if (!isWritten(behavior, next) || parents.has(next)) continue;
|
|
562
574
|
parents.set(next, current);
|
|
563
575
|
queue.push(next);
|
|
564
576
|
}
|
|
@@ -567,24 +579,27 @@ export const createLivenessChecker = (
|
|
|
567
579
|
};
|
|
568
580
|
|
|
569
581
|
// TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
|
|
570
|
-
const
|
|
571
|
-
|
|
582
|
+
const findLassoInModel = (
|
|
583
|
+
behavior: BehaviorGraph,
|
|
584
|
+
model: Solution["models"][number],
|
|
585
|
+
): Lasso | undefined => {
|
|
586
|
+
const solution = behavior.solution;
|
|
572
587
|
const actionCount = solution.actionChecks.length;
|
|
573
588
|
const getAction = (node: number, edge: number, position: number) =>
|
|
574
|
-
|
|
589
|
+
behavior.edgeActions.data[(behavior.edgeStarts[node] + edge) * actionCount + position] === 1;
|
|
575
590
|
const isAllowed = (node: number, edge: number) =>
|
|
576
591
|
model.eventuallyAlways.every((position) => getAction(node, edge, position));
|
|
577
|
-
const links = new Float64Array(
|
|
578
|
-
const queue =
|
|
592
|
+
const links = new Float64Array(behavior.nodeStates.length).fill(UNVISITED);
|
|
593
|
+
const queue = behavior.initial.filter((node) => isWritten(behavior, node));
|
|
579
594
|
const components: number[] = [];
|
|
580
595
|
|
|
581
596
|
const isStuttering = (node: number) => {
|
|
582
|
-
const edge =
|
|
597
|
+
const edge = getNodeSuccessors(behavior, node).indexOf(node);
|
|
583
598
|
return edge !== -1 && isAllowed(node, edge);
|
|
584
599
|
};
|
|
585
600
|
const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
|
|
586
601
|
solution.tableau !== undefined &&
|
|
587
|
-
isFulfilling(solution.tableau.nodes[
|
|
602
|
+
isFulfilling(solution.tableau.nodes[behavior.nodeTableaux[node]].particle, promise);
|
|
588
603
|
|
|
589
604
|
const checkComponent = (root: number) => {
|
|
590
605
|
const top = components.pop() ?? root;
|
|
@@ -596,18 +611,18 @@ export const createLivenessChecker = (
|
|
|
596
611
|
const membersByState = new Map<number, number[]>();
|
|
597
612
|
for (let member = top; ; member = components.pop() ?? root) {
|
|
598
613
|
members.add(member);
|
|
599
|
-
const siblings = membersByState.get(
|
|
614
|
+
const siblings = membersByState.get(behavior.nodeStates[member]);
|
|
600
615
|
if (siblings) siblings.push(member);
|
|
601
|
-
else membersByState.set(
|
|
616
|
+
else membersByState.set(behavior.nodeStates[member], [member]);
|
|
602
617
|
links[member] = MAXIMUM_LINK;
|
|
603
618
|
if (member === root) break;
|
|
604
619
|
}
|
|
605
620
|
const isStateSatisfied = model.infinitelyOftenStates.every((position) =>
|
|
606
|
-
[...members].some((node) => getStateResult(
|
|
621
|
+
[...members].some((node) => getStateResult(behavior, node, position)),
|
|
607
622
|
);
|
|
608
623
|
const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
|
|
609
624
|
[...members].some((node) =>
|
|
610
|
-
|
|
625
|
+
getNodeSuccessors(behavior, node).some(
|
|
611
626
|
(next, edge) =>
|
|
612
627
|
members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
|
|
613
628
|
),
|
|
@@ -628,9 +643,9 @@ export const createLivenessChecker = (
|
|
|
628
643
|
membersByState: Map<number, number[]>,
|
|
629
644
|
) => {
|
|
630
645
|
const prefix = removeRepeats(
|
|
631
|
-
getPath(
|
|
646
|
+
getPath(behavior, root)
|
|
632
647
|
.reverse()
|
|
633
|
-
.map((node) =>
|
|
648
|
+
.map((node) => behavior.nodeStates[node]),
|
|
634
649
|
);
|
|
635
650
|
const cycleStack: number[] = [];
|
|
636
651
|
const seen = new Set<number>([root]);
|
|
@@ -640,7 +655,7 @@ export const createLivenessChecker = (
|
|
|
640
655
|
const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
|
|
641
656
|
const current = { node: root };
|
|
642
657
|
const isMember = (node: number) => members.has(node);
|
|
643
|
-
const
|
|
658
|
+
const moveTo = (next: number) => {
|
|
644
659
|
cycleStack.push(current.node);
|
|
645
660
|
current.node = next;
|
|
646
661
|
};
|
|
@@ -648,7 +663,7 @@ export const createLivenessChecker = (
|
|
|
648
663
|
const countAtStart = remaining.count;
|
|
649
664
|
while (true) {
|
|
650
665
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
651
|
-
if (!stateDone[slot] && getStateResult(
|
|
666
|
+
if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
|
|
652
667
|
stateDone[slot] = true;
|
|
653
668
|
remaining.count--;
|
|
654
669
|
}
|
|
@@ -662,8 +677,8 @@ export const createLivenessChecker = (
|
|
|
662
677
|
if (remaining.count <= 0) break;
|
|
663
678
|
const step = { last: -1, unvisited: -1 };
|
|
664
679
|
const countBeforeActions = remaining.count;
|
|
665
|
-
const taken =
|
|
666
|
-
if (membersByState.has(
|
|
680
|
+
const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
|
|
681
|
+
if (membersByState.has(behavior.nodeStates[next])) {
|
|
667
682
|
if (!isMember(next) || !isAllowed(current.node, edge)) return false;
|
|
668
683
|
step.last = next;
|
|
669
684
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
@@ -674,7 +689,7 @@ export const createLivenessChecker = (
|
|
|
674
689
|
});
|
|
675
690
|
}
|
|
676
691
|
if (remaining.count < countBeforeActions) {
|
|
677
|
-
|
|
692
|
+
moveTo(next);
|
|
678
693
|
seen.clear();
|
|
679
694
|
return true;
|
|
680
695
|
}
|
|
@@ -683,7 +698,7 @@ export const createLivenessChecker = (
|
|
|
683
698
|
});
|
|
684
699
|
if (taken) break;
|
|
685
700
|
if (remaining.count < countAtStart) {
|
|
686
|
-
|
|
701
|
+
moveTo(step.last);
|
|
687
702
|
seen.clear();
|
|
688
703
|
break;
|
|
689
704
|
}
|
|
@@ -696,16 +711,17 @@ export const createLivenessChecker = (
|
|
|
696
711
|
}
|
|
697
712
|
current.node = previous;
|
|
698
713
|
step.unvisited =
|
|
699
|
-
|
|
700
|
-
|
|
714
|
+
getNodeSuccessors(behavior, previous).find(
|
|
715
|
+
(next) => isMember(next) && !seen.has(next),
|
|
716
|
+
) ?? -1;
|
|
701
717
|
}
|
|
702
|
-
|
|
718
|
+
moveTo(step.unvisited);
|
|
703
719
|
seen.add(step.unvisited);
|
|
704
720
|
}
|
|
705
721
|
}
|
|
706
722
|
const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
|
|
707
723
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
708
|
-
const state =
|
|
724
|
+
const state = behavior.nodeStates[cycleStack[position]];
|
|
709
725
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
710
726
|
}
|
|
711
727
|
const cycleState = prefix[prefix.length - 1];
|
|
@@ -725,13 +741,13 @@ export const createLivenessChecker = (
|
|
|
725
741
|
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
726
742
|
) => {
|
|
727
743
|
if (end === root) return [];
|
|
728
|
-
const start =
|
|
744
|
+
const start = behavior.nodeStates[end];
|
|
729
745
|
const parents = new Map<number, number>();
|
|
730
746
|
const seen = new Set<number>([start]);
|
|
731
747
|
const queue: [number, number][] = [];
|
|
732
748
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
733
749
|
for (const node of membersByState.get(state) ?? []) {
|
|
734
|
-
for (const [edge, next] of
|
|
750
|
+
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
735
751
|
if (next === node || !isAllowedEdge(node, edge)) continue;
|
|
736
752
|
if (next === root) {
|
|
737
753
|
const path: number[] = [];
|
|
@@ -743,7 +759,7 @@ export const createLivenessChecker = (
|
|
|
743
759
|
path.push(start);
|
|
744
760
|
return path;
|
|
745
761
|
}
|
|
746
|
-
const nextState =
|
|
762
|
+
const nextState = behavior.nodeStates[next];
|
|
747
763
|
if (!membersByState.has(nextState) || seen.has(nextState)) continue;
|
|
748
764
|
seen.add(nextState);
|
|
749
765
|
queue.push([nextState, state]);
|
|
@@ -784,8 +800,8 @@ export const createLivenessChecker = (
|
|
|
784
800
|
stack.push(lowLink, node, SCC_MARKER);
|
|
785
801
|
components.push(node);
|
|
786
802
|
const nextLowLink = { value: counter.link++ };
|
|
787
|
-
|
|
788
|
-
if (!isWritten(
|
|
803
|
+
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
804
|
+
if (!isWritten(behavior, next)) return;
|
|
789
805
|
if (!isAllowed(node, edge)) {
|
|
790
806
|
if (links[next] === UNVISITED) queue.push(next);
|
|
791
807
|
return;
|
|
@@ -800,21 +816,23 @@ export const createLivenessChecker = (
|
|
|
800
816
|
};
|
|
801
817
|
|
|
802
818
|
return {
|
|
803
|
-
branches:
|
|
819
|
+
branches: behaviors.length,
|
|
804
820
|
addInitialState: (index, state, tracing) => {
|
|
805
821
|
evaluation.environment = tracing ?? environment;
|
|
806
822
|
shared.states.clear();
|
|
807
823
|
shared.actions.clear();
|
|
808
824
|
try {
|
|
809
|
-
for (const
|
|
810
|
-
const tableau =
|
|
825
|
+
for (const behavior of behaviors) {
|
|
826
|
+
const tableau = behavior.solution.tableau;
|
|
811
827
|
if (!tableau) {
|
|
812
|
-
|
|
828
|
+
behavior.initial.push(index);
|
|
813
829
|
continue;
|
|
814
830
|
}
|
|
815
831
|
for (let node = 0; node < tableau.initialCount; node++) {
|
|
816
832
|
if (!isConsistent(tableau, node, undefined, state)) continue;
|
|
817
|
-
|
|
833
|
+
behavior.initial.push(
|
|
834
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
835
|
+
);
|
|
818
836
|
}
|
|
819
837
|
}
|
|
820
838
|
} finally {
|
|
@@ -827,15 +845,24 @@ export const createLivenessChecker = (
|
|
|
827
845
|
shared.actions.clear();
|
|
828
846
|
try {
|
|
829
847
|
const set = getSuccessorSet(index, state, successors);
|
|
830
|
-
for (const
|
|
848
|
+
for (const behavior of behaviors) {
|
|
831
849
|
const actionResults = set.map((successor) =>
|
|
832
|
-
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,
|
|
833
865
|
);
|
|
834
|
-
const stateResults = checkState(check, index, state);
|
|
835
|
-
const tableau = check.solution.tableau;
|
|
836
|
-
const accepted = tableau
|
|
837
|
-
? addTableauState(check, tableau, set, actionResults, stateResults, index)
|
|
838
|
-
: addPlainState(check, set, actionResults, stateResults, index);
|
|
839
866
|
if (accepted) return accepted;
|
|
840
867
|
}
|
|
841
868
|
return undefined;
|
|
@@ -844,9 +871,9 @@ export const createLivenessChecker = (
|
|
|
844
871
|
}
|
|
845
872
|
},
|
|
846
873
|
findViolation: () => {
|
|
847
|
-
for (const
|
|
848
|
-
for (const model of
|
|
849
|
-
const lasso =
|
|
874
|
+
for (const behavior of behaviors) {
|
|
875
|
+
for (const model of behavior.solution.models) {
|
|
876
|
+
const lasso = findLassoInModel(behavior, model);
|
|
850
877
|
if (lasso) return lasso;
|
|
851
878
|
}
|
|
852
879
|
}
|