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