tla-ts 0.0.9 → 0.0.10-dev.09e53c2a6
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 +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +109 -10
- package/dist/index.d.ts +109 -10
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +146 -31
- package/dist/run.js +146 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +132 -104
- package/dist/transfer.js +132 -104
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +3 -1
- package/src/ast.ts +45 -59
- package/src/bags.ts +99 -102
- package/src/builtins.ts +28 -75
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +797 -782
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +136 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +323 -658
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +196 -74
- package/src/config.ts +140 -109
- package/src/coverage.ts +830 -0
- package/src/dependencies.ts +36 -54
- package/src/dfid.ts +618 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +178 -339
- package/src/errors.ts +100 -57
- package/src/evaluate.ts +598 -340
- package/src/exit-codes.ts +38 -3
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +126 -21
- package/src/java-hash.ts +7 -0
- package/src/java-overrides.ts +4 -19
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +46 -58
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +590 -311
- package/src/liveness.ts +180 -124
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +38 -19
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +30 -37
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +89 -58
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +119 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +30 -60
- package/src/parallel.ts +59 -73
- package/src/parser.ts +1082 -399
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +224 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +0 -14
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +27 -52
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +31 -74
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +1 -44
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1026 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +615 -53
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +87 -58
- package/src/prover/smt/solver/ast-lt.ts +166 -22
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1424 -180
- package/src/prover/smt/solver/auf-solver.ts +7 -44
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +110 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +519 -175
- package/src/prover/smt/solver/ctx-simplify.ts +33 -50
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +39 -30
- package/src/prover/smt/solver/diff-neq.ts +206 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +545 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +907 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1050 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +335 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- package/src/prover/smt/solver/expr2polynomial.ts +146 -0
- package/src/prover/smt/solver/factor.ts +141 -0
- package/src/prover/smt/solver/fd-solver.ts +265 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -26
- package/src/prover/smt/solver/fix-dl-var.ts +148 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +640 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2249 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +176 -28
- package/src/prover/smt/solver/goal2nlsat.ts +189 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -9
- package/src/prover/smt/solver/hashtable.ts +26 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +112 -132
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +11 -30
- package/src/prover/smt/solver/lp/core-solver.ts +23 -29
- package/src/prover/smt/solver/lp/cross-nested.ts +5 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +69 -82
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +4 -28
- package/src/prover/smt/solver/lp/nex.ts +0 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +91 -135
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +22 -72
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +123 -112
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +0 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +1 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +2 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -62
- package/src/prover/smt/solver/model-evaluator.ts +190 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +56 -40
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +711 -0
- package/src/prover/smt/solver/mus.ts +51 -0
- package/src/prover/smt/solver/muz/dl-context.ts +404 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1406 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +218 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +177 -160
- package/src/prover/smt/solver/nlsat/atoms.ts +24 -24
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +65 -69
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +48 -135
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +29 -161
- package/src/prover/smt/solver/nlsat/solver.ts +241 -110
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +367 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -47
- package/src/prover/smt/solver/nlsat/upolynomial.ts +10 -93
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +107 -60
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +787 -0
- package/src/prover/smt/solver/opt-nlsat.ts +375 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +308 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +284 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +204 -79
- package/src/prover/smt/solver/probes.ts +512 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1098 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +39 -49
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1498 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -16
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +8 -23
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +261 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +52 -129
- package/src/prover/smt/solver/rewriter.ts +477 -120
- package/src/prover/smt/solver/rlimit.ts +39 -21
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +43 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2127 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +1010 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1301 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +728 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1170 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2402 -0
- package/src/prover/smt/solver/seq-skolem.ts +317 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +83 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3140 -365
- package/src/prover/smt/solver/smtlib-script.ts +1631 -0
- package/src/prover/smt/solver/solve-eqs.ts +929 -0
- package/src/prover/smt/solver/solver.ts +119 -39
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +1986 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +59 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +94 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -40
- package/src/prover/smt/solver/theory-lra-state.ts +6 -27
- package/src/prover/smt/solver/theory-lra.ts +188 -8
- package/src/prover/smt/solver/theory-pb.ts +934 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +871 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +67 -41
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +0 -6
- package/src/prover/zenon/expr.ts +8 -28
- package/src/prover/zenon/index-table.ts +26 -59
- package/src/prover/zenon/isar-case.ts +8 -20
- package/src/prover/zenon/isar.ts +35 -65
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +1 -13
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +2 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +67 -185
- package/src/runtime.ts +26 -22
- package/src/sany/builtins.ts +2 -5
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +191 -2764
- package/src/sany/levels.ts +5 -35
- package/src/sany/lexer.ts +58 -77
- package/src/sany/linter.ts +0 -10
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +5 -43
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +49 -76
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +35 -117
- package/src/search.ts +671 -169
- package/src/simulate.ts +712 -0
- package/src/spec-description.ts +192 -100
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +264 -95
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +267 -100
- package/src/symmetry.ts +35 -27
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- package/src/tlc/jar-data.ts +112 -6
- package/src/tlc/messages.ts +125 -54
- package/src/tlc/order.ts +39 -69
- package/src/tlc/random.ts +37 -49
- package/src/tlc/replay.ts +553 -228
- package/src/tlc/summary.ts +64 -60
- package/src/tlc/tlc-operators.ts +78 -44
- package/src/tlc/tlcext-operators.ts +171 -122
- package/src/tlc/trace-spec.ts +249 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/transfer.ts +22 -25
- package/src/typed-tier.ts +6535 -0
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +832 -484
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/liveness-checker.ts
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
import { TlaEvaluationError } from "./errors";
|
|
2
|
+
import { isExpressionImpure } from "./dependencies";
|
|
2
3
|
import { hasRepeatedEffects, type Environment } from "./evaluate";
|
|
3
4
|
import {
|
|
4
|
-
createTautologyError,
|
|
5
|
-
evaluateLive,
|
|
6
5
|
evaluateOnLasso,
|
|
6
|
+
getInterpretedAtoms,
|
|
7
7
|
toLiveExpression,
|
|
8
|
+
type LiveAtoms,
|
|
8
9
|
type ScopedExpression,
|
|
9
10
|
type TemporalProperty,
|
|
10
11
|
} from "./liveness";
|
|
@@ -14,30 +15,29 @@ import {
|
|
|
14
15
|
getSolutions,
|
|
15
16
|
getTermKey,
|
|
16
17
|
isFulfilling,
|
|
18
|
+
type LiveAction,
|
|
19
|
+
type LiveEnabled,
|
|
17
20
|
type LiveExpression,
|
|
21
|
+
type LiveState,
|
|
18
22
|
type Solution,
|
|
19
23
|
type Tableau,
|
|
20
24
|
} from "./tableau";
|
|
21
25
|
import { isSameValue, type Value } from "./values";
|
|
22
26
|
|
|
23
|
-
export interface LiveSuccessor {
|
|
27
|
+
export interface LiveSuccessor<State = Value[]> {
|
|
24
28
|
index: number;
|
|
25
|
-
state:
|
|
29
|
+
state: State;
|
|
26
30
|
}
|
|
27
31
|
|
|
28
32
|
export interface Lasso {
|
|
29
33
|
prefix: number[];
|
|
30
34
|
cycle: number[];
|
|
31
|
-
// Whether the solution that the lasso violates constrains the cycle, as a liveness property does.
|
|
32
|
-
// TLC warns that a stuttering counterexample to one may come from a missing fairness constraint.
|
|
33
35
|
isCycleConstrained: boolean;
|
|
34
36
|
}
|
|
35
37
|
|
|
36
38
|
export interface LivenessChecker {
|
|
37
|
-
// How many solutions of the negated properties TLC checks, which it calls branches.
|
|
38
39
|
branches: number;
|
|
39
|
-
|
|
40
|
-
// check does.
|
|
40
|
+
solutions: Solution[];
|
|
41
41
|
addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
|
|
42
42
|
addState: (
|
|
43
43
|
index: number,
|
|
@@ -49,37 +49,66 @@ export interface LivenessChecker {
|
|
|
49
49
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
50
50
|
}
|
|
51
51
|
|
|
52
|
-
interface
|
|
53
|
-
|
|
54
|
-
|
|
52
|
+
export interface LiveGraph<State> {
|
|
53
|
+
branches: number;
|
|
54
|
+
addInitialState: (index: number, state: State) => void;
|
|
55
|
+
// The path to an accepting node the state reaches, if any.
|
|
56
|
+
addState: (
|
|
57
|
+
index: number,
|
|
58
|
+
state: State,
|
|
59
|
+
successors: LiveSuccessor<State>[],
|
|
60
|
+
) => number[] | undefined;
|
|
61
|
+
findViolation: () => Lasso | undefined;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
export interface SearchGraph<State> {
|
|
65
|
+
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
66
|
+
getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
export interface LiveEvaluation<State> {
|
|
70
|
+
atoms: LiveAtoms<State>;
|
|
71
|
+
// Whether a check's result for a state holds for every step from it.
|
|
72
|
+
isShared: boolean;
|
|
73
|
+
isSame: (left: State, right: State) => boolean;
|
|
74
|
+
// Evaluates the checks of a state the search found from the state at source.
|
|
75
|
+
evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
|
|
55
76
|
}
|
|
56
77
|
|
|
57
|
-
// Numbers in a typed array that doubles as it fills, so a graph of millions of nodes takes a few
|
|
58
|
-
// bytes for each.
|
|
59
78
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
60
79
|
data: Data;
|
|
61
80
|
length: number;
|
|
62
81
|
create: (length: number) => Data;
|
|
63
82
|
}
|
|
64
83
|
|
|
65
|
-
//
|
|
66
|
-
|
|
84
|
+
// A check reads and fills the state atoms of a state in its row, which starts at offset.
|
|
85
|
+
type Check<State> = (
|
|
86
|
+
state: State,
|
|
87
|
+
row: Int8Array,
|
|
88
|
+
offset: number,
|
|
89
|
+
next: State | undefined,
|
|
90
|
+
) => boolean;
|
|
91
|
+
|
|
92
|
+
interface BehaviorChecks<State> {
|
|
93
|
+
states: Check<State>[];
|
|
94
|
+
actions: Check<State>[];
|
|
95
|
+
// The state predicates of each tableau node, or, where its checks share results and it has only
|
|
96
|
+
// state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
|
|
97
|
+
nodes: (Check<State>[] | Int32Array)[];
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
interface BehaviorGraph<State> {
|
|
67
101
|
solution: Solution;
|
|
68
|
-
|
|
102
|
+
checks: BehaviorChecks<State>;
|
|
69
103
|
actionIds: Int32Array;
|
|
70
104
|
nodeStates: number[];
|
|
71
105
|
nodeTableaux: number[];
|
|
72
|
-
// Where a node's edges start in edgeTargets, or UNWRITTEN until TLC writes the node with its
|
|
73
|
-
// successors, and how many it has.
|
|
74
106
|
edgeStarts: number[];
|
|
75
107
|
edgeCounts: number[];
|
|
76
108
|
edgeTargets: Pool<Int32Array>;
|
|
77
|
-
// The results of the action checks on each edge, and of the state checks on each state, which
|
|
78
|
-
// are the same for every node of the state.
|
|
79
109
|
edgeActions: Pool<Uint8Array>;
|
|
80
110
|
stateResults: Pool<Uint8Array>;
|
|
81
111
|
initial: number[];
|
|
82
|
-
// The nodes of each state in the order they are recorded, a list through nextSiblings.
|
|
83
112
|
firstNodes: Pool<Int32Array>;
|
|
84
113
|
lastNodes: Pool<Int32Array>;
|
|
85
114
|
nextSiblings: number[];
|
|
@@ -104,15 +133,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
|
|
|
104
133
|
}
|
|
105
134
|
};
|
|
106
135
|
|
|
107
|
-
|
|
136
|
+
const isEmptyModel = (model: Solution["models"][number]) =>
|
|
137
|
+
model.eventuallyAlways.length === 0 &&
|
|
138
|
+
model.infinitelyOftenStates.length === 0 &&
|
|
139
|
+
model.infinitelyOftenActions.length === 0;
|
|
140
|
+
|
|
108
141
|
const isCycleConstrained = (solution: Solution) =>
|
|
109
142
|
solution.promises.some((promise) => containsAlways(promise.body)) ||
|
|
110
|
-
solution.models.some(
|
|
111
|
-
(model) =>
|
|
112
|
-
model.eventuallyAlways.length > 0 ||
|
|
113
|
-
model.infinitelyOftenStates.length > 0 ||
|
|
114
|
-
model.infinitelyOftenActions.length > 0,
|
|
115
|
-
);
|
|
143
|
+
solution.models.some((model) => !isEmptyModel(model));
|
|
116
144
|
|
|
117
145
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
118
146
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
@@ -128,21 +156,24 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
128
156
|
pool: Pool<Data>,
|
|
129
157
|
offset: number,
|
|
130
158
|
values: ArrayLike<number>,
|
|
159
|
+
start = 0,
|
|
160
|
+
length = values.length - start,
|
|
131
161
|
) => {
|
|
132
|
-
const end = offset +
|
|
162
|
+
const end = offset + length;
|
|
133
163
|
if (end > pool.data.length) {
|
|
134
164
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
135
165
|
data.set(pool.data);
|
|
136
166
|
pool.data = data;
|
|
137
167
|
}
|
|
138
|
-
|
|
168
|
+
for (let position = 0; position < length; position++) {
|
|
169
|
+
pool.data[offset + position] = values[start + position];
|
|
170
|
+
}
|
|
139
171
|
pool.length = Math.max(pool.length, end);
|
|
140
172
|
};
|
|
141
173
|
|
|
142
174
|
const NO_NODE = -1;
|
|
143
175
|
|
|
144
|
-
// A Map holds at most 2^24 entries, so
|
|
145
|
-
// open-addressing table of (state plus one, tableau node, node) triples.
|
|
176
|
+
// A Map holds at most 2^24 entries, so an open-addressing table of (state plus one, tableau node, node) triples finds each node.
|
|
146
177
|
interface NodeTable {
|
|
147
178
|
slots: Int32Array;
|
|
148
179
|
size: number;
|
|
@@ -165,21 +196,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
165
196
|
|
|
166
197
|
const UNWRITTEN = -1;
|
|
167
198
|
|
|
168
|
-
const isWritten = (behavior: BehaviorGraph
|
|
199
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
169
200
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
170
201
|
|
|
171
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
202
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
172
203
|
const start = behavior.edgeStarts[node];
|
|
173
204
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
174
205
|
};
|
|
175
206
|
|
|
176
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
207
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
177
208
|
behavior.stateResults.data[
|
|
178
209
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
179
210
|
] === 1;
|
|
180
211
|
|
|
181
|
-
|
|
182
|
-
const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
212
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
183
213
|
behavior.nodeStates.push(state);
|
|
184
214
|
behavior.nodeTableaux.push(tableauNode);
|
|
185
215
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -188,7 +218,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
188
218
|
return behavior.nodeStates.length - 1;
|
|
189
219
|
};
|
|
190
220
|
|
|
191
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
221
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
192
222
|
const nodes: number[] = [];
|
|
193
223
|
for (
|
|
194
224
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -208,13 +238,11 @@ const UNVISITED = -1;
|
|
|
208
238
|
|
|
209
239
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
210
240
|
|
|
211
|
-
|
|
241
|
+
const getLiveFormula = (
|
|
212
242
|
properties: TemporalProperty[],
|
|
213
243
|
temporals: ScopedExpression[],
|
|
214
244
|
environment: Environment,
|
|
215
|
-
|
|
216
|
-
): LivenessChecker | undefined => {
|
|
217
|
-
if (properties.length === 0) return undefined;
|
|
245
|
+
) => {
|
|
218
246
|
const fairness = temporals.map((item) =>
|
|
219
247
|
toLiveExpression(item.expression, item.scope, environment),
|
|
220
248
|
);
|
|
@@ -224,18 +252,245 @@ export const createLivenessChecker = (
|
|
|
224
252
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
225
253
|
const formula =
|
|
226
254
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
255
|
+
return { formula, negations };
|
|
256
|
+
};
|
|
257
|
+
|
|
258
|
+
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
259
|
+
|
|
260
|
+
const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
|
|
261
|
+
switch (atom.kind) {
|
|
262
|
+
case "State":
|
|
263
|
+
return [atom];
|
|
264
|
+
case "Enabled":
|
|
265
|
+
return [{ expression: atom.step, scope: atom.scope }];
|
|
266
|
+
case "Action":
|
|
267
|
+
return [atom.expression, atom.subscript].flatMap((inner) =>
|
|
268
|
+
inner ? [{ expression: inner, scope: atom.scope }] : [],
|
|
269
|
+
);
|
|
270
|
+
}
|
|
271
|
+
};
|
|
272
|
+
|
|
273
|
+
const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
|
|
274
|
+
switch (expression.kind) {
|
|
275
|
+
case "Boolean":
|
|
276
|
+
return;
|
|
277
|
+
case "State":
|
|
278
|
+
case "Enabled":
|
|
279
|
+
case "Action":
|
|
280
|
+
atoms.add(expression);
|
|
281
|
+
return;
|
|
282
|
+
case "And":
|
|
283
|
+
case "Or":
|
|
284
|
+
expression.operands.forEach((operand) => collectAtoms(operand, atoms));
|
|
285
|
+
return;
|
|
286
|
+
default:
|
|
287
|
+
collectAtoms(expression.body, atoms);
|
|
230
288
|
}
|
|
289
|
+
};
|
|
290
|
+
|
|
291
|
+
// The atoms the checks of the solutions evaluate.
|
|
292
|
+
export const getLiveAtoms = (solutions: Solution[]) => {
|
|
293
|
+
const atoms = new Set<LiveAtom>();
|
|
294
|
+
for (const solution of solutions) {
|
|
295
|
+
[
|
|
296
|
+
...solution.stateChecks,
|
|
297
|
+
...solution.actionChecks,
|
|
298
|
+
...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
|
|
299
|
+
].forEach((check) => collectAtoms(check, atoms));
|
|
300
|
+
}
|
|
301
|
+
return [...atoms];
|
|
302
|
+
};
|
|
303
|
+
|
|
304
|
+
// The expressions the checks of the solutions evaluate.
|
|
305
|
+
export const getLiveExpressions = (solutions: Solution[]) =>
|
|
306
|
+
getLiveAtoms(solutions).flatMap((atom) =>
|
|
307
|
+
getAtomExpressions(atom).map((item) => item.expression),
|
|
308
|
+
);
|
|
309
|
+
|
|
310
|
+
export const createLivenessChecker = (
|
|
311
|
+
properties: TemporalProperty[],
|
|
312
|
+
temporals: ScopedExpression[],
|
|
313
|
+
environment: Environment,
|
|
314
|
+
search: SearchGraph<Value[]>,
|
|
315
|
+
): LivenessChecker | undefined => {
|
|
316
|
+
if (properties.length === 0) return undefined;
|
|
317
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
318
|
+
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
319
|
+
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
320
|
+
const formulaAtoms = new Set<LiveAtom>();
|
|
321
|
+
collectAtoms(live.formula, formulaAtoms);
|
|
322
|
+
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
323
|
+
const isShared = checked.every((item) => item.scope === undefined)
|
|
324
|
+
? !isExpressionImpure(
|
|
325
|
+
checked.map((item) => item.expression),
|
|
326
|
+
environment,
|
|
327
|
+
"repeated",
|
|
328
|
+
)
|
|
329
|
+
: !hasRepeatedEffects(environment);
|
|
330
|
+
const tracing = { environment, atoms: getInterpretedAtoms(environment) };
|
|
331
|
+
const solutions = getSolutions(live.formula);
|
|
332
|
+
const graph = createLiveGraph(
|
|
333
|
+
solutions,
|
|
334
|
+
{
|
|
335
|
+
atoms: {
|
|
336
|
+
holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
|
|
337
|
+
holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
|
|
338
|
+
},
|
|
339
|
+
isShared,
|
|
340
|
+
isSame: isSameState,
|
|
341
|
+
evaluateFrom: (source, evaluate) => {
|
|
342
|
+
environment.runtime.setLivenessSource(source);
|
|
343
|
+
try {
|
|
344
|
+
return evaluate();
|
|
345
|
+
} finally {
|
|
346
|
+
environment.runtime.setLivenessSource(undefined);
|
|
347
|
+
}
|
|
348
|
+
},
|
|
349
|
+
},
|
|
350
|
+
search,
|
|
351
|
+
environment.runtime.version !== "1.7.4",
|
|
352
|
+
);
|
|
353
|
+
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
354
|
+
if (replay === undefined) return run();
|
|
355
|
+
tracing.atoms = getInterpretedAtoms(replay);
|
|
356
|
+
try {
|
|
357
|
+
return run();
|
|
358
|
+
} finally {
|
|
359
|
+
tracing.atoms = getInterpretedAtoms(environment);
|
|
360
|
+
}
|
|
361
|
+
};
|
|
362
|
+
return {
|
|
363
|
+
branches: graph.branches,
|
|
364
|
+
solutions,
|
|
365
|
+
addInitialState: (index, state, replay) =>
|
|
366
|
+
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
367
|
+
addState: (index, state, successors, replay) =>
|
|
368
|
+
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
369
|
+
findViolation: graph.findViolation,
|
|
370
|
+
getViolatedProperties: (path, cycleStart) => [
|
|
371
|
+
...new Set(
|
|
372
|
+
properties
|
|
373
|
+
.filter(
|
|
374
|
+
(_property, position) =>
|
|
375
|
+
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
376
|
+
)
|
|
377
|
+
.map((property) => property.name),
|
|
378
|
+
),
|
|
379
|
+
],
|
|
380
|
+
};
|
|
381
|
+
};
|
|
382
|
+
|
|
383
|
+
export const createLiveGraph = <State>(
|
|
384
|
+
solutions: Solution[],
|
|
385
|
+
evaluation: LiveEvaluation<State>,
|
|
386
|
+
search: SearchGraph<State>,
|
|
387
|
+
isAcceptingFound: boolean,
|
|
388
|
+
): LiveGraph<State> => {
|
|
231
389
|
const actionIds = new Map<string, number>();
|
|
232
|
-
|
|
390
|
+
let capacityMultiplier = 1;
|
|
391
|
+
const isShared = evaluation.isShared;
|
|
392
|
+
const atoms = evaluation.atoms;
|
|
393
|
+
const evaluateFrom = evaluation.evaluateFrom;
|
|
394
|
+
const stateAtoms = new Map<LiveState | LiveEnabled, number>();
|
|
395
|
+
const atomsById: (LiveState | LiveEnabled)[] = [];
|
|
396
|
+
const getAtomId = (atom: LiveState | LiveEnabled) => {
|
|
397
|
+
const id = stateAtoms.get(atom) ?? stateAtoms.size;
|
|
398
|
+
stateAtoms.set(atom, id);
|
|
399
|
+
atomsById[id] = atom;
|
|
400
|
+
return id;
|
|
401
|
+
};
|
|
402
|
+
const getLiterals = (expression: LiveExpression): number[] | undefined => {
|
|
403
|
+
if (expression.kind === "State" || expression.kind === "Enabled") {
|
|
404
|
+
return [getAtomId(expression) * 2 + 1];
|
|
405
|
+
}
|
|
406
|
+
if (expression.kind === "Not") {
|
|
407
|
+
const body = expression.body;
|
|
408
|
+
return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
|
|
409
|
+
}
|
|
410
|
+
if (expression.kind !== "And") return undefined;
|
|
411
|
+
const operands = expression.operands.map(getLiterals);
|
|
412
|
+
return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
|
|
413
|
+
};
|
|
414
|
+
// The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
|
|
415
|
+
// or -1 before it is evaluated.
|
|
416
|
+
const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
|
|
417
|
+
// The edge rows of steps hold the result of each action check, shared by the behaviors that
|
|
418
|
+
// check it.
|
|
419
|
+
const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
|
|
420
|
+
// Unless the checks share results, each check evaluates its atoms afresh.
|
|
421
|
+
const runCheck = (
|
|
422
|
+
check: Check<State>,
|
|
423
|
+
state: State,
|
|
424
|
+
row: Int8Array,
|
|
425
|
+
offset: number,
|
|
426
|
+
next?: State,
|
|
427
|
+
) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
|
|
428
|
+
const compileCheck = (expression: LiveExpression): Check<State> => {
|
|
429
|
+
switch (expression.kind) {
|
|
430
|
+
case "Boolean": {
|
|
431
|
+
const value = expression.value;
|
|
432
|
+
return () => value;
|
|
433
|
+
}
|
|
434
|
+
case "State":
|
|
435
|
+
case "Enabled": {
|
|
436
|
+
const id = getAtomId(expression);
|
|
437
|
+
return (state, row, offset) => {
|
|
438
|
+
if (row[offset + id] === -1) {
|
|
439
|
+
row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
|
|
440
|
+
}
|
|
441
|
+
return row[offset + id] === 1;
|
|
442
|
+
};
|
|
443
|
+
}
|
|
444
|
+
case "Action": {
|
|
445
|
+
const enabled = expression.enabled && getAtomId(expression.enabled);
|
|
446
|
+
return (state, row, offset, next) =>
|
|
447
|
+
!(enabled !== undefined && row[offset + enabled] === 0) &&
|
|
448
|
+
next !== undefined &&
|
|
449
|
+
atoms.holdsAction(expression, state, next);
|
|
450
|
+
}
|
|
451
|
+
case "Not": {
|
|
452
|
+
const body = compileCheck(expression.body);
|
|
453
|
+
return (state, row, offset, next) => !body(state, row, offset, next);
|
|
454
|
+
}
|
|
455
|
+
case "And": {
|
|
456
|
+
const operands = expression.operands.map(compileCheck);
|
|
457
|
+
return (state, row, offset, next) =>
|
|
458
|
+
operands.every((operand) => operand(state, row, offset, next));
|
|
459
|
+
}
|
|
460
|
+
case "Or": {
|
|
461
|
+
const operands = expression.operands.map(compileCheck);
|
|
462
|
+
return (state, row, offset, next) =>
|
|
463
|
+
operands.some((operand) => operand(state, row, offset, next));
|
|
464
|
+
}
|
|
465
|
+
case "Next": {
|
|
466
|
+
const body = compileCheck(expression.body);
|
|
467
|
+
return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
|
|
468
|
+
}
|
|
469
|
+
case "Always":
|
|
470
|
+
case "Eventually":
|
|
471
|
+
return () => {
|
|
472
|
+
throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
|
|
473
|
+
};
|
|
474
|
+
}
|
|
475
|
+
};
|
|
476
|
+
const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
|
|
233
477
|
solution,
|
|
478
|
+
checks: {
|
|
479
|
+
states: solution.stateChecks.map(compileCheck),
|
|
480
|
+
actions: solution.actionChecks.map(compileCheck),
|
|
481
|
+
nodes:
|
|
482
|
+
solution.tableau?.nodes.map((node) => {
|
|
483
|
+
const literals = isShared
|
|
484
|
+
? getLiterals({ kind: "And", operands: node.statePredicates })
|
|
485
|
+
: undefined;
|
|
486
|
+
return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
|
|
487
|
+
}) ?? [],
|
|
488
|
+
},
|
|
234
489
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
235
490
|
const key = getTermKey(predicate);
|
|
236
|
-
const
|
|
237
|
-
actionIds.set(key,
|
|
238
|
-
return
|
|
491
|
+
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
492
|
+
actionIds.set(key, actionId);
|
|
493
|
+
return actionId;
|
|
239
494
|
}),
|
|
240
495
|
nodeStates: [],
|
|
241
496
|
nodeTableaux: [],
|
|
@@ -252,88 +507,85 @@ export const createLivenessChecker = (
|
|
|
252
507
|
isDone: [],
|
|
253
508
|
errorNode: undefined,
|
|
254
509
|
}));
|
|
255
|
-
const
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
//
|
|
271
|
-
const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
|
|
272
|
-
environment.runtime.setLivenessSource(source);
|
|
273
|
-
const result = evaluate();
|
|
274
|
-
environment.runtime.setLivenessSource(undefined);
|
|
275
|
-
return result;
|
|
276
|
-
};
|
|
277
|
-
const evaluateState = (predicate: LiveExpression, state: Value[]) =>
|
|
278
|
-
evaluateLive(
|
|
279
|
-
predicate,
|
|
280
|
-
state,
|
|
281
|
-
undefined,
|
|
282
|
-
evaluation.environment,
|
|
283
|
-
isShared ? getStateCache(state) : new Map(),
|
|
284
|
-
);
|
|
285
|
-
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
286
|
-
evaluateFrom(source, () =>
|
|
287
|
-
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
288
|
-
evaluateState(predicate, state) ? 1 : 0,
|
|
289
|
-
),
|
|
290
|
-
);
|
|
510
|
+
const checkState = (
|
|
511
|
+
behavior: BehaviorGraph<State>,
|
|
512
|
+
source: number,
|
|
513
|
+
state: State,
|
|
514
|
+
row: Int8Array,
|
|
515
|
+
offset: number,
|
|
516
|
+
) =>
|
|
517
|
+
evaluateFrom(source, () => {
|
|
518
|
+
const checks = behavior.checks.states;
|
|
519
|
+
const results = new Uint8Array(checks.length);
|
|
520
|
+
checks.forEach((check, position) => {
|
|
521
|
+
results[position] = runCheck(check, state, row, offset) ? 1 : 0;
|
|
522
|
+
});
|
|
523
|
+
return results;
|
|
524
|
+
});
|
|
525
|
+
// Writes the result of each action check of the step to successor at resultOffset in results.
|
|
291
526
|
const checkAction = (
|
|
292
|
-
behavior: BehaviorGraph
|
|
527
|
+
behavior: BehaviorGraph<State>,
|
|
293
528
|
source: number,
|
|
294
|
-
state:
|
|
295
|
-
|
|
529
|
+
state: State,
|
|
530
|
+
row: Int8Array,
|
|
531
|
+
offset: number,
|
|
532
|
+
successor: State,
|
|
533
|
+
edges: Int8Array,
|
|
534
|
+
edgeOffset: number,
|
|
535
|
+
results: Uint8Array,
|
|
536
|
+
resultOffset: number,
|
|
296
537
|
) =>
|
|
297
538
|
evaluateFrom(source, () => {
|
|
298
|
-
const
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
}
|
|
304
|
-
const stateCache = getStateCache(state);
|
|
305
|
-
const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
|
|
306
|
-
shared.actions.set(state, results);
|
|
307
|
-
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
308
|
-
results.set(successor, known);
|
|
309
|
-
return Uint8Array.from(behavior.actionIds, (id, position) => {
|
|
310
|
-
if (known[id] === -1) {
|
|
311
|
-
known[id] = evaluateLive(
|
|
312
|
-
predicates[position],
|
|
539
|
+
const actions = behavior.checks.actions;
|
|
540
|
+
for (let position = 0; position < actions.length; position++) {
|
|
541
|
+
if (!isShared) {
|
|
542
|
+
results[resultOffset + position] = runCheck(
|
|
543
|
+
actions[position],
|
|
313
544
|
state,
|
|
545
|
+
row,
|
|
546
|
+
offset,
|
|
314
547
|
successor,
|
|
315
|
-
evaluation.environment,
|
|
316
|
-
stateCache,
|
|
317
548
|
)
|
|
318
549
|
? 1
|
|
319
550
|
: 0;
|
|
551
|
+
continue;
|
|
320
552
|
}
|
|
321
|
-
|
|
322
|
-
|
|
553
|
+
const edge = edgeOffset + behavior.actionIds[position];
|
|
554
|
+
if (edges[edge] === -1)
|
|
555
|
+
edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
|
|
556
|
+
results[resultOffset + position] = edges[edge];
|
|
557
|
+
}
|
|
323
558
|
});
|
|
559
|
+
const holdsNode = (
|
|
560
|
+
behavior: BehaviorGraph<State>,
|
|
561
|
+
node: number,
|
|
562
|
+
state: State,
|
|
563
|
+
row: Int8Array,
|
|
564
|
+
offset: number,
|
|
565
|
+
) => {
|
|
566
|
+
const checks = behavior.checks.nodes[node];
|
|
567
|
+
if (!(checks instanceof Int32Array)) {
|
|
568
|
+
return checks.every((check) => runCheck(check, state, row, offset));
|
|
569
|
+
}
|
|
570
|
+
for (let position = 0; position < checks.length; position++) {
|
|
571
|
+
const literal: number = checks[position];
|
|
572
|
+
const cell = offset + (literal >> 1);
|
|
573
|
+
if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
|
|
574
|
+
if (row[cell] !== (literal & 1)) return false;
|
|
575
|
+
}
|
|
576
|
+
return true;
|
|
577
|
+
};
|
|
324
578
|
const isConsistent = (
|
|
325
|
-
|
|
579
|
+
behavior: BehaviorGraph<State>,
|
|
326
580
|
node: number,
|
|
327
581
|
source: number | undefined,
|
|
328
|
-
state:
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
// TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
|
|
334
|
-
// of a property like a safety property only in its liveness checks.
|
|
582
|
+
state: State,
|
|
583
|
+
row: Int8Array,
|
|
584
|
+
offset: number,
|
|
585
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
586
|
+
|
|
335
587
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
336
|
-
if (
|
|
588
|
+
if (!isAcceptingFound) return false;
|
|
337
589
|
const tableauNode = tableau.nodes[node];
|
|
338
590
|
return (
|
|
339
591
|
tableauNode.particle.length === 0 &&
|
|
@@ -341,21 +593,14 @@ export const createLivenessChecker = (
|
|
|
341
593
|
tableauNode.successors[0] === node
|
|
342
594
|
);
|
|
343
595
|
};
|
|
344
|
-
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
345
|
-
behavior.solution.models.some(
|
|
346
|
-
(model) =>
|
|
347
|
-
model.eventuallyAlways.length === 0 &&
|
|
348
|
-
model.infinitelyOftenStates.length === 0 &&
|
|
349
|
-
model.infinitelyOftenActions.length === 0,
|
|
350
|
-
);
|
|
351
596
|
|
|
352
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
597
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
353
598
|
if (!behavior.solution.tableau) return state;
|
|
354
599
|
const slots = behavior.nodeIds.slots;
|
|
355
600
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
356
601
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
357
602
|
};
|
|
358
|
-
const recordNode = (behavior: BehaviorGraph
|
|
603
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
359
604
|
const node = pushNode(behavior, state, tableauNode);
|
|
360
605
|
const table = behavior.nodeIds;
|
|
361
606
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
@@ -378,18 +623,26 @@ export const createLivenessChecker = (
|
|
|
378
623
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
379
624
|
return node;
|
|
380
625
|
};
|
|
626
|
+
// The action results of the edge to each target are at its position in actions.
|
|
381
627
|
const writeNode = (
|
|
382
|
-
behavior: BehaviorGraph
|
|
628
|
+
behavior: BehaviorGraph<State>,
|
|
383
629
|
node: number,
|
|
384
630
|
targets: number[],
|
|
385
|
-
|
|
631
|
+
actionResults: Uint8Array,
|
|
632
|
+
actions: number[],
|
|
386
633
|
stateResults: Uint8Array,
|
|
387
634
|
) => {
|
|
388
635
|
const start = behavior.edgeTargets.length;
|
|
389
636
|
const actionCount = behavior.solution.actionChecks.length;
|
|
390
637
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
391
|
-
actions.forEach((
|
|
392
|
-
writeToPool(
|
|
638
|
+
actions.forEach((position, edge) =>
|
|
639
|
+
writeToPool(
|
|
640
|
+
behavior.edgeActions,
|
|
641
|
+
(start + edge) * actionCount,
|
|
642
|
+
actionResults,
|
|
643
|
+
position * actionCount,
|
|
644
|
+
actionCount,
|
|
645
|
+
),
|
|
393
646
|
);
|
|
394
647
|
writeToPool(
|
|
395
648
|
behavior.stateResults,
|
|
@@ -400,67 +653,73 @@ export const createLivenessChecker = (
|
|
|
400
653
|
behavior.edgeCounts[node] = targets.length;
|
|
401
654
|
};
|
|
402
655
|
|
|
403
|
-
// TLC
|
|
404
|
-
//
|
|
405
|
-
|
|
406
|
-
const getSuccessorSet = (index: number, state:
|
|
407
|
-
const
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
const
|
|
656
|
+
// TLC iterates a state's successors and the state itself in the slot order of a SetOfStates, a hash set whose capacity grows with every set that outgrows it.
|
|
657
|
+
// Each slot holds a candidate's position plus one, or 0 when it is empty.
|
|
658
|
+
const successorSet = { slots: new Int32Array(0) };
|
|
659
|
+
const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
|
|
660
|
+
const candidates = [...successors, { index, state }];
|
|
661
|
+
const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
|
|
662
|
+
successorSet.slots =
|
|
663
|
+
successorSet.slots.length === capacity
|
|
664
|
+
? successorSet.slots.fill(0)
|
|
665
|
+
: new Int32Array(capacity);
|
|
666
|
+
const insert = (position: number) => {
|
|
667
|
+
const slots = successorSet.slots;
|
|
668
|
+
const candidate = candidates[position];
|
|
414
669
|
for (
|
|
415
|
-
let slot = (search.getFingerprint(
|
|
670
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
416
671
|
;
|
|
417
672
|
slot = (slot + 1) % slots.length
|
|
418
673
|
) {
|
|
419
674
|
const entry = slots[slot];
|
|
420
|
-
if (entry ===
|
|
421
|
-
slots[slot] =
|
|
675
|
+
if (entry === 0) {
|
|
676
|
+
slots[slot] = position + 1;
|
|
422
677
|
return true;
|
|
423
678
|
}
|
|
424
|
-
|
|
679
|
+
const stored = candidates[entry - 1];
|
|
680
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
425
681
|
return false;
|
|
426
682
|
}
|
|
427
683
|
};
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
684
|
+
let count = 0;
|
|
685
|
+
for (let position = 0; position < candidates.length; position++) {
|
|
686
|
+
if (count >= successorSet.slots.length >> 1) {
|
|
687
|
+
const old = successorSet.slots;
|
|
688
|
+
successorSet.slots = new Int32Array(2 * old.length + 1);
|
|
689
|
+
for (const entry of old) if (entry !== 0) insert(entry - 1);
|
|
433
690
|
}
|
|
434
|
-
if (
|
|
435
|
-
}
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
return
|
|
691
|
+
if (insert(position)) count++;
|
|
692
|
+
}
|
|
693
|
+
if (successorSet.slots.length > capacity) capacityMultiplier++;
|
|
694
|
+
const set: LiveSuccessor<State>[] = [];
|
|
695
|
+
for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
|
|
696
|
+
return set;
|
|
440
697
|
};
|
|
441
698
|
|
|
442
|
-
// TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
|
|
443
699
|
const expandLate = (
|
|
444
|
-
behavior: BehaviorGraph
|
|
700
|
+
behavior: BehaviorGraph<State>,
|
|
445
701
|
tableau: Tableau,
|
|
446
|
-
state:
|
|
702
|
+
state: State,
|
|
447
703
|
index: number,
|
|
448
704
|
node: number,
|
|
705
|
+
row: Int8Array,
|
|
706
|
+
offset: number,
|
|
449
707
|
) => {
|
|
450
|
-
const stateResults = checkState(behavior, index, state);
|
|
708
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
451
709
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
452
|
-
const
|
|
710
|
+
const actionCount = behavior.checks.actions.length;
|
|
711
|
+
const actions: number[] = [];
|
|
453
712
|
const successors: number[] = [];
|
|
454
|
-
const
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
713
|
+
const selfResults = new Uint8Array(actionCount);
|
|
714
|
+
if (tableauNode.successors.length > 0) {
|
|
715
|
+
checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
|
|
716
|
+
}
|
|
458
717
|
for (const next of tableauNode.successors) {
|
|
459
|
-
if (!isConsistent(
|
|
718
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
460
719
|
if (
|
|
461
720
|
isAccepting(tableau, next) &&
|
|
462
721
|
behavior.errorNode === undefined &&
|
|
463
|
-
|
|
722
|
+
behavior.solution.models.some(isEmptyModel)
|
|
464
723
|
) {
|
|
465
724
|
behavior.errorNode = node;
|
|
466
725
|
return;
|
|
@@ -469,90 +728,122 @@ export const createLivenessChecker = (
|
|
|
469
728
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
470
729
|
const target = existing ?? recordNode(behavior, index, next);
|
|
471
730
|
successors.push(target);
|
|
472
|
-
actions.push(
|
|
473
|
-
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
731
|
+
actions.push(0);
|
|
732
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
474
733
|
}
|
|
475
|
-
|
|
476
|
-
|
|
734
|
+
const nextStates = search.getSuccessors(index, state);
|
|
735
|
+
// The results of the step to the state itself come first, then those of each successor.
|
|
736
|
+
const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
|
|
737
|
+
actionResults.set(selfResults);
|
|
738
|
+
const edges = createEdgeRows(nextStates.length);
|
|
739
|
+
nextStates.forEach((successor, position) => {
|
|
740
|
+
const successorRow = createRows(1);
|
|
741
|
+
checkAction(
|
|
742
|
+
behavior,
|
|
743
|
+
index,
|
|
744
|
+
state,
|
|
745
|
+
row,
|
|
746
|
+
offset,
|
|
747
|
+
successor.state,
|
|
748
|
+
edges,
|
|
749
|
+
position * actionIds.size,
|
|
750
|
+
actionResults,
|
|
751
|
+
(position + 1) * actionCount,
|
|
752
|
+
);
|
|
477
753
|
const isDone = behavior.isDone[successor.index] === true;
|
|
478
754
|
for (const next of tableauNode.successors) {
|
|
479
|
-
if (!isConsistent(
|
|
480
|
-
//
|
|
481
|
-
// checks the graph. TLC records its node, which it never expands.
|
|
755
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
756
|
+
// Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
|
|
482
757
|
if (successor.index === -1) continue;
|
|
483
758
|
const existing = getNodeId(behavior, successor.index, next);
|
|
484
759
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
485
760
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
486
761
|
successors.push(target);
|
|
487
|
-
actions.push(
|
|
762
|
+
actions.push(position + 1);
|
|
488
763
|
if (existing === undefined && isDone) {
|
|
489
|
-
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
764
|
+
expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
|
|
490
765
|
}
|
|
491
766
|
}
|
|
767
|
+
});
|
|
768
|
+
if (successors.length > 0) {
|
|
769
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
492
770
|
}
|
|
493
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
494
771
|
};
|
|
495
772
|
|
|
496
773
|
const addTableauState = (
|
|
497
|
-
behavior: BehaviorGraph
|
|
774
|
+
behavior: BehaviorGraph<State>,
|
|
498
775
|
tableau: Tableau,
|
|
499
|
-
set: LiveSuccessor[],
|
|
500
|
-
|
|
776
|
+
set: LiveSuccessor<State>[],
|
|
777
|
+
rows: Int8Array,
|
|
778
|
+
actionResults: Uint8Array,
|
|
501
779
|
stateResults: Uint8Array,
|
|
502
780
|
index: number,
|
|
503
781
|
) => {
|
|
504
|
-
const
|
|
505
|
-
|
|
506
|
-
);
|
|
782
|
+
const atomCount = stateAtoms.size;
|
|
783
|
+
// Whether each successor is consistent with each tableau node, node by node.
|
|
784
|
+
const consistency = new Uint8Array(tableau.nodes.length * set.length);
|
|
785
|
+
evaluateFrom(index, () => {
|
|
786
|
+
for (let node = 0; node < tableau.nodes.length; node++) {
|
|
787
|
+
for (let position = 0; position < set.length; position++) {
|
|
788
|
+
if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
|
|
789
|
+
consistency[node * set.length + position] = 1;
|
|
790
|
+
}
|
|
791
|
+
}
|
|
792
|
+
}
|
|
793
|
+
});
|
|
507
794
|
behavior.isDone[index] = true;
|
|
508
795
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
509
796
|
for (const node of getStateNodes(behavior, index)) {
|
|
510
797
|
const successors: number[] = [];
|
|
511
|
-
const actions:
|
|
798
|
+
const actions: number[] = [];
|
|
512
799
|
set.forEach((successor, position) => {
|
|
513
800
|
const isDone = behavior.isDone[successor.index] === true;
|
|
514
801
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
515
|
-
if (
|
|
802
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
516
803
|
const existing = getNodeId(behavior, successor.index, next);
|
|
517
804
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
518
805
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
519
806
|
successors.push(target);
|
|
520
|
-
actions.push(
|
|
807
|
+
actions.push(position);
|
|
521
808
|
if (existing === undefined && isDone) {
|
|
522
|
-
expandLate(
|
|
809
|
+
expandLate(
|
|
810
|
+
behavior,
|
|
811
|
+
tableau,
|
|
812
|
+
successor.state,
|
|
813
|
+
successor.index,
|
|
814
|
+
target,
|
|
815
|
+
rows,
|
|
816
|
+
position * atomCount,
|
|
817
|
+
);
|
|
523
818
|
}
|
|
524
819
|
}
|
|
525
820
|
});
|
|
526
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
821
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
527
822
|
}
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
.reverse()
|
|
532
|
-
.map((node) => behavior.nodeStates[node]),
|
|
533
|
-
);
|
|
823
|
+
return behavior.errorNode === undefined
|
|
824
|
+
? undefined
|
|
825
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
534
826
|
};
|
|
535
827
|
|
|
536
828
|
const addPlainState = (
|
|
537
|
-
behavior: BehaviorGraph
|
|
538
|
-
set: LiveSuccessor[],
|
|
539
|
-
actionResults: Uint8Array
|
|
829
|
+
behavior: BehaviorGraph<State>,
|
|
830
|
+
set: LiveSuccessor<State>[],
|
|
831
|
+
actionResults: Uint8Array,
|
|
540
832
|
stateResults: Uint8Array,
|
|
541
833
|
index: number,
|
|
542
834
|
) => {
|
|
543
835
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
544
836
|
const successors: number[] = [];
|
|
545
|
-
const actions:
|
|
837
|
+
const actions: number[] = [];
|
|
546
838
|
set.forEach((successor, position) => {
|
|
547
839
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
548
840
|
successors.push(successor.index);
|
|
549
|
-
actions.push(
|
|
841
|
+
actions.push(position);
|
|
550
842
|
});
|
|
551
|
-
writeNode(behavior, index, successors, actions, stateResults);
|
|
843
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
552
844
|
};
|
|
553
845
|
|
|
554
|
-
|
|
555
|
-
const getPath = (behavior: BehaviorGraph, target: number) => {
|
|
846
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
556
847
|
if (behavior.initial.includes(target)) return [target];
|
|
557
848
|
const parents = new Map<number, number>();
|
|
558
849
|
const queue: number[] = [];
|
|
@@ -578,9 +869,15 @@ export const createLivenessChecker = (
|
|
|
578
869
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
579
870
|
};
|
|
580
871
|
|
|
581
|
-
|
|
872
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
873
|
+
removeRepeats(
|
|
874
|
+
getPath(behavior, target)
|
|
875
|
+
.reverse()
|
|
876
|
+
.map((node) => behavior.nodeStates[node]),
|
|
877
|
+
);
|
|
878
|
+
|
|
582
879
|
const findLassoInModel = (
|
|
583
|
-
behavior: BehaviorGraph
|
|
880
|
+
behavior: BehaviorGraph<State>,
|
|
584
881
|
model: Solution["models"][number],
|
|
585
882
|
): Lasso | undefined => {
|
|
586
883
|
const solution = behavior.solution;
|
|
@@ -635,91 +932,85 @@ export const createLivenessChecker = (
|
|
|
635
932
|
return getLasso(root, members, membersByState);
|
|
636
933
|
};
|
|
637
934
|
|
|
638
|
-
// TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component
|
|
639
|
-
// until it satisfies every check, and a breadth-first path back to the root.
|
|
640
935
|
const getLasso = (
|
|
641
936
|
root: number,
|
|
642
937
|
members: Set<number>,
|
|
643
938
|
membersByState: Map<number, number[]>,
|
|
644
939
|
) => {
|
|
645
|
-
const prefix =
|
|
646
|
-
getPath(behavior, root)
|
|
647
|
-
.reverse()
|
|
648
|
-
.map((node) => behavior.nodeStates[node]),
|
|
649
|
-
);
|
|
940
|
+
const prefix = getStatePath(behavior, root);
|
|
650
941
|
const cycleStack: number[] = [];
|
|
651
942
|
const seen = new Set<number>([root]);
|
|
652
943
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
653
944
|
const actionDone = model.infinitelyOftenActions.map(() => false);
|
|
654
945
|
const promiseDone = solution.promises.map(() => false);
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
const isMember = (node: number) => members.has(node);
|
|
946
|
+
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
947
|
+
let currentNode = root;
|
|
658
948
|
const moveTo = (next: number) => {
|
|
659
|
-
cycleStack.push(
|
|
660
|
-
|
|
949
|
+
cycleStack.push(currentNode);
|
|
950
|
+
currentNode = next;
|
|
661
951
|
};
|
|
662
|
-
while (
|
|
663
|
-
const countAtStart =
|
|
952
|
+
while (remainingCount > 0) {
|
|
953
|
+
const countAtStart = remainingCount;
|
|
664
954
|
while (true) {
|
|
665
955
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
666
|
-
if (!stateDone[slot] && getStateResult(behavior,
|
|
956
|
+
if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
|
|
667
957
|
stateDone[slot] = true;
|
|
668
|
-
|
|
958
|
+
remainingCount--;
|
|
669
959
|
}
|
|
670
960
|
});
|
|
671
961
|
solution.promises.forEach((promise, position) => {
|
|
672
|
-
if (!promiseDone[position] && isFulfilled(
|
|
962
|
+
if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
|
|
673
963
|
promiseDone[position] = true;
|
|
674
|
-
|
|
964
|
+
remainingCount--;
|
|
675
965
|
}
|
|
676
966
|
});
|
|
677
|
-
if (
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
const
|
|
967
|
+
if (remainingCount <= 0) break;
|
|
968
|
+
let lastNext = -1;
|
|
969
|
+
let unvisitedNext = -1;
|
|
970
|
+
const countBeforeActions = remainingCount;
|
|
971
|
+
const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
|
|
681
972
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
682
|
-
if (!
|
|
683
|
-
|
|
973
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
974
|
+
lastNext = next;
|
|
684
975
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
685
|
-
if (!actionDone[slot] && getAction(
|
|
976
|
+
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
686
977
|
actionDone[slot] = true;
|
|
687
|
-
|
|
978
|
+
remainingCount--;
|
|
688
979
|
}
|
|
689
980
|
});
|
|
690
981
|
}
|
|
691
|
-
if (
|
|
982
|
+
if (remainingCount < countBeforeActions) {
|
|
692
983
|
moveTo(next);
|
|
693
984
|
seen.clear();
|
|
694
985
|
return true;
|
|
695
986
|
}
|
|
696
|
-
if (
|
|
987
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
697
988
|
return false;
|
|
698
989
|
});
|
|
699
|
-
if (
|
|
700
|
-
if (
|
|
701
|
-
moveTo(
|
|
990
|
+
if (isTaken) break;
|
|
991
|
+
if (remainingCount < countAtStart) {
|
|
992
|
+
moveTo(lastNext);
|
|
702
993
|
seen.clear();
|
|
703
994
|
break;
|
|
704
995
|
}
|
|
705
|
-
while (
|
|
996
|
+
while (unvisitedNext === -1) {
|
|
706
997
|
const previous = cycleStack.pop();
|
|
707
998
|
if (previous === undefined) {
|
|
708
999
|
throw new TlaEvaluationError(
|
|
709
1000
|
"TLC failed to build the counterexample of a liveness property",
|
|
710
1001
|
);
|
|
711
1002
|
}
|
|
712
|
-
|
|
713
|
-
|
|
1003
|
+
currentNode = previous;
|
|
1004
|
+
unvisitedNext =
|
|
714
1005
|
getNodeSuccessors(behavior, previous).find(
|
|
715
|
-
(next) =>
|
|
1006
|
+
(next) => members.has(next) && !seen.has(next),
|
|
716
1007
|
) ?? -1;
|
|
717
1008
|
}
|
|
718
|
-
moveTo(
|
|
719
|
-
seen.add(
|
|
1009
|
+
moveTo(unvisitedNext);
|
|
1010
|
+
seen.add(unvisitedNext);
|
|
720
1011
|
}
|
|
721
1012
|
}
|
|
722
|
-
const postfix = getClosingPath(root,
|
|
1013
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
723
1014
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
724
1015
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
725
1016
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -733,13 +1024,7 @@ export const createLivenessChecker = (
|
|
|
733
1024
|
};
|
|
734
1025
|
};
|
|
735
1026
|
|
|
736
|
-
|
|
737
|
-
const getClosingPath = (
|
|
738
|
-
root: number,
|
|
739
|
-
end: number,
|
|
740
|
-
membersByState: Map<number, number[]>,
|
|
741
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
742
|
-
) => {
|
|
1027
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
743
1028
|
if (end === root) return [];
|
|
744
1029
|
const start = behavior.nodeStates[end];
|
|
745
1030
|
const parents = new Map<number, number>();
|
|
@@ -748,7 +1033,7 @@ export const createLivenessChecker = (
|
|
|
748
1033
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
749
1034
|
for (const node of membersByState.get(state) ?? []) {
|
|
750
1035
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
751
|
-
if (next === node || !
|
|
1036
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
752
1037
|
if (next === root) {
|
|
753
1038
|
const path: number[] = [];
|
|
754
1039
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -779,7 +1064,7 @@ export const createLivenessChecker = (
|
|
|
779
1064
|
|
|
780
1065
|
for (let position = 0; position < queue.length; position++) {
|
|
781
1066
|
const stack = [queue[position], UNVISITED, 0];
|
|
782
|
-
|
|
1067
|
+
let nextLink = 0;
|
|
783
1068
|
while (stack.length >= 3) {
|
|
784
1069
|
const lowLink = stack.pop() ?? 0;
|
|
785
1070
|
const location = stack.pop();
|
|
@@ -796,10 +1081,10 @@ export const createLivenessChecker = (
|
|
|
796
1081
|
stack.push(Math.min(lowLink, links[node]));
|
|
797
1082
|
continue;
|
|
798
1083
|
}
|
|
799
|
-
links[node] =
|
|
1084
|
+
links[node] = nextLink;
|
|
800
1085
|
stack.push(lowLink, node, SCC_MARKER);
|
|
801
1086
|
components.push(node);
|
|
802
|
-
|
|
1087
|
+
let nextLowLink = nextLink++;
|
|
803
1088
|
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
804
1089
|
if (!isWritten(behavior, next)) return;
|
|
805
1090
|
if (!isAllowed(node, edge)) {
|
|
@@ -807,9 +1092,9 @@ export const createLivenessChecker = (
|
|
|
807
1092
|
return;
|
|
808
1093
|
}
|
|
809
1094
|
if (links[next] === UNVISITED) stack.push(next, UNVISITED);
|
|
810
|
-
else nextLowLink
|
|
1095
|
+
else nextLowLink = Math.min(nextLowLink, links[next]);
|
|
811
1096
|
});
|
|
812
|
-
stack.push(nextLowLink
|
|
1097
|
+
stack.push(nextLowLink);
|
|
813
1098
|
}
|
|
814
1099
|
}
|
|
815
1100
|
return undefined;
|
|
@@ -817,58 +1102,63 @@ export const createLivenessChecker = (
|
|
|
817
1102
|
|
|
818
1103
|
return {
|
|
819
1104
|
branches: behaviors.length,
|
|
820
|
-
addInitialState: (index, state
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
behavior.initial.push(
|
|
834
|
-
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
835
|
-
);
|
|
836
|
-
}
|
|
1105
|
+
addInitialState: (index, state) => {
|
|
1106
|
+
const row = createRows(1);
|
|
1107
|
+
for (const behavior of behaviors) {
|
|
1108
|
+
const tableau = behavior.solution.tableau;
|
|
1109
|
+
if (!tableau) {
|
|
1110
|
+
behavior.initial.push(index);
|
|
1111
|
+
continue;
|
|
1112
|
+
}
|
|
1113
|
+
for (let node = 0; node < tableau.initialCount; node++) {
|
|
1114
|
+
if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
|
|
1115
|
+
behavior.initial.push(
|
|
1116
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
1117
|
+
);
|
|
837
1118
|
}
|
|
838
|
-
} finally {
|
|
839
|
-
evaluation.environment = environment;
|
|
840
1119
|
}
|
|
841
1120
|
},
|
|
842
|
-
addState: (index, state, successors
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
const tableau = behavior.solution.tableau;
|
|
854
|
-
if (!tableau) {
|
|
855
|
-
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
856
|
-
continue;
|
|
857
|
-
}
|
|
858
|
-
const accepted = addTableauState(
|
|
1121
|
+
addState: (index, state, successors) => {
|
|
1122
|
+
const set = getSuccessorSet(index, state, successors);
|
|
1123
|
+
const rows = createRows(set.length);
|
|
1124
|
+
// The set holds the state itself, as a successor of the same index.
|
|
1125
|
+
const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
|
|
1126
|
+
const edges = createEdgeRows(set.length);
|
|
1127
|
+
for (const behavior of behaviors) {
|
|
1128
|
+
const actionCount = behavior.checks.actions.length;
|
|
1129
|
+
const actionResults = new Uint8Array(set.length * actionCount);
|
|
1130
|
+
set.forEach((successor, position) =>
|
|
1131
|
+
checkAction(
|
|
859
1132
|
behavior,
|
|
860
|
-
tableau,
|
|
861
|
-
set,
|
|
862
|
-
actionResults,
|
|
863
|
-
stateResults,
|
|
864
1133
|
index,
|
|
865
|
-
|
|
866
|
-
|
|
1134
|
+
state,
|
|
1135
|
+
rows,
|
|
1136
|
+
offset,
|
|
1137
|
+
successor.state,
|
|
1138
|
+
edges,
|
|
1139
|
+
position * actionIds.size,
|
|
1140
|
+
actionResults,
|
|
1141
|
+
position * actionCount,
|
|
1142
|
+
),
|
|
1143
|
+
);
|
|
1144
|
+
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1145
|
+
const tableau = behavior.solution.tableau;
|
|
1146
|
+
if (!tableau) {
|
|
1147
|
+
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1148
|
+
continue;
|
|
867
1149
|
}
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
1150
|
+
const accepted = addTableauState(
|
|
1151
|
+
behavior,
|
|
1152
|
+
tableau,
|
|
1153
|
+
set,
|
|
1154
|
+
rows,
|
|
1155
|
+
actionResults,
|
|
1156
|
+
stateResults,
|
|
1157
|
+
index,
|
|
1158
|
+
);
|
|
1159
|
+
if (accepted) return accepted;
|
|
871
1160
|
}
|
|
1161
|
+
return undefined;
|
|
872
1162
|
},
|
|
873
1163
|
findViolation: () => {
|
|
874
1164
|
for (const behavior of behaviors) {
|
|
@@ -879,16 +1169,5 @@ export const createLivenessChecker = (
|
|
|
879
1169
|
}
|
|
880
1170
|
return undefined;
|
|
881
1171
|
},
|
|
882
|
-
// TLC names every property that the counterexample violates, once each.
|
|
883
|
-
getViolatedProperties: (path, cycleStart) => [
|
|
884
|
-
...new Set(
|
|
885
|
-
properties
|
|
886
|
-
.filter(
|
|
887
|
-
(_, position) =>
|
|
888
|
-
!evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
|
|
889
|
-
)
|
|
890
|
-
.map((property) => property.name),
|
|
891
|
-
),
|
|
892
|
-
],
|
|
893
1172
|
};
|
|
894
1173
|
};
|