tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.37a75eb5b
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 +4 -1
- package/dist/index.d.ts +4 -1
- 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 +43 -42
- package/dist/run.js +45 -44
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -40
- package/dist/transfer.js +42 -39
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +41 -36
- package/src/bags.ts +47 -28
- package/src/builtins.ts +4 -13
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +268 -0
- package/src/check.ts +476 -590
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +686 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +60 -708
- 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 +25 -18
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +73 -338
- package/src/errors.ts +33 -5
- package/src/evaluate.ts +14 -7
- 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/json.ts +4 -7
- package/src/levels.ts +42 -44
- package/src/lexer.ts +5 -3
- package/src/liveness-checker.ts +597 -240
- package/src/liveness.ts +94 -86
- 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 +29 -47
- package/src/parser.ts +652 -220
- package/src/pretty-print.ts +1 -1
- 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 +93 -15
- 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 +536 -117
- 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 +907 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1205 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1050 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +830 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +335 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +267 -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 +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -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 +177 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -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 +68 -17
- 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 +163 -99
- 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 +410 -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 +1407 -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 +219 -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 +315 -97
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +464 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2410 -683
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +40 -19
- 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 +792 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -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 +311 -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 +22 -25
- 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 +44 -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 +90 -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 +1704 -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 +1995 -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/resolve.ts +127 -108
- package/src/runtime.ts +6 -0
- package/src/sany/generation.ts +382 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1092 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +155 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +17 -16
- package/src/sany/linter.ts +0 -2
- 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 +243 -52
- package/src/simulate.ts +160 -133
- package/src/spec-description.ts +33 -48
- package/src/standard-definitions.ts +4 -0
- package/src/standard-modules.ts +16 -32
- package/src/state-graph.ts +2 -9
- package/src/subexpressions.ts +3 -1
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +6 -8
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +12 -0
- package/src/tlc/messages.ts +20 -15
- package/src/tlc/order.ts +16 -12
- package/src/tlc/random.ts +4 -4
- package/src/tlc/replay.ts +8 -15
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +2 -3
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +26 -47
- 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 +63 -158
- 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,15 +15,18 @@ 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 {
|
|
@@ -32,6 +37,7 @@ export interface Lasso {
|
|
|
32
37
|
|
|
33
38
|
export interface LivenessChecker {
|
|
34
39
|
branches: number;
|
|
40
|
+
solutions: Solution[];
|
|
35
41
|
addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
|
|
36
42
|
addState: (
|
|
37
43
|
index: number,
|
|
@@ -39,13 +45,39 @@ export interface LivenessChecker {
|
|
|
39
45
|
successors: LiveSuccessor[],
|
|
40
46
|
tracing?: Environment,
|
|
41
47
|
) => number[] | undefined;
|
|
48
|
+
storeState: (pending: number, index: number) => void;
|
|
49
|
+
getStateCounts: () => number[];
|
|
42
50
|
findViolation: () => Lasso | undefined;
|
|
43
51
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
44
52
|
}
|
|
45
53
|
|
|
46
|
-
interface
|
|
47
|
-
|
|
48
|
-
|
|
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;
|
|
49
81
|
}
|
|
50
82
|
|
|
51
83
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
@@ -54,8 +86,25 @@ interface Pool<Data extends Int32Array | Uint8Array> {
|
|
|
54
86
|
create: (length: number) => Data;
|
|
55
87
|
}
|
|
56
88
|
|
|
57
|
-
|
|
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> {
|
|
58
106
|
solution: Solution;
|
|
107
|
+
checks: BehaviorChecks<State>;
|
|
59
108
|
actionIds: Int32Array;
|
|
60
109
|
nodeStates: number[];
|
|
61
110
|
nodeTableaux: number[];
|
|
@@ -70,6 +119,7 @@ interface BehaviorGraph {
|
|
|
70
119
|
nextSiblings: number[];
|
|
71
120
|
nodeIds: NodeTable;
|
|
72
121
|
isDone: boolean[];
|
|
122
|
+
stateCount: number;
|
|
73
123
|
errorNode: number | undefined;
|
|
74
124
|
}
|
|
75
125
|
|
|
@@ -89,14 +139,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
|
|
|
89
139
|
}
|
|
90
140
|
};
|
|
91
141
|
|
|
142
|
+
const isEmptyModel = (model: Solution["models"][number]) =>
|
|
143
|
+
model.eventuallyAlways.length === 0 &&
|
|
144
|
+
model.infinitelyOftenStates.length === 0 &&
|
|
145
|
+
model.infinitelyOftenActions.length === 0;
|
|
146
|
+
|
|
92
147
|
const isCycleConstrained = (solution: Solution) =>
|
|
93
148
|
solution.promises.some((promise) => containsAlways(promise.body)) ||
|
|
94
|
-
solution.models.some(
|
|
95
|
-
(model) =>
|
|
96
|
-
model.eventuallyAlways.length > 0 ||
|
|
97
|
-
model.infinitelyOftenStates.length > 0 ||
|
|
98
|
-
model.infinitelyOftenActions.length > 0,
|
|
99
|
-
);
|
|
149
|
+
solution.models.some((model) => !isEmptyModel(model));
|
|
100
150
|
|
|
101
151
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
102
152
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
@@ -112,14 +162,18 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
112
162
|
pool: Pool<Data>,
|
|
113
163
|
offset: number,
|
|
114
164
|
values: ArrayLike<number>,
|
|
165
|
+
start = 0,
|
|
166
|
+
length = values.length - start,
|
|
115
167
|
) => {
|
|
116
|
-
const end = offset +
|
|
168
|
+
const end = offset + length;
|
|
117
169
|
if (end > pool.data.length) {
|
|
118
170
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
119
171
|
data.set(pool.data);
|
|
120
172
|
pool.data = data;
|
|
121
173
|
}
|
|
122
|
-
|
|
174
|
+
for (let position = 0; position < length; position++) {
|
|
175
|
+
pool.data[offset + position] = values[start + position];
|
|
176
|
+
}
|
|
123
177
|
pool.length = Math.max(pool.length, end);
|
|
124
178
|
};
|
|
125
179
|
|
|
@@ -148,20 +202,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
148
202
|
|
|
149
203
|
const UNWRITTEN = -1;
|
|
150
204
|
|
|
151
|
-
const isWritten = (behavior: BehaviorGraph
|
|
205
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
152
206
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
153
207
|
|
|
154
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
208
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
155
209
|
const start = behavior.edgeStarts[node];
|
|
156
210
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
157
211
|
};
|
|
158
212
|
|
|
159
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
213
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
160
214
|
behavior.stateResults.data[
|
|
161
215
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
162
216
|
] === 1;
|
|
163
217
|
|
|
164
|
-
const pushNode = (behavior: BehaviorGraph
|
|
218
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
165
219
|
behavior.nodeStates.push(state);
|
|
166
220
|
behavior.nodeTableaux.push(tableauNode);
|
|
167
221
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -170,7 +224,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
170
224
|
return behavior.nodeStates.length - 1;
|
|
171
225
|
};
|
|
172
226
|
|
|
173
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
227
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
174
228
|
const nodes: number[] = [];
|
|
175
229
|
for (
|
|
176
230
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -190,13 +244,11 @@ const UNVISITED = -1;
|
|
|
190
244
|
|
|
191
245
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
192
246
|
|
|
193
|
-
|
|
247
|
+
const getLiveFormula = (
|
|
194
248
|
properties: TemporalProperty[],
|
|
195
249
|
temporals: ScopedExpression[],
|
|
196
250
|
environment: Environment,
|
|
197
|
-
|
|
198
|
-
): LivenessChecker | undefined => {
|
|
199
|
-
if (properties.length === 0) return undefined;
|
|
251
|
+
) => {
|
|
200
252
|
const fairness = temporals.map((item) =>
|
|
201
253
|
toLiveExpression(item.expression, item.scope, environment),
|
|
202
254
|
);
|
|
@@ -206,10 +258,242 @@ export const createLivenessChecker = (
|
|
|
206
258
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
207
259
|
const formula =
|
|
208
260
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
209
|
-
|
|
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> => {
|
|
210
397
|
const actionIds = new Map<string, number>();
|
|
211
|
-
|
|
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> => ({
|
|
212
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
|
+
},
|
|
213
497
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
214
498
|
const key = getTermKey(predicate);
|
|
215
499
|
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
@@ -229,85 +513,88 @@ export const createLivenessChecker = (
|
|
|
229
513
|
nextSiblings: [],
|
|
230
514
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
231
515
|
isDone: [],
|
|
516
|
+
stateCount: 0,
|
|
232
517
|
errorNode: undefined,
|
|
233
518
|
}));
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
environment.runtime.setLivenessSource(undefined);
|
|
251
|
-
}
|
|
252
|
-
};
|
|
253
|
-
const evaluateState = (predicate: LiveExpression, state: Value[]) =>
|
|
254
|
-
evaluateLive(
|
|
255
|
-
predicate,
|
|
256
|
-
state,
|
|
257
|
-
undefined,
|
|
258
|
-
evaluationEnvironment,
|
|
259
|
-
isShared ? getStateCache(state) : new Map(),
|
|
260
|
-
);
|
|
261
|
-
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
262
|
-
evaluateFrom(source, () =>
|
|
263
|
-
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
264
|
-
evaluateState(predicate, state) ? 1 : 0,
|
|
265
|
-
),
|
|
266
|
-
);
|
|
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.
|
|
267
535
|
const checkAction = (
|
|
268
|
-
behavior: BehaviorGraph
|
|
536
|
+
behavior: BehaviorGraph<State>,
|
|
269
537
|
source: number,
|
|
270
|
-
state:
|
|
271
|
-
|
|
538
|
+
state: State,
|
|
539
|
+
row: Int8Array,
|
|
540
|
+
offset: number,
|
|
541
|
+
successor: State,
|
|
542
|
+
edges: Int8Array,
|
|
543
|
+
edgeOffset: number,
|
|
544
|
+
results: Uint8Array,
|
|
545
|
+
resultOffset: number,
|
|
272
546
|
) =>
|
|
273
547
|
evaluateFrom(source, () => {
|
|
274
|
-
const
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
}
|
|
280
|
-
const stateCache = getStateCache(state);
|
|
281
|
-
const results = sharedActions.get(state) ?? new Map<Value[], Int8Array>();
|
|
282
|
-
sharedActions.set(state, results);
|
|
283
|
-
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
284
|
-
results.set(successor, known);
|
|
285
|
-
return Uint8Array.from(behavior.actionIds, (actionId, position) => {
|
|
286
|
-
if (known[actionId] === -1) {
|
|
287
|
-
known[actionId] = evaluateLive(
|
|
288
|
-
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],
|
|
289
553
|
state,
|
|
554
|
+
row,
|
|
555
|
+
offset,
|
|
290
556
|
successor,
|
|
291
|
-
evaluationEnvironment,
|
|
292
|
-
stateCache,
|
|
293
557
|
)
|
|
294
558
|
? 1
|
|
295
559
|
: 0;
|
|
560
|
+
continue;
|
|
296
561
|
}
|
|
297
|
-
|
|
298
|
-
|
|
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
|
+
}
|
|
299
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
|
+
};
|
|
300
587
|
const isConsistent = (
|
|
301
|
-
|
|
588
|
+
behavior: BehaviorGraph<State>,
|
|
302
589
|
node: number,
|
|
303
590
|
source: number | undefined,
|
|
304
|
-
state:
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
591
|
+
state: State,
|
|
592
|
+
row: Int8Array,
|
|
593
|
+
offset: number,
|
|
594
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
595
|
+
|
|
309
596
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
310
|
-
if (
|
|
597
|
+
if (!isAcceptingFound) return false;
|
|
311
598
|
const tableauNode = tableau.nodes[node];
|
|
312
599
|
return (
|
|
313
600
|
tableauNode.particle.length === 0 &&
|
|
@@ -315,22 +602,19 @@ export const createLivenessChecker = (
|
|
|
315
602
|
tableauNode.successors[0] === node
|
|
316
603
|
);
|
|
317
604
|
};
|
|
318
|
-
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
319
|
-
behavior.solution.models.some(
|
|
320
|
-
(model) =>
|
|
321
|
-
model.eventuallyAlways.length === 0 &&
|
|
322
|
-
model.infinitelyOftenStates.length === 0 &&
|
|
323
|
-
model.infinitelyOftenActions.length === 0,
|
|
324
|
-
);
|
|
325
605
|
|
|
326
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
606
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
327
607
|
if (!behavior.solution.tableau) return state;
|
|
328
608
|
const slots = behavior.nodeIds.slots;
|
|
329
609
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
330
610
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
331
611
|
};
|
|
332
|
-
const
|
|
333
|
-
|
|
612
|
+
const linkNode = (
|
|
613
|
+
behavior: BehaviorGraph<State>,
|
|
614
|
+
state: number,
|
|
615
|
+
tableauNode: number,
|
|
616
|
+
node: number,
|
|
617
|
+
) => {
|
|
334
618
|
const table = behavior.nodeIds;
|
|
335
619
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
336
620
|
const old = table.slots;
|
|
@@ -346,24 +630,44 @@ export const createLivenessChecker = (
|
|
|
346
630
|
}
|
|
347
631
|
}
|
|
348
632
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
633
|
+
if (state < 0) return node;
|
|
349
634
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
350
635
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
351
636
|
else behavior.nextSiblings[last] = node;
|
|
352
637
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
353
638
|
return node;
|
|
354
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.
|
|
355
652
|
const writeNode = (
|
|
356
|
-
behavior: BehaviorGraph
|
|
653
|
+
behavior: BehaviorGraph<State>,
|
|
357
654
|
node: number,
|
|
358
655
|
targets: number[],
|
|
359
|
-
|
|
656
|
+
actionResults: Uint8Array,
|
|
657
|
+
actions: number[],
|
|
360
658
|
stateResults: Uint8Array,
|
|
361
659
|
) => {
|
|
362
660
|
const start = behavior.edgeTargets.length;
|
|
363
661
|
const actionCount = behavior.solution.actionChecks.length;
|
|
364
662
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
365
|
-
actions.forEach((
|
|
366
|
-
writeToPool(
|
|
663
|
+
actions.forEach((position, edge) =>
|
|
664
|
+
writeToPool(
|
|
665
|
+
behavior.edgeActions,
|
|
666
|
+
(start + edge) * actionCount,
|
|
667
|
+
actionResults,
|
|
668
|
+
position * actionCount,
|
|
669
|
+
actionCount,
|
|
670
|
+
),
|
|
367
671
|
);
|
|
368
672
|
writeToPool(
|
|
369
673
|
behavior.stateResults,
|
|
@@ -375,61 +679,72 @@ export const createLivenessChecker = (
|
|
|
375
679
|
};
|
|
376
680
|
|
|
377
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.
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
}
|
|
382
|
-
|
|
383
|
-
|
|
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];
|
|
384
694
|
for (
|
|
385
|
-
let slot = (search.getFingerprint(
|
|
695
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
386
696
|
;
|
|
387
697
|
slot = (slot + 1) % slots.length
|
|
388
698
|
) {
|
|
389
699
|
const entry = slots[slot];
|
|
390
|
-
if (entry ===
|
|
391
|
-
slots[slot] =
|
|
700
|
+
if (entry === 0) {
|
|
701
|
+
slots[slot] = position + 1;
|
|
392
702
|
return true;
|
|
393
703
|
}
|
|
394
|
-
|
|
704
|
+
const stored = candidates[entry - 1];
|
|
705
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
395
706
|
return false;
|
|
396
707
|
}
|
|
397
708
|
};
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
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);
|
|
403
715
|
}
|
|
404
|
-
if (
|
|
405
|
-
}
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
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;
|
|
410
722
|
};
|
|
411
723
|
|
|
412
724
|
const expandLate = (
|
|
413
|
-
behavior: BehaviorGraph
|
|
725
|
+
behavior: BehaviorGraph<State>,
|
|
414
726
|
tableau: Tableau,
|
|
415
|
-
state:
|
|
727
|
+
state: State,
|
|
416
728
|
index: number,
|
|
417
729
|
node: number,
|
|
730
|
+
row: Int8Array,
|
|
731
|
+
offset: number,
|
|
418
732
|
) => {
|
|
419
|
-
const stateResults = checkState(behavior, index, state);
|
|
733
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
420
734
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
421
|
-
const
|
|
735
|
+
const actionCount = behavior.checks.actions.length;
|
|
736
|
+
const actions: number[] = [];
|
|
422
737
|
const successors: number[] = [];
|
|
423
|
-
const
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
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
|
+
}
|
|
427
742
|
for (const next of tableauNode.successors) {
|
|
428
|
-
if (!isConsistent(
|
|
743
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
429
744
|
if (
|
|
430
745
|
isAccepting(tableau, next) &&
|
|
431
746
|
behavior.errorNode === undefined &&
|
|
432
|
-
|
|
747
|
+
behavior.solution.models.some(isEmptyModel)
|
|
433
748
|
) {
|
|
434
749
|
behavior.errorNode = node;
|
|
435
750
|
return;
|
|
@@ -438,88 +753,122 @@ export const createLivenessChecker = (
|
|
|
438
753
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
439
754
|
const target = existing ?? recordNode(behavior, index, next);
|
|
440
755
|
successors.push(target);
|
|
441
|
-
actions.push(
|
|
442
|
-
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);
|
|
443
758
|
}
|
|
444
|
-
|
|
445
|
-
|
|
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
|
+
);
|
|
446
778
|
const isDone = behavior.isDone[successor.index] === true;
|
|
447
779
|
for (const next of tableauNode.successors) {
|
|
448
|
-
if (!isConsistent(
|
|
449
|
-
// Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
|
|
450
|
-
if (successor.index === -1) continue;
|
|
780
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
451
781
|
const existing = getNodeId(behavior, successor.index, next);
|
|
452
782
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
453
783
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
454
784
|
successors.push(target);
|
|
455
|
-
actions.push(
|
|
785
|
+
actions.push(position + 1);
|
|
456
786
|
if (existing === undefined && isDone) {
|
|
457
|
-
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
787
|
+
expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
|
|
458
788
|
}
|
|
459
789
|
}
|
|
790
|
+
});
|
|
791
|
+
if (successors.length > 0) {
|
|
792
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
460
793
|
}
|
|
461
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
462
794
|
};
|
|
463
795
|
|
|
464
796
|
const addTableauState = (
|
|
465
|
-
behavior: BehaviorGraph
|
|
797
|
+
behavior: BehaviorGraph<State>,
|
|
466
798
|
tableau: Tableau,
|
|
467
|
-
set: LiveSuccessor[],
|
|
468
|
-
|
|
799
|
+
set: LiveSuccessor<State>[],
|
|
800
|
+
rows: Int8Array,
|
|
801
|
+
actionResults: Uint8Array,
|
|
469
802
|
stateResults: Uint8Array,
|
|
470
803
|
index: number,
|
|
471
804
|
) => {
|
|
472
|
-
const
|
|
473
|
-
|
|
474
|
-
);
|
|
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++;
|
|
475
818
|
behavior.isDone[index] = true;
|
|
476
819
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
477
820
|
for (const node of getStateNodes(behavior, index)) {
|
|
478
821
|
const successors: number[] = [];
|
|
479
|
-
const actions:
|
|
822
|
+
const actions: number[] = [];
|
|
480
823
|
set.forEach((successor, position) => {
|
|
481
824
|
const isDone = behavior.isDone[successor.index] === true;
|
|
482
825
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
483
|
-
if (
|
|
826
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
484
827
|
const existing = getNodeId(behavior, successor.index, next);
|
|
485
828
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
486
829
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
487
830
|
successors.push(target);
|
|
488
|
-
actions.push(
|
|
831
|
+
actions.push(position);
|
|
489
832
|
if (existing === undefined && isDone) {
|
|
490
|
-
expandLate(
|
|
833
|
+
expandLate(
|
|
834
|
+
behavior,
|
|
835
|
+
tableau,
|
|
836
|
+
successor.state,
|
|
837
|
+
successor.index,
|
|
838
|
+
target,
|
|
839
|
+
rows,
|
|
840
|
+
position * atomCount,
|
|
841
|
+
);
|
|
491
842
|
}
|
|
492
843
|
}
|
|
493
844
|
});
|
|
494
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
845
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
495
846
|
}
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
.reverse()
|
|
500
|
-
.map((node) => behavior.nodeStates[node]),
|
|
501
|
-
);
|
|
847
|
+
return behavior.errorNode === undefined
|
|
848
|
+
? undefined
|
|
849
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
502
850
|
};
|
|
503
851
|
|
|
504
852
|
const addPlainState = (
|
|
505
|
-
behavior: BehaviorGraph
|
|
506
|
-
set: LiveSuccessor[],
|
|
507
|
-
actionResults: Uint8Array
|
|
853
|
+
behavior: BehaviorGraph<State>,
|
|
854
|
+
set: LiveSuccessor<State>[],
|
|
855
|
+
actionResults: Uint8Array,
|
|
508
856
|
stateResults: Uint8Array,
|
|
509
857
|
index: number,
|
|
510
858
|
) => {
|
|
511
859
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
512
860
|
const successors: number[] = [];
|
|
513
|
-
const actions:
|
|
861
|
+
const actions: number[] = [];
|
|
514
862
|
set.forEach((successor, position) => {
|
|
515
863
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
516
864
|
successors.push(successor.index);
|
|
517
|
-
actions.push(
|
|
865
|
+
actions.push(position);
|
|
518
866
|
});
|
|
519
|
-
|
|
867
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
868
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
520
869
|
};
|
|
521
870
|
|
|
522
|
-
const getPath = (behavior: BehaviorGraph
|
|
871
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
523
872
|
if (behavior.initial.includes(target)) return [target];
|
|
524
873
|
const parents = new Map<number, number>();
|
|
525
874
|
const queue: number[] = [];
|
|
@@ -545,8 +894,15 @@ export const createLivenessChecker = (
|
|
|
545
894
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
546
895
|
};
|
|
547
896
|
|
|
897
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
898
|
+
removeRepeats(
|
|
899
|
+
getPath(behavior, target)
|
|
900
|
+
.reverse()
|
|
901
|
+
.map((node) => behavior.nodeStates[node]),
|
|
902
|
+
);
|
|
903
|
+
|
|
548
904
|
const findLassoInModel = (
|
|
549
|
-
behavior: BehaviorGraph
|
|
905
|
+
behavior: BehaviorGraph<State>,
|
|
550
906
|
model: Solution["models"][number],
|
|
551
907
|
): Lasso | undefined => {
|
|
552
908
|
const solution = behavior.solution;
|
|
@@ -606,11 +962,7 @@ export const createLivenessChecker = (
|
|
|
606
962
|
members: Set<number>,
|
|
607
963
|
membersByState: Map<number, number[]>,
|
|
608
964
|
) => {
|
|
609
|
-
const prefix =
|
|
610
|
-
getPath(behavior, root)
|
|
611
|
-
.reverse()
|
|
612
|
-
.map((node) => behavior.nodeStates[node]),
|
|
613
|
-
);
|
|
965
|
+
const prefix = getStatePath(behavior, root);
|
|
614
966
|
const cycleStack: number[] = [];
|
|
615
967
|
const seen = new Set<number>([root]);
|
|
616
968
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
@@ -618,7 +970,6 @@ export const createLivenessChecker = (
|
|
|
618
970
|
const promiseDone = solution.promises.map(() => false);
|
|
619
971
|
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
620
972
|
let currentNode = root;
|
|
621
|
-
const isMember = (node: number) => members.has(node);
|
|
622
973
|
const moveTo = (next: number) => {
|
|
623
974
|
cycleStack.push(currentNode);
|
|
624
975
|
currentNode = next;
|
|
@@ -644,7 +995,7 @@ export const createLivenessChecker = (
|
|
|
644
995
|
const countBeforeActions = remainingCount;
|
|
645
996
|
const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
|
|
646
997
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
647
|
-
if (!
|
|
998
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
648
999
|
lastNext = next;
|
|
649
1000
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
650
1001
|
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
@@ -658,7 +1009,7 @@ export const createLivenessChecker = (
|
|
|
658
1009
|
seen.clear();
|
|
659
1010
|
return true;
|
|
660
1011
|
}
|
|
661
|
-
if (
|
|
1012
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
662
1013
|
return false;
|
|
663
1014
|
});
|
|
664
1015
|
if (isTaken) break;
|
|
@@ -677,14 +1028,14 @@ export const createLivenessChecker = (
|
|
|
677
1028
|
currentNode = previous;
|
|
678
1029
|
unvisitedNext =
|
|
679
1030
|
getNodeSuccessors(behavior, previous).find(
|
|
680
|
-
(next) =>
|
|
1031
|
+
(next) => members.has(next) && !seen.has(next),
|
|
681
1032
|
) ?? -1;
|
|
682
1033
|
}
|
|
683
1034
|
moveTo(unvisitedNext);
|
|
684
1035
|
seen.add(unvisitedNext);
|
|
685
1036
|
}
|
|
686
1037
|
}
|
|
687
|
-
const postfix = getClosingPath(root, currentNode, membersByState
|
|
1038
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
688
1039
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
689
1040
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
690
1041
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -698,12 +1049,7 @@ export const createLivenessChecker = (
|
|
|
698
1049
|
};
|
|
699
1050
|
};
|
|
700
1051
|
|
|
701
|
-
const getClosingPath = (
|
|
702
|
-
root: number,
|
|
703
|
-
end: number,
|
|
704
|
-
membersByState: Map<number, number[]>,
|
|
705
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
706
|
-
) => {
|
|
1052
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
707
1053
|
if (end === root) return [];
|
|
708
1054
|
const start = behavior.nodeStates[end];
|
|
709
1055
|
const parents = new Map<number, number>();
|
|
@@ -712,7 +1058,7 @@ export const createLivenessChecker = (
|
|
|
712
1058
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
713
1059
|
for (const node of membersByState.get(state) ?? []) {
|
|
714
1060
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
715
|
-
if (next === node || !
|
|
1061
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
716
1062
|
if (next === root) {
|
|
717
1063
|
const path: number[] = [];
|
|
718
1064
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -781,59 +1127,80 @@ export const createLivenessChecker = (
|
|
|
781
1127
|
|
|
782
1128
|
return {
|
|
783
1129
|
branches: behaviors.length,
|
|
784
|
-
addInitialState: (index, state
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
behavior.initial.push(
|
|
798
|
-
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
799
|
-
);
|
|
800
|
-
}
|
|
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
|
+
);
|
|
801
1143
|
}
|
|
802
|
-
} finally {
|
|
803
|
-
evaluationEnvironment = environment;
|
|
804
1144
|
}
|
|
805
1145
|
},
|
|
806
|
-
addState: (index, state, successors
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
const tableau = behavior.solution.tableau;
|
|
818
|
-
if (!tableau) {
|
|
819
|
-
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
820
|
-
continue;
|
|
821
|
-
}
|
|
822
|
-
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(
|
|
823
1157
|
behavior,
|
|
824
|
-
tableau,
|
|
825
|
-
set,
|
|
826
|
-
actionResults,
|
|
827
|
-
stateResults,
|
|
828
1158
|
index,
|
|
829
|
-
|
|
830
|
-
|
|
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;
|
|
831
1174
|
}
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
1175
|
+
const accepted = addTableauState(
|
|
1176
|
+
behavior,
|
|
1177
|
+
tableau,
|
|
1178
|
+
set,
|
|
1179
|
+
rows,
|
|
1180
|
+
actionResults,
|
|
1181
|
+
stateResults,
|
|
1182
|
+
index,
|
|
1183
|
+
);
|
|
1184
|
+
if (accepted) return accepted;
|
|
835
1185
|
}
|
|
1186
|
+
return undefined;
|
|
836
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),
|
|
837
1204
|
findViolation: () => {
|
|
838
1205
|
for (const behavior of behaviors) {
|
|
839
1206
|
for (const model of behavior.solution.models) {
|
|
@@ -843,15 +1210,5 @@ export const createLivenessChecker = (
|
|
|
843
1210
|
}
|
|
844
1211
|
return undefined;
|
|
845
1212
|
},
|
|
846
|
-
getViolatedProperties: (path, cycleStart) => [
|
|
847
|
-
...new Set(
|
|
848
|
-
properties
|
|
849
|
-
.filter(
|
|
850
|
-
(_property, position) =>
|
|
851
|
-
!evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
|
|
852
|
-
)
|
|
853
|
-
.map((property) => property.name),
|
|
854
|
-
),
|
|
855
|
-
],
|
|
856
1213
|
};
|
|
857
1214
|
};
|