tla-ts 0.0.10-dev.b4a856304 → 0.0.10-dev.d618a2d79
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 +47 -44
- package/dist/run.js +47 -44
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +44 -41
- package/dist/transfer.js +44 -41
- 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 +474 -718
- package/src/cli/options.ts +6 -31
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +8 -7
- package/src/cli/shared.ts +1 -5
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +244 -238
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +3 -5
- package/src/cli/tlc.ts +49 -702
- 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 +55 -338
- package/src/errors.ts +33 -5
- package/src/evaluate.ts +31 -106
- package/src/exit-codes.ts +2 -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 +616 -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 +10 -30
- package/src/parallel.ts +50 -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 +9 -5
- 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 +0 -1
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -2
- 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 +15 -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 +206 -44
- 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 +22 -47
- 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 +54 -26
- 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,39 +45,72 @@ export interface LivenessChecker {
|
|
|
44
45
|
successors: LiveSuccessor[],
|
|
45
46
|
tracing?: Environment,
|
|
46
47
|
) => number[] | undefined;
|
|
48
|
+
storeState: (pending: number, index: number) => void;
|
|
47
49
|
findViolation: () => Lasso | undefined;
|
|
48
50
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
49
51
|
}
|
|
50
52
|
|
|
51
|
-
interface
|
|
52
|
-
|
|
53
|
-
|
|
53
|
+
export interface LiveGraph<State> {
|
|
54
|
+
branches: number;
|
|
55
|
+
addInitialState: (index: number, state: State) => void;
|
|
56
|
+
// The path to an accepting node the state reaches, if any.
|
|
57
|
+
addState: (
|
|
58
|
+
index: number,
|
|
59
|
+
state: State,
|
|
60
|
+
successors: LiveSuccessor<State>[],
|
|
61
|
+
) => number[] | undefined;
|
|
62
|
+
storeState: (pending: number, index: number) => void;
|
|
63
|
+
findViolation: () => Lasso | undefined;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
export interface SearchGraph<State> {
|
|
67
|
+
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
68
|
+
getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
export interface LiveEvaluation<State> {
|
|
72
|
+
atoms: LiveAtoms<State>;
|
|
73
|
+
// Whether a check's result for a state holds for every step from it.
|
|
74
|
+
isShared: boolean;
|
|
75
|
+
isSame: (left: State, right: State) => boolean;
|
|
76
|
+
// Evaluates the checks of a state the search found from the state at source.
|
|
77
|
+
evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
|
|
54
78
|
}
|
|
55
79
|
|
|
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
80
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
59
81
|
data: Data;
|
|
60
82
|
length: number;
|
|
61
83
|
create: (length: number) => Data;
|
|
62
84
|
}
|
|
63
85
|
|
|
64
|
-
|
|
86
|
+
// A check reads and fills the state atoms of a state in its row, which starts at offset.
|
|
87
|
+
type Check<State> = (
|
|
88
|
+
state: State,
|
|
89
|
+
row: Int8Array,
|
|
90
|
+
offset: number,
|
|
91
|
+
next: State | undefined,
|
|
92
|
+
) => boolean;
|
|
93
|
+
|
|
94
|
+
interface BehaviorChecks<State> {
|
|
95
|
+
states: Check<State>[];
|
|
96
|
+
actions: Check<State>[];
|
|
97
|
+
// The state predicates of each tableau node, or, where its checks share results and it has only
|
|
98
|
+
// state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
|
|
99
|
+
nodes: (Check<State>[] | Int32Array)[];
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
interface BehaviorGraph<State> {
|
|
65
103
|
solution: Solution;
|
|
104
|
+
checks: BehaviorChecks<State>;
|
|
66
105
|
actionIds: Int32Array;
|
|
67
106
|
nodeStates: number[];
|
|
68
107
|
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
108
|
edgeStarts: number[];
|
|
72
109
|
edgeCounts: number[];
|
|
73
110
|
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
111
|
edgeActions: Pool<Uint8Array>;
|
|
77
112
|
stateResults: Pool<Uint8Array>;
|
|
78
113
|
initial: number[];
|
|
79
|
-
// The nodes of each state in the order they are recorded, a list through nextSiblings.
|
|
80
114
|
firstNodes: Pool<Int32Array>;
|
|
81
115
|
lastNodes: Pool<Int32Array>;
|
|
82
116
|
nextSiblings: number[];
|
|
@@ -101,14 +135,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
|
|
|
101
135
|
}
|
|
102
136
|
};
|
|
103
137
|
|
|
138
|
+
const isEmptyModel = (model: Solution["models"][number]) =>
|
|
139
|
+
model.eventuallyAlways.length === 0 &&
|
|
140
|
+
model.infinitelyOftenStates.length === 0 &&
|
|
141
|
+
model.infinitelyOftenActions.length === 0;
|
|
142
|
+
|
|
104
143
|
const isCycleConstrained = (solution: Solution) =>
|
|
105
144
|
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
|
-
);
|
|
145
|
+
solution.models.some((model) => !isEmptyModel(model));
|
|
112
146
|
|
|
113
147
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
114
148
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
@@ -124,21 +158,24 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
124
158
|
pool: Pool<Data>,
|
|
125
159
|
offset: number,
|
|
126
160
|
values: ArrayLike<number>,
|
|
161
|
+
start = 0,
|
|
162
|
+
length = values.length - start,
|
|
127
163
|
) => {
|
|
128
|
-
const end = offset +
|
|
164
|
+
const end = offset + length;
|
|
129
165
|
if (end > pool.data.length) {
|
|
130
166
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
131
167
|
data.set(pool.data);
|
|
132
168
|
pool.data = data;
|
|
133
169
|
}
|
|
134
|
-
|
|
170
|
+
for (let position = 0; position < length; position++) {
|
|
171
|
+
pool.data[offset + position] = values[start + position];
|
|
172
|
+
}
|
|
135
173
|
pool.length = Math.max(pool.length, end);
|
|
136
174
|
};
|
|
137
175
|
|
|
138
176
|
const NO_NODE = -1;
|
|
139
177
|
|
|
140
|
-
// A Map holds at most 2^24 entries, so
|
|
141
|
-
// open-addressing table of (state plus one, tableau node, node) triples.
|
|
178
|
+
// 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
179
|
interface NodeTable {
|
|
143
180
|
slots: Int32Array;
|
|
144
181
|
size: number;
|
|
@@ -161,20 +198,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
161
198
|
|
|
162
199
|
const UNWRITTEN = -1;
|
|
163
200
|
|
|
164
|
-
const isWritten = (behavior: BehaviorGraph
|
|
201
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
165
202
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
166
203
|
|
|
167
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
204
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
168
205
|
const start = behavior.edgeStarts[node];
|
|
169
206
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
170
207
|
};
|
|
171
208
|
|
|
172
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
209
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
173
210
|
behavior.stateResults.data[
|
|
174
211
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
175
212
|
] === 1;
|
|
176
213
|
|
|
177
|
-
const pushNode = (behavior: BehaviorGraph
|
|
214
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
178
215
|
behavior.nodeStates.push(state);
|
|
179
216
|
behavior.nodeTableaux.push(tableauNode);
|
|
180
217
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -183,7 +220,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
183
220
|
return behavior.nodeStates.length - 1;
|
|
184
221
|
};
|
|
185
222
|
|
|
186
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
223
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
187
224
|
const nodes: number[] = [];
|
|
188
225
|
for (
|
|
189
226
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -203,13 +240,11 @@ const UNVISITED = -1;
|
|
|
203
240
|
|
|
204
241
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
205
242
|
|
|
206
|
-
|
|
243
|
+
const getLiveFormula = (
|
|
207
244
|
properties: TemporalProperty[],
|
|
208
245
|
temporals: ScopedExpression[],
|
|
209
246
|
environment: Environment,
|
|
210
|
-
|
|
211
|
-
): LivenessChecker | undefined => {
|
|
212
|
-
if (properties.length === 0) return undefined;
|
|
247
|
+
) => {
|
|
213
248
|
const fairness = temporals.map((item) =>
|
|
214
249
|
toLiveExpression(item.expression, item.scope, environment),
|
|
215
250
|
);
|
|
@@ -219,15 +254,246 @@ export const createLivenessChecker = (
|
|
|
219
254
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
220
255
|
const formula =
|
|
221
256
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
222
|
-
|
|
257
|
+
return { formula, negations };
|
|
258
|
+
};
|
|
259
|
+
|
|
260
|
+
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
261
|
+
|
|
262
|
+
const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
|
|
263
|
+
switch (atom.kind) {
|
|
264
|
+
case "State":
|
|
265
|
+
return [atom];
|
|
266
|
+
case "Enabled":
|
|
267
|
+
return [{ expression: atom.step, scope: atom.scope }];
|
|
268
|
+
case "Action":
|
|
269
|
+
return [atom.expression, atom.subscript].flatMap((inner) =>
|
|
270
|
+
inner ? [{ expression: inner, scope: atom.scope }] : [],
|
|
271
|
+
);
|
|
272
|
+
}
|
|
273
|
+
};
|
|
274
|
+
|
|
275
|
+
const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
|
|
276
|
+
switch (expression.kind) {
|
|
277
|
+
case "Boolean":
|
|
278
|
+
return;
|
|
279
|
+
case "State":
|
|
280
|
+
case "Enabled":
|
|
281
|
+
case "Action":
|
|
282
|
+
atoms.add(expression);
|
|
283
|
+
return;
|
|
284
|
+
case "And":
|
|
285
|
+
case "Or":
|
|
286
|
+
expression.operands.forEach((operand) => collectAtoms(operand, atoms));
|
|
287
|
+
return;
|
|
288
|
+
default:
|
|
289
|
+
collectAtoms(expression.body, atoms);
|
|
290
|
+
}
|
|
291
|
+
};
|
|
292
|
+
|
|
293
|
+
// The atoms the checks of the solutions evaluate.
|
|
294
|
+
export const getLiveAtoms = (solutions: Solution[]) => {
|
|
295
|
+
const atoms = new Set<LiveAtom>();
|
|
296
|
+
for (const solution of solutions) {
|
|
297
|
+
[
|
|
298
|
+
...solution.stateChecks,
|
|
299
|
+
...solution.actionChecks,
|
|
300
|
+
...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
|
|
301
|
+
].forEach((check) => collectAtoms(check, atoms));
|
|
302
|
+
}
|
|
303
|
+
return [...atoms];
|
|
304
|
+
};
|
|
305
|
+
|
|
306
|
+
// The expressions the checks of the solutions evaluate.
|
|
307
|
+
export const getLiveExpressions = (solutions: Solution[]) =>
|
|
308
|
+
getLiveAtoms(solutions).flatMap((atom) =>
|
|
309
|
+
getAtomExpressions(atom).map((item) => item.expression),
|
|
310
|
+
);
|
|
311
|
+
|
|
312
|
+
export const createLivenessChecker = (
|
|
313
|
+
properties: TemporalProperty[],
|
|
314
|
+
temporals: ScopedExpression[],
|
|
315
|
+
environment: Environment,
|
|
316
|
+
search: SearchGraph<Value[]>,
|
|
317
|
+
): LivenessChecker | undefined => {
|
|
318
|
+
if (properties.length === 0) return undefined;
|
|
319
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
320
|
+
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
321
|
+
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
322
|
+
const formulaAtoms = new Set<LiveAtom>();
|
|
323
|
+
collectAtoms(live.formula, formulaAtoms);
|
|
324
|
+
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
325
|
+
const isShared = checked.every((item) => item.scope === undefined)
|
|
326
|
+
? !isExpressionImpure(
|
|
327
|
+
checked.map((item) => item.expression),
|
|
328
|
+
environment,
|
|
329
|
+
"repeated",
|
|
330
|
+
)
|
|
331
|
+
: !hasRepeatedEffects(environment);
|
|
332
|
+
const tracing = { environment, atoms: getInterpretedAtoms(environment) };
|
|
333
|
+
const solutions = getSolutions(live.formula);
|
|
334
|
+
const graph = createLiveGraph(
|
|
335
|
+
solutions,
|
|
336
|
+
{
|
|
337
|
+
atoms: {
|
|
338
|
+
holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
|
|
339
|
+
holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
|
|
340
|
+
},
|
|
341
|
+
isShared,
|
|
342
|
+
isSame: isSameState,
|
|
343
|
+
evaluateFrom: (source, evaluate) => {
|
|
344
|
+
environment.runtime.setLivenessSource(source);
|
|
345
|
+
try {
|
|
346
|
+
return evaluate();
|
|
347
|
+
} finally {
|
|
348
|
+
environment.runtime.setLivenessSource(undefined);
|
|
349
|
+
}
|
|
350
|
+
},
|
|
351
|
+
},
|
|
352
|
+
search,
|
|
353
|
+
environment.runtime.version !== "1.7.4",
|
|
354
|
+
);
|
|
355
|
+
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
356
|
+
if (replay === undefined) return run();
|
|
357
|
+
tracing.atoms = getInterpretedAtoms(replay);
|
|
358
|
+
try {
|
|
359
|
+
return run();
|
|
360
|
+
} finally {
|
|
361
|
+
tracing.atoms = getInterpretedAtoms(environment);
|
|
362
|
+
}
|
|
363
|
+
};
|
|
364
|
+
return {
|
|
365
|
+
branches: graph.branches,
|
|
366
|
+
solutions,
|
|
367
|
+
addInitialState: (index, state, replay) =>
|
|
368
|
+
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
369
|
+
addState: (index, state, successors, replay) =>
|
|
370
|
+
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
371
|
+
storeState: graph.storeState,
|
|
372
|
+
findViolation: graph.findViolation,
|
|
373
|
+
getViolatedProperties: (path, cycleStart) => [
|
|
374
|
+
...new Set(
|
|
375
|
+
properties
|
|
376
|
+
.filter(
|
|
377
|
+
(_property, position) =>
|
|
378
|
+
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
379
|
+
)
|
|
380
|
+
.map((property) => property.name),
|
|
381
|
+
),
|
|
382
|
+
],
|
|
383
|
+
};
|
|
384
|
+
};
|
|
385
|
+
|
|
386
|
+
export const createLiveGraph = <State>(
|
|
387
|
+
solutions: Solution[],
|
|
388
|
+
evaluation: LiveEvaluation<State>,
|
|
389
|
+
search: SearchGraph<State>,
|
|
390
|
+
isAcceptingFound: boolean,
|
|
391
|
+
): LiveGraph<State> => {
|
|
223
392
|
const actionIds = new Map<string, number>();
|
|
224
|
-
|
|
393
|
+
let capacityMultiplier = 1;
|
|
394
|
+
const isShared = evaluation.isShared;
|
|
395
|
+
const atoms = evaluation.atoms;
|
|
396
|
+
const evaluateFrom = evaluation.evaluateFrom;
|
|
397
|
+
const stateAtoms = new Map<LiveState | LiveEnabled, number>();
|
|
398
|
+
const atomsById: (LiveState | LiveEnabled)[] = [];
|
|
399
|
+
const getAtomId = (atom: LiveState | LiveEnabled) => {
|
|
400
|
+
const id = stateAtoms.get(atom) ?? stateAtoms.size;
|
|
401
|
+
stateAtoms.set(atom, id);
|
|
402
|
+
atomsById[id] = atom;
|
|
403
|
+
return id;
|
|
404
|
+
};
|
|
405
|
+
const getLiterals = (expression: LiveExpression): number[] | undefined => {
|
|
406
|
+
if (expression.kind === "State" || expression.kind === "Enabled") {
|
|
407
|
+
return [getAtomId(expression) * 2 + 1];
|
|
408
|
+
}
|
|
409
|
+
if (expression.kind === "Not") {
|
|
410
|
+
const body = expression.body;
|
|
411
|
+
return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
|
|
412
|
+
}
|
|
413
|
+
if (expression.kind !== "And") return undefined;
|
|
414
|
+
const operands = expression.operands.map(getLiterals);
|
|
415
|
+
return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
|
|
416
|
+
};
|
|
417
|
+
// The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
|
|
418
|
+
// or -1 before it is evaluated.
|
|
419
|
+
const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
|
|
420
|
+
// The edge rows of steps hold the result of each action check, shared by the behaviors that
|
|
421
|
+
// check it.
|
|
422
|
+
const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
|
|
423
|
+
// Unless the checks share results, each check evaluates its atoms afresh.
|
|
424
|
+
const runCheck = (
|
|
425
|
+
check: Check<State>,
|
|
426
|
+
state: State,
|
|
427
|
+
row: Int8Array,
|
|
428
|
+
offset: number,
|
|
429
|
+
next?: State,
|
|
430
|
+
) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
|
|
431
|
+
const compileCheck = (expression: LiveExpression): Check<State> => {
|
|
432
|
+
switch (expression.kind) {
|
|
433
|
+
case "Boolean": {
|
|
434
|
+
const value = expression.value;
|
|
435
|
+
return () => value;
|
|
436
|
+
}
|
|
437
|
+
case "State":
|
|
438
|
+
case "Enabled": {
|
|
439
|
+
const id = getAtomId(expression);
|
|
440
|
+
return (state, row, offset) => {
|
|
441
|
+
if (row[offset + id] === -1) {
|
|
442
|
+
row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
|
|
443
|
+
}
|
|
444
|
+
return row[offset + id] === 1;
|
|
445
|
+
};
|
|
446
|
+
}
|
|
447
|
+
case "Action": {
|
|
448
|
+
const enabled = expression.enabled && getAtomId(expression.enabled);
|
|
449
|
+
return (state, row, offset, next) =>
|
|
450
|
+
!(enabled !== undefined && row[offset + enabled] === 0) &&
|
|
451
|
+
next !== undefined &&
|
|
452
|
+
atoms.holdsAction(expression, state, next);
|
|
453
|
+
}
|
|
454
|
+
case "Not": {
|
|
455
|
+
const body = compileCheck(expression.body);
|
|
456
|
+
return (state, row, offset, next) => !body(state, row, offset, next);
|
|
457
|
+
}
|
|
458
|
+
case "And": {
|
|
459
|
+
const operands = expression.operands.map(compileCheck);
|
|
460
|
+
return (state, row, offset, next) =>
|
|
461
|
+
operands.every((operand) => operand(state, row, offset, next));
|
|
462
|
+
}
|
|
463
|
+
case "Or": {
|
|
464
|
+
const operands = expression.operands.map(compileCheck);
|
|
465
|
+
return (state, row, offset, next) =>
|
|
466
|
+
operands.some((operand) => operand(state, row, offset, next));
|
|
467
|
+
}
|
|
468
|
+
case "Next": {
|
|
469
|
+
const body = compileCheck(expression.body);
|
|
470
|
+
return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
|
|
471
|
+
}
|
|
472
|
+
case "Always":
|
|
473
|
+
case "Eventually":
|
|
474
|
+
return () => {
|
|
475
|
+
throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
|
|
476
|
+
};
|
|
477
|
+
}
|
|
478
|
+
};
|
|
479
|
+
const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
|
|
225
480
|
solution,
|
|
481
|
+
checks: {
|
|
482
|
+
states: solution.stateChecks.map(compileCheck),
|
|
483
|
+
actions: solution.actionChecks.map(compileCheck),
|
|
484
|
+
nodes:
|
|
485
|
+
solution.tableau?.nodes.map((node) => {
|
|
486
|
+
const literals = isShared
|
|
487
|
+
? getLiterals({ kind: "And", operands: node.statePredicates })
|
|
488
|
+
: undefined;
|
|
489
|
+
return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
|
|
490
|
+
}) ?? [],
|
|
491
|
+
},
|
|
226
492
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
227
493
|
const key = getTermKey(predicate);
|
|
228
|
-
const
|
|
229
|
-
actionIds.set(key,
|
|
230
|
-
return
|
|
494
|
+
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
495
|
+
actionIds.set(key, actionId);
|
|
496
|
+
return actionId;
|
|
231
497
|
}),
|
|
232
498
|
nodeStates: [],
|
|
233
499
|
nodeTableaux: [],
|
|
@@ -244,91 +510,85 @@ export const createLivenessChecker = (
|
|
|
244
510
|
isDone: [],
|
|
245
511
|
errorNode: undefined,
|
|
246
512
|
}));
|
|
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
|
-
);
|
|
513
|
+
const checkState = (
|
|
514
|
+
behavior: BehaviorGraph<State>,
|
|
515
|
+
source: number,
|
|
516
|
+
state: State,
|
|
517
|
+
row: Int8Array,
|
|
518
|
+
offset: number,
|
|
519
|
+
) =>
|
|
520
|
+
evaluateFrom(source, () => {
|
|
521
|
+
const checks = behavior.checks.states;
|
|
522
|
+
const results = new Uint8Array(checks.length);
|
|
523
|
+
checks.forEach((check, position) => {
|
|
524
|
+
results[position] = runCheck(check, state, row, offset) ? 1 : 0;
|
|
525
|
+
});
|
|
526
|
+
return results;
|
|
527
|
+
});
|
|
528
|
+
// Writes the result of each action check of the step to successor at resultOffset in results.
|
|
286
529
|
const checkAction = (
|
|
287
|
-
behavior: BehaviorGraph
|
|
530
|
+
behavior: BehaviorGraph<State>,
|
|
288
531
|
source: number,
|
|
289
|
-
state:
|
|
290
|
-
|
|
532
|
+
state: State,
|
|
533
|
+
row: Int8Array,
|
|
534
|
+
offset: number,
|
|
535
|
+
successor: State,
|
|
536
|
+
edges: Int8Array,
|
|
537
|
+
edgeOffset: number,
|
|
538
|
+
results: Uint8Array,
|
|
539
|
+
resultOffset: number,
|
|
291
540
|
) =>
|
|
292
541
|
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],
|
|
542
|
+
const actions = behavior.checks.actions;
|
|
543
|
+
for (let position = 0; position < actions.length; position++) {
|
|
544
|
+
if (!isShared) {
|
|
545
|
+
results[resultOffset + position] = runCheck(
|
|
546
|
+
actions[position],
|
|
308
547
|
state,
|
|
548
|
+
row,
|
|
549
|
+
offset,
|
|
309
550
|
successor,
|
|
310
|
-
evaluation.environment,
|
|
311
|
-
stateCache,
|
|
312
551
|
)
|
|
313
552
|
? 1
|
|
314
553
|
: 0;
|
|
554
|
+
continue;
|
|
315
555
|
}
|
|
316
|
-
|
|
317
|
-
|
|
556
|
+
const edge = edgeOffset + behavior.actionIds[position];
|
|
557
|
+
if (edges[edge] === -1)
|
|
558
|
+
edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
|
|
559
|
+
results[resultOffset + position] = edges[edge];
|
|
560
|
+
}
|
|
318
561
|
});
|
|
562
|
+
const holdsNode = (
|
|
563
|
+
behavior: BehaviorGraph<State>,
|
|
564
|
+
node: number,
|
|
565
|
+
state: State,
|
|
566
|
+
row: Int8Array,
|
|
567
|
+
offset: number,
|
|
568
|
+
) => {
|
|
569
|
+
const checks = behavior.checks.nodes[node];
|
|
570
|
+
if (!(checks instanceof Int32Array)) {
|
|
571
|
+
return checks.every((check) => runCheck(check, state, row, offset));
|
|
572
|
+
}
|
|
573
|
+
for (let position = 0; position < checks.length; position++) {
|
|
574
|
+
const literal: number = checks[position];
|
|
575
|
+
const cell = offset + (literal >> 1);
|
|
576
|
+
if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
|
|
577
|
+
if (row[cell] !== (literal & 1)) return false;
|
|
578
|
+
}
|
|
579
|
+
return true;
|
|
580
|
+
};
|
|
319
581
|
const isConsistent = (
|
|
320
|
-
|
|
582
|
+
behavior: BehaviorGraph<State>,
|
|
321
583
|
node: number,
|
|
322
584
|
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.
|
|
585
|
+
state: State,
|
|
586
|
+
row: Int8Array,
|
|
587
|
+
offset: number,
|
|
588
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
589
|
+
|
|
330
590
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
331
|
-
if (
|
|
591
|
+
if (!isAcceptingFound) return false;
|
|
332
592
|
const tableauNode = tableau.nodes[node];
|
|
333
593
|
return (
|
|
334
594
|
tableauNode.particle.length === 0 &&
|
|
@@ -336,22 +596,19 @@ export const createLivenessChecker = (
|
|
|
336
596
|
tableauNode.successors[0] === node
|
|
337
597
|
);
|
|
338
598
|
};
|
|
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
599
|
|
|
347
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
600
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
348
601
|
if (!behavior.solution.tableau) return state;
|
|
349
602
|
const slots = behavior.nodeIds.slots;
|
|
350
603
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
351
604
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
352
605
|
};
|
|
353
|
-
const
|
|
354
|
-
|
|
606
|
+
const linkNode = (
|
|
607
|
+
behavior: BehaviorGraph<State>,
|
|
608
|
+
state: number,
|
|
609
|
+
tableauNode: number,
|
|
610
|
+
node: number,
|
|
611
|
+
) => {
|
|
355
612
|
const table = behavior.nodeIds;
|
|
356
613
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
357
614
|
const old = table.slots;
|
|
@@ -367,24 +624,35 @@ export const createLivenessChecker = (
|
|
|
367
624
|
}
|
|
368
625
|
}
|
|
369
626
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
627
|
+
if (state < 0) return node;
|
|
370
628
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
371
629
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
372
630
|
else behavior.nextSiblings[last] = node;
|
|
373
631
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
374
632
|
return node;
|
|
375
633
|
};
|
|
634
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) =>
|
|
635
|
+
linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
|
|
636
|
+
// The action results of the edge to each target are at its position in actions.
|
|
376
637
|
const writeNode = (
|
|
377
|
-
behavior: BehaviorGraph
|
|
638
|
+
behavior: BehaviorGraph<State>,
|
|
378
639
|
node: number,
|
|
379
640
|
targets: number[],
|
|
380
|
-
|
|
641
|
+
actionResults: Uint8Array,
|
|
642
|
+
actions: number[],
|
|
381
643
|
stateResults: Uint8Array,
|
|
382
644
|
) => {
|
|
383
645
|
const start = behavior.edgeTargets.length;
|
|
384
646
|
const actionCount = behavior.solution.actionChecks.length;
|
|
385
647
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
386
|
-
actions.forEach((
|
|
387
|
-
writeToPool(
|
|
648
|
+
actions.forEach((position, edge) =>
|
|
649
|
+
writeToPool(
|
|
650
|
+
behavior.edgeActions,
|
|
651
|
+
(start + edge) * actionCount,
|
|
652
|
+
actionResults,
|
|
653
|
+
position * actionCount,
|
|
654
|
+
actionCount,
|
|
655
|
+
),
|
|
388
656
|
);
|
|
389
657
|
writeToPool(
|
|
390
658
|
behavior.stateResults,
|
|
@@ -395,66 +663,73 @@ export const createLivenessChecker = (
|
|
|
395
663
|
behavior.edgeCounts[node] = targets.length;
|
|
396
664
|
};
|
|
397
665
|
|
|
398
|
-
// TLC
|
|
399
|
-
//
|
|
400
|
-
|
|
401
|
-
const getSuccessorSet = (index: number, state:
|
|
402
|
-
const
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
const
|
|
666
|
+
// 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.
|
|
667
|
+
// Each slot holds a candidate's position plus one, or 0 when it is empty.
|
|
668
|
+
const successorSet = { slots: new Int32Array(0) };
|
|
669
|
+
const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
|
|
670
|
+
const candidates = [...successors, { index, state }];
|
|
671
|
+
const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
|
|
672
|
+
successorSet.slots =
|
|
673
|
+
successorSet.slots.length === capacity
|
|
674
|
+
? successorSet.slots.fill(0)
|
|
675
|
+
: new Int32Array(capacity);
|
|
676
|
+
const insert = (position: number) => {
|
|
677
|
+
const slots = successorSet.slots;
|
|
678
|
+
const candidate = candidates[position];
|
|
409
679
|
for (
|
|
410
|
-
let slot = (search.getFingerprint(
|
|
680
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
411
681
|
;
|
|
412
682
|
slot = (slot + 1) % slots.length
|
|
413
683
|
) {
|
|
414
684
|
const entry = slots[slot];
|
|
415
|
-
if (entry ===
|
|
416
|
-
slots[slot] =
|
|
685
|
+
if (entry === 0) {
|
|
686
|
+
slots[slot] = position + 1;
|
|
417
687
|
return true;
|
|
418
688
|
}
|
|
419
|
-
|
|
689
|
+
const stored = candidates[entry - 1];
|
|
690
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
420
691
|
return false;
|
|
421
692
|
}
|
|
422
693
|
};
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
694
|
+
let count = 0;
|
|
695
|
+
for (let position = 0; position < candidates.length; position++) {
|
|
696
|
+
if (count >= successorSet.slots.length >> 1) {
|
|
697
|
+
const old = successorSet.slots;
|
|
698
|
+
successorSet.slots = new Int32Array(2 * old.length + 1);
|
|
699
|
+
for (const entry of old) if (entry !== 0) insert(entry - 1);
|
|
428
700
|
}
|
|
429
|
-
if (
|
|
430
|
-
}
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
return
|
|
701
|
+
if (insert(position)) count++;
|
|
702
|
+
}
|
|
703
|
+
if (successorSet.slots.length > capacity) capacityMultiplier++;
|
|
704
|
+
const set: LiveSuccessor<State>[] = [];
|
|
705
|
+
for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
|
|
706
|
+
return set;
|
|
435
707
|
};
|
|
436
708
|
|
|
437
709
|
const expandLate = (
|
|
438
|
-
behavior: BehaviorGraph
|
|
710
|
+
behavior: BehaviorGraph<State>,
|
|
439
711
|
tableau: Tableau,
|
|
440
|
-
state:
|
|
712
|
+
state: State,
|
|
441
713
|
index: number,
|
|
442
714
|
node: number,
|
|
715
|
+
row: Int8Array,
|
|
716
|
+
offset: number,
|
|
443
717
|
) => {
|
|
444
|
-
const stateResults = checkState(behavior, index, state);
|
|
718
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
445
719
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
446
|
-
const
|
|
720
|
+
const actionCount = behavior.checks.actions.length;
|
|
721
|
+
const actions: number[] = [];
|
|
447
722
|
const successors: number[] = [];
|
|
448
|
-
const
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
723
|
+
const selfResults = new Uint8Array(actionCount);
|
|
724
|
+
if (tableauNode.successors.length > 0) {
|
|
725
|
+
checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
|
|
726
|
+
}
|
|
452
727
|
for (const next of tableauNode.successors) {
|
|
453
|
-
if (!isConsistent(
|
|
728
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
454
729
|
if (
|
|
455
730
|
isAccepting(tableau, next) &&
|
|
456
731
|
behavior.errorNode === undefined &&
|
|
457
|
-
|
|
732
|
+
behavior.solution.models.some(isEmptyModel)
|
|
458
733
|
) {
|
|
459
734
|
behavior.errorNode = node;
|
|
460
735
|
return;
|
|
@@ -463,89 +738,120 @@ export const createLivenessChecker = (
|
|
|
463
738
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
464
739
|
const target = existing ?? recordNode(behavior, index, next);
|
|
465
740
|
successors.push(target);
|
|
466
|
-
actions.push(
|
|
467
|
-
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
741
|
+
actions.push(0);
|
|
742
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
468
743
|
}
|
|
469
|
-
|
|
470
|
-
|
|
744
|
+
const nextStates = search.getSuccessors(index, state);
|
|
745
|
+
// The results of the step to the state itself come first, then those of each successor.
|
|
746
|
+
const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
|
|
747
|
+
actionResults.set(selfResults);
|
|
748
|
+
const edges = createEdgeRows(nextStates.length);
|
|
749
|
+
nextStates.forEach((successor, position) => {
|
|
750
|
+
const successorRow = createRows(1);
|
|
751
|
+
checkAction(
|
|
752
|
+
behavior,
|
|
753
|
+
index,
|
|
754
|
+
state,
|
|
755
|
+
row,
|
|
756
|
+
offset,
|
|
757
|
+
successor.state,
|
|
758
|
+
edges,
|
|
759
|
+
position * actionIds.size,
|
|
760
|
+
actionResults,
|
|
761
|
+
(position + 1) * actionCount,
|
|
762
|
+
);
|
|
471
763
|
const isDone = behavior.isDone[successor.index] === true;
|
|
472
764
|
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;
|
|
765
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
477
766
|
const existing = getNodeId(behavior, successor.index, next);
|
|
478
767
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
479
768
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
480
769
|
successors.push(target);
|
|
481
|
-
actions.push(
|
|
770
|
+
actions.push(position + 1);
|
|
482
771
|
if (existing === undefined && isDone) {
|
|
483
|
-
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
772
|
+
expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
|
|
484
773
|
}
|
|
485
774
|
}
|
|
775
|
+
});
|
|
776
|
+
if (successors.length > 0) {
|
|
777
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
486
778
|
}
|
|
487
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
488
779
|
};
|
|
489
780
|
|
|
490
781
|
const addTableauState = (
|
|
491
|
-
behavior: BehaviorGraph
|
|
782
|
+
behavior: BehaviorGraph<State>,
|
|
492
783
|
tableau: Tableau,
|
|
493
|
-
set: LiveSuccessor[],
|
|
494
|
-
|
|
784
|
+
set: LiveSuccessor<State>[],
|
|
785
|
+
rows: Int8Array,
|
|
786
|
+
actionResults: Uint8Array,
|
|
495
787
|
stateResults: Uint8Array,
|
|
496
788
|
index: number,
|
|
497
789
|
) => {
|
|
498
|
-
const
|
|
499
|
-
|
|
500
|
-
);
|
|
790
|
+
const atomCount = stateAtoms.size;
|
|
791
|
+
// Whether each successor is consistent with each tableau node, node by node.
|
|
792
|
+
const consistency = new Uint8Array(tableau.nodes.length * set.length);
|
|
793
|
+
evaluateFrom(index, () => {
|
|
794
|
+
for (let node = 0; node < tableau.nodes.length; node++) {
|
|
795
|
+
for (let position = 0; position < set.length; position++) {
|
|
796
|
+
if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
|
|
797
|
+
consistency[node * set.length + position] = 1;
|
|
798
|
+
}
|
|
799
|
+
}
|
|
800
|
+
}
|
|
801
|
+
});
|
|
501
802
|
behavior.isDone[index] = true;
|
|
502
803
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
503
804
|
for (const node of getStateNodes(behavior, index)) {
|
|
504
805
|
const successors: number[] = [];
|
|
505
|
-
const actions:
|
|
806
|
+
const actions: number[] = [];
|
|
506
807
|
set.forEach((successor, position) => {
|
|
507
808
|
const isDone = behavior.isDone[successor.index] === true;
|
|
508
809
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
509
|
-
if (
|
|
810
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
510
811
|
const existing = getNodeId(behavior, successor.index, next);
|
|
511
812
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
512
813
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
513
814
|
successors.push(target);
|
|
514
|
-
actions.push(
|
|
815
|
+
actions.push(position);
|
|
515
816
|
if (existing === undefined && isDone) {
|
|
516
|
-
expandLate(
|
|
817
|
+
expandLate(
|
|
818
|
+
behavior,
|
|
819
|
+
tableau,
|
|
820
|
+
successor.state,
|
|
821
|
+
successor.index,
|
|
822
|
+
target,
|
|
823
|
+
rows,
|
|
824
|
+
position * atomCount,
|
|
825
|
+
);
|
|
517
826
|
}
|
|
518
827
|
}
|
|
519
828
|
});
|
|
520
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
829
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
521
830
|
}
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
.reverse()
|
|
526
|
-
.map((node) => behavior.nodeStates[node]),
|
|
527
|
-
);
|
|
831
|
+
return behavior.errorNode === undefined
|
|
832
|
+
? undefined
|
|
833
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
528
834
|
};
|
|
529
835
|
|
|
530
836
|
const addPlainState = (
|
|
531
|
-
behavior: BehaviorGraph
|
|
532
|
-
set: LiveSuccessor[],
|
|
533
|
-
actionResults: Uint8Array
|
|
837
|
+
behavior: BehaviorGraph<State>,
|
|
838
|
+
set: LiveSuccessor<State>[],
|
|
839
|
+
actionResults: Uint8Array,
|
|
534
840
|
stateResults: Uint8Array,
|
|
535
841
|
index: number,
|
|
536
842
|
) => {
|
|
537
843
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
538
844
|
const successors: number[] = [];
|
|
539
|
-
const actions:
|
|
845
|
+
const actions: number[] = [];
|
|
540
846
|
set.forEach((successor, position) => {
|
|
541
847
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
542
848
|
successors.push(successor.index);
|
|
543
|
-
actions.push(
|
|
849
|
+
actions.push(position);
|
|
544
850
|
});
|
|
545
|
-
writeNode(behavior, index, successors, actions, stateResults);
|
|
851
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
546
852
|
};
|
|
547
853
|
|
|
548
|
-
const getPath = (behavior: BehaviorGraph
|
|
854
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
549
855
|
if (behavior.initial.includes(target)) return [target];
|
|
550
856
|
const parents = new Map<number, number>();
|
|
551
857
|
const queue: number[] = [];
|
|
@@ -571,9 +877,15 @@ export const createLivenessChecker = (
|
|
|
571
877
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
572
878
|
};
|
|
573
879
|
|
|
574
|
-
|
|
880
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
881
|
+
removeRepeats(
|
|
882
|
+
getPath(behavior, target)
|
|
883
|
+
.reverse()
|
|
884
|
+
.map((node) => behavior.nodeStates[node]),
|
|
885
|
+
);
|
|
886
|
+
|
|
575
887
|
const findLassoInModel = (
|
|
576
|
-
behavior: BehaviorGraph
|
|
888
|
+
behavior: BehaviorGraph<State>,
|
|
577
889
|
model: Solution["models"][number],
|
|
578
890
|
): Lasso | undefined => {
|
|
579
891
|
const solution = behavior.solution;
|
|
@@ -628,91 +940,85 @@ export const createLivenessChecker = (
|
|
|
628
940
|
return getLasso(root, members, membersByState);
|
|
629
941
|
};
|
|
630
942
|
|
|
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
943
|
const getLasso = (
|
|
634
944
|
root: number,
|
|
635
945
|
members: Set<number>,
|
|
636
946
|
membersByState: Map<number, number[]>,
|
|
637
947
|
) => {
|
|
638
|
-
const prefix =
|
|
639
|
-
getPath(behavior, root)
|
|
640
|
-
.reverse()
|
|
641
|
-
.map((node) => behavior.nodeStates[node]),
|
|
642
|
-
);
|
|
948
|
+
const prefix = getStatePath(behavior, root);
|
|
643
949
|
const cycleStack: number[] = [];
|
|
644
950
|
const seen = new Set<number>([root]);
|
|
645
951
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
646
952
|
const actionDone = model.infinitelyOftenActions.map(() => false);
|
|
647
953
|
const promiseDone = solution.promises.map(() => false);
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
const isMember = (node: number) => members.has(node);
|
|
954
|
+
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
955
|
+
let currentNode = root;
|
|
651
956
|
const moveTo = (next: number) => {
|
|
652
|
-
cycleStack.push(
|
|
653
|
-
|
|
957
|
+
cycleStack.push(currentNode);
|
|
958
|
+
currentNode = next;
|
|
654
959
|
};
|
|
655
|
-
while (
|
|
656
|
-
const countAtStart =
|
|
960
|
+
while (remainingCount > 0) {
|
|
961
|
+
const countAtStart = remainingCount;
|
|
657
962
|
while (true) {
|
|
658
963
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
659
|
-
if (!stateDone[slot] && getStateResult(behavior,
|
|
964
|
+
if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
|
|
660
965
|
stateDone[slot] = true;
|
|
661
|
-
|
|
966
|
+
remainingCount--;
|
|
662
967
|
}
|
|
663
968
|
});
|
|
664
969
|
solution.promises.forEach((promise, position) => {
|
|
665
|
-
if (!promiseDone[position] && isFulfilled(
|
|
970
|
+
if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
|
|
666
971
|
promiseDone[position] = true;
|
|
667
|
-
|
|
972
|
+
remainingCount--;
|
|
668
973
|
}
|
|
669
974
|
});
|
|
670
|
-
if (
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
const
|
|
975
|
+
if (remainingCount <= 0) break;
|
|
976
|
+
let lastNext = -1;
|
|
977
|
+
let unvisitedNext = -1;
|
|
978
|
+
const countBeforeActions = remainingCount;
|
|
979
|
+
const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
|
|
674
980
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
675
|
-
if (!
|
|
676
|
-
|
|
981
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
982
|
+
lastNext = next;
|
|
677
983
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
678
|
-
if (!actionDone[slot] && getAction(
|
|
984
|
+
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
679
985
|
actionDone[slot] = true;
|
|
680
|
-
|
|
986
|
+
remainingCount--;
|
|
681
987
|
}
|
|
682
988
|
});
|
|
683
989
|
}
|
|
684
|
-
if (
|
|
990
|
+
if (remainingCount < countBeforeActions) {
|
|
685
991
|
moveTo(next);
|
|
686
992
|
seen.clear();
|
|
687
993
|
return true;
|
|
688
994
|
}
|
|
689
|
-
if (
|
|
995
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
690
996
|
return false;
|
|
691
997
|
});
|
|
692
|
-
if (
|
|
693
|
-
if (
|
|
694
|
-
moveTo(
|
|
998
|
+
if (isTaken) break;
|
|
999
|
+
if (remainingCount < countAtStart) {
|
|
1000
|
+
moveTo(lastNext);
|
|
695
1001
|
seen.clear();
|
|
696
1002
|
break;
|
|
697
1003
|
}
|
|
698
|
-
while (
|
|
1004
|
+
while (unvisitedNext === -1) {
|
|
699
1005
|
const previous = cycleStack.pop();
|
|
700
1006
|
if (previous === undefined) {
|
|
701
1007
|
throw new TlaEvaluationError(
|
|
702
1008
|
"TLC failed to build the counterexample of a liveness property",
|
|
703
1009
|
);
|
|
704
1010
|
}
|
|
705
|
-
|
|
706
|
-
|
|
1011
|
+
currentNode = previous;
|
|
1012
|
+
unvisitedNext =
|
|
707
1013
|
getNodeSuccessors(behavior, previous).find(
|
|
708
|
-
(next) =>
|
|
1014
|
+
(next) => members.has(next) && !seen.has(next),
|
|
709
1015
|
) ?? -1;
|
|
710
1016
|
}
|
|
711
|
-
moveTo(
|
|
712
|
-
seen.add(
|
|
1017
|
+
moveTo(unvisitedNext);
|
|
1018
|
+
seen.add(unvisitedNext);
|
|
713
1019
|
}
|
|
714
1020
|
}
|
|
715
|
-
const postfix = getClosingPath(root,
|
|
1021
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
716
1022
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
717
1023
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
718
1024
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -726,12 +1032,7 @@ export const createLivenessChecker = (
|
|
|
726
1032
|
};
|
|
727
1033
|
};
|
|
728
1034
|
|
|
729
|
-
const getClosingPath = (
|
|
730
|
-
root: number,
|
|
731
|
-
end: number,
|
|
732
|
-
membersByState: Map<number, number[]>,
|
|
733
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
734
|
-
) => {
|
|
1035
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
735
1036
|
if (end === root) return [];
|
|
736
1037
|
const start = behavior.nodeStates[end];
|
|
737
1038
|
const parents = new Map<number, number>();
|
|
@@ -740,7 +1041,7 @@ export const createLivenessChecker = (
|
|
|
740
1041
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
741
1042
|
for (const node of membersByState.get(state) ?? []) {
|
|
742
1043
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
743
|
-
if (next === node || !
|
|
1044
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
744
1045
|
if (next === root) {
|
|
745
1046
|
const path: number[] = [];
|
|
746
1047
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -771,7 +1072,7 @@ export const createLivenessChecker = (
|
|
|
771
1072
|
|
|
772
1073
|
for (let position = 0; position < queue.length; position++) {
|
|
773
1074
|
const stack = [queue[position], UNVISITED, 0];
|
|
774
|
-
|
|
1075
|
+
let nextLink = 0;
|
|
775
1076
|
while (stack.length >= 3) {
|
|
776
1077
|
const lowLink = stack.pop() ?? 0;
|
|
777
1078
|
const location = stack.pop();
|
|
@@ -788,10 +1089,10 @@ export const createLivenessChecker = (
|
|
|
788
1089
|
stack.push(Math.min(lowLink, links[node]));
|
|
789
1090
|
continue;
|
|
790
1091
|
}
|
|
791
|
-
links[node] =
|
|
1092
|
+
links[node] = nextLink;
|
|
792
1093
|
stack.push(lowLink, node, SCC_MARKER);
|
|
793
1094
|
components.push(node);
|
|
794
|
-
|
|
1095
|
+
let nextLowLink = nextLink++;
|
|
795
1096
|
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
796
1097
|
if (!isWritten(behavior, next)) return;
|
|
797
1098
|
if (!isAllowed(node, edge)) {
|
|
@@ -799,9 +1100,9 @@ export const createLivenessChecker = (
|
|
|
799
1100
|
return;
|
|
800
1101
|
}
|
|
801
1102
|
if (links[next] === UNVISITED) stack.push(next, UNVISITED);
|
|
802
|
-
else nextLowLink
|
|
1103
|
+
else nextLowLink = Math.min(nextLowLink, links[next]);
|
|
803
1104
|
});
|
|
804
|
-
stack.push(nextLowLink
|
|
1105
|
+
stack.push(nextLowLink);
|
|
805
1106
|
}
|
|
806
1107
|
}
|
|
807
1108
|
return undefined;
|
|
@@ -809,57 +1110,77 @@ export const createLivenessChecker = (
|
|
|
809
1110
|
|
|
810
1111
|
return {
|
|
811
1112
|
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
|
-
}
|
|
1113
|
+
addInitialState: (index, state) => {
|
|
1114
|
+
const row = createRows(1);
|
|
1115
|
+
for (const behavior of behaviors) {
|
|
1116
|
+
const tableau = behavior.solution.tableau;
|
|
1117
|
+
if (!tableau) {
|
|
1118
|
+
behavior.initial.push(index);
|
|
1119
|
+
continue;
|
|
1120
|
+
}
|
|
1121
|
+
for (let node = 0; node < tableau.initialCount; node++) {
|
|
1122
|
+
if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
|
|
1123
|
+
behavior.initial.push(
|
|
1124
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
1125
|
+
);
|
|
829
1126
|
}
|
|
830
|
-
} finally {
|
|
831
|
-
evaluation.environment = environment;
|
|
832
1127
|
}
|
|
833
1128
|
},
|
|
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(
|
|
1129
|
+
addState: (index, state, successors) => {
|
|
1130
|
+
const set = getSuccessorSet(index, state, successors);
|
|
1131
|
+
const rows = createRows(set.length);
|
|
1132
|
+
// The set holds the state itself, as a successor of the same index.
|
|
1133
|
+
const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
|
|
1134
|
+
const edges = createEdgeRows(set.length);
|
|
1135
|
+
for (const behavior of behaviors) {
|
|
1136
|
+
const actionCount = behavior.checks.actions.length;
|
|
1137
|
+
const actionResults = new Uint8Array(set.length * actionCount);
|
|
1138
|
+
set.forEach((successor, position) =>
|
|
1139
|
+
checkAction(
|
|
851
1140
|
behavior,
|
|
852
|
-
tableau,
|
|
853
|
-
set,
|
|
854
|
-
actionResults,
|
|
855
|
-
stateResults,
|
|
856
1141
|
index,
|
|
857
|
-
|
|
858
|
-
|
|
1142
|
+
state,
|
|
1143
|
+
rows,
|
|
1144
|
+
offset,
|
|
1145
|
+
successor.state,
|
|
1146
|
+
edges,
|
|
1147
|
+
position * actionIds.size,
|
|
1148
|
+
actionResults,
|
|
1149
|
+
position * actionCount,
|
|
1150
|
+
),
|
|
1151
|
+
);
|
|
1152
|
+
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1153
|
+
const tableau = behavior.solution.tableau;
|
|
1154
|
+
if (!tableau) {
|
|
1155
|
+
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1156
|
+
continue;
|
|
1157
|
+
}
|
|
1158
|
+
const accepted = addTableauState(
|
|
1159
|
+
behavior,
|
|
1160
|
+
tableau,
|
|
1161
|
+
set,
|
|
1162
|
+
rows,
|
|
1163
|
+
actionResults,
|
|
1164
|
+
stateResults,
|
|
1165
|
+
index,
|
|
1166
|
+
);
|
|
1167
|
+
if (accepted) return accepted;
|
|
1168
|
+
}
|
|
1169
|
+
return undefined;
|
|
1170
|
+
},
|
|
1171
|
+
storeState: (pending, index) => {
|
|
1172
|
+
for (const behavior of behaviors) {
|
|
1173
|
+
const tableau = behavior.solution.tableau;
|
|
1174
|
+
if (!tableau) continue;
|
|
1175
|
+
const nodes: number[] = [];
|
|
1176
|
+
for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
|
|
1177
|
+
const node = getNodeId(behavior, pending, tableauNode);
|
|
1178
|
+
if (node !== undefined) nodes.push(node);
|
|
1179
|
+
}
|
|
1180
|
+
for (const node of nodes.sort((left, right) => left - right)) {
|
|
1181
|
+
behavior.nodeStates[node] = index;
|
|
1182
|
+
linkNode(behavior, index, behavior.nodeTableaux[node], node);
|
|
859
1183
|
}
|
|
860
|
-
return undefined;
|
|
861
|
-
} finally {
|
|
862
|
-
evaluation.environment = environment;
|
|
863
1184
|
}
|
|
864
1185
|
},
|
|
865
1186
|
findViolation: () => {
|
|
@@ -871,16 +1192,5 @@ export const createLivenessChecker = (
|
|
|
871
1192
|
}
|
|
872
1193
|
return undefined;
|
|
873
1194
|
},
|
|
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
1195
|
};
|
|
886
1196
|
};
|