tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
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 +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- 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 +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- 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 +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- 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 +120 -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 +757 -326
- 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 +226 -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 +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- 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 +9 -20
- 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 +3 -5
- 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/md5.ts +26 -29
- 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 +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -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 +624 -9
- 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 +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -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 +127 -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 +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -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 +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -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 +298 -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-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -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 +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -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 +328 -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 +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -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 +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -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 +34 -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 +111 -39
- 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 +355 -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 +30 -11
- 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 +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- 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 +167 -85
- 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 -290
- 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 +310 -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 +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- 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 +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -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 +495 -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 +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -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 +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- 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 +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- 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 +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- 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 +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -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 +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -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 +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -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 +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -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 +829 -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 +262 -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 +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- 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 +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -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 +2107 -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 +995 -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 +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -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 +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -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 +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- 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 +2176 -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 +1210 -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 +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -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 +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -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 +57 -26
- 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 +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- 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 +1 -3
- 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 +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -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/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- 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,19 @@ 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";
|
|
25
|
+
import { findTraceLasso, type TraceLasso } from "./trace-liveness";
|
|
20
26
|
import { isSameValue, type Value } from "./values";
|
|
21
27
|
|
|
22
|
-
export interface LiveSuccessor {
|
|
28
|
+
export interface LiveSuccessor<State = Value[]> {
|
|
23
29
|
index: number;
|
|
24
|
-
state:
|
|
30
|
+
state: State;
|
|
25
31
|
}
|
|
26
32
|
|
|
27
33
|
export interface Lasso {
|
|
@@ -32,6 +38,7 @@ export interface Lasso {
|
|
|
32
38
|
|
|
33
39
|
export interface LivenessChecker {
|
|
34
40
|
branches: number;
|
|
41
|
+
solutions: Solution[];
|
|
35
42
|
addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
|
|
36
43
|
addState: (
|
|
37
44
|
index: number,
|
|
@@ -39,13 +46,59 @@ export interface LivenessChecker {
|
|
|
39
46
|
successors: LiveSuccessor[],
|
|
40
47
|
tracing?: Environment,
|
|
41
48
|
) => number[] | undefined;
|
|
49
|
+
storeState: (pending: number, index: number) => void;
|
|
50
|
+
getStateCounts: () => number[];
|
|
42
51
|
findViolation: () => Lasso | undefined;
|
|
43
52
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
44
53
|
}
|
|
45
54
|
|
|
46
|
-
interface
|
|
47
|
-
|
|
48
|
-
|
|
55
|
+
export interface TraceViolation extends TraceLasso {
|
|
56
|
+
properties: string[];
|
|
57
|
+
failures: TlaEvaluationError[];
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
export interface LivenessChecks {
|
|
61
|
+
solutions: Solution[];
|
|
62
|
+
findTraceViolation: (trace: Value[][], fingerprints: bigint[]) => TraceViolation | undefined;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
export interface LiveGraph<State> {
|
|
66
|
+
branches: number;
|
|
67
|
+
addInitialState: (index: number, state: State) => void;
|
|
68
|
+
// The path to an accepting node the state reaches, if any.
|
|
69
|
+
addState: (
|
|
70
|
+
index: number,
|
|
71
|
+
state: State,
|
|
72
|
+
successors: LiveSuccessor<State>[],
|
|
73
|
+
isRerun?: boolean,
|
|
74
|
+
) => number[] | undefined;
|
|
75
|
+
storeState: (pending: number, index: number) => void;
|
|
76
|
+
getStateCounts: () => number[];
|
|
77
|
+
findViolation: () => Lasso | undefined;
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
export interface SearchGraph<State> {
|
|
81
|
+
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
82
|
+
forEachActionSuccessors: (
|
|
83
|
+
index: number,
|
|
84
|
+
state: State,
|
|
85
|
+
onSuccessors: (successors: LiveSuccessor<State>[]) => void,
|
|
86
|
+
replay?: Environment,
|
|
87
|
+
) => void;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
interface Tracing {
|
|
91
|
+
atoms: LiveAtoms<Value[]>;
|
|
92
|
+
replay: Environment | undefined;
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
export interface LiveEvaluation<State> {
|
|
96
|
+
atoms: LiveAtoms<State>;
|
|
97
|
+
// Whether a check's result for a state holds for every step from it.
|
|
98
|
+
isShared: boolean;
|
|
99
|
+
isSame: (left: State, right: State) => boolean;
|
|
100
|
+
// Evaluates the checks of a state the search found from the state at source.
|
|
101
|
+
evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
|
|
49
102
|
}
|
|
50
103
|
|
|
51
104
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
@@ -54,8 +107,25 @@ interface Pool<Data extends Int32Array | Uint8Array> {
|
|
|
54
107
|
create: (length: number) => Data;
|
|
55
108
|
}
|
|
56
109
|
|
|
57
|
-
|
|
110
|
+
// A check reads and fills the state atoms of a state in its row, which starts at offset.
|
|
111
|
+
type Check<State> = (
|
|
112
|
+
state: State,
|
|
113
|
+
row: Int8Array,
|
|
114
|
+
offset: number,
|
|
115
|
+
next: State | undefined,
|
|
116
|
+
) => boolean;
|
|
117
|
+
|
|
118
|
+
interface BehaviorChecks<State> {
|
|
119
|
+
states: Check<State>[];
|
|
120
|
+
actions: Check<State>[];
|
|
121
|
+
// The state predicates of each tableau node, or, where its checks share results and it has only
|
|
122
|
+
// state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
|
|
123
|
+
nodes: (Check<State>[] | Int32Array)[];
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
interface BehaviorGraph<State> {
|
|
58
127
|
solution: Solution;
|
|
128
|
+
checks: BehaviorChecks<State>;
|
|
59
129
|
actionIds: Int32Array;
|
|
60
130
|
nodeStates: number[];
|
|
61
131
|
nodeTableaux: number[];
|
|
@@ -70,6 +140,7 @@ interface BehaviorGraph {
|
|
|
70
140
|
nextSiblings: number[];
|
|
71
141
|
nodeIds: NodeTable;
|
|
72
142
|
isDone: boolean[];
|
|
143
|
+
stateCount: number;
|
|
73
144
|
errorNode: number | undefined;
|
|
74
145
|
}
|
|
75
146
|
|
|
@@ -89,14 +160,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
|
|
|
89
160
|
}
|
|
90
161
|
};
|
|
91
162
|
|
|
163
|
+
const isEmptyModel = (model: Solution["models"][number]) =>
|
|
164
|
+
model.eventuallyAlways.length === 0 &&
|
|
165
|
+
model.infinitelyOftenStates.length === 0 &&
|
|
166
|
+
model.infinitelyOftenActions.length === 0;
|
|
167
|
+
|
|
92
168
|
const isCycleConstrained = (solution: Solution) =>
|
|
93
169
|
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
|
-
);
|
|
170
|
+
solution.models.some((model) => !isEmptyModel(model));
|
|
100
171
|
|
|
101
172
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
102
173
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
@@ -112,14 +183,18 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
112
183
|
pool: Pool<Data>,
|
|
113
184
|
offset: number,
|
|
114
185
|
values: ArrayLike<number>,
|
|
186
|
+
start = 0,
|
|
187
|
+
length = values.length - start,
|
|
115
188
|
) => {
|
|
116
|
-
const end = offset +
|
|
189
|
+
const end = offset + length;
|
|
117
190
|
if (end > pool.data.length) {
|
|
118
191
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
119
192
|
data.set(pool.data);
|
|
120
193
|
pool.data = data;
|
|
121
194
|
}
|
|
122
|
-
|
|
195
|
+
for (let position = 0; position < length; position++) {
|
|
196
|
+
pool.data[offset + position] = values[start + position];
|
|
197
|
+
}
|
|
123
198
|
pool.length = Math.max(pool.length, end);
|
|
124
199
|
};
|
|
125
200
|
|
|
@@ -148,20 +223,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
148
223
|
|
|
149
224
|
const UNWRITTEN = -1;
|
|
150
225
|
|
|
151
|
-
const isWritten = (behavior: BehaviorGraph
|
|
226
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
152
227
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
153
228
|
|
|
154
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
229
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
155
230
|
const start = behavior.edgeStarts[node];
|
|
156
231
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
157
232
|
};
|
|
158
233
|
|
|
159
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
234
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
160
235
|
behavior.stateResults.data[
|
|
161
236
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
162
237
|
] === 1;
|
|
163
238
|
|
|
164
|
-
const pushNode = (behavior: BehaviorGraph
|
|
239
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
165
240
|
behavior.nodeStates.push(state);
|
|
166
241
|
behavior.nodeTableaux.push(tableauNode);
|
|
167
242
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -170,7 +245,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
170
245
|
return behavior.nodeStates.length - 1;
|
|
171
246
|
};
|
|
172
247
|
|
|
173
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
248
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
174
249
|
const nodes: number[] = [];
|
|
175
250
|
for (
|
|
176
251
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -190,26 +265,310 @@ const UNVISITED = -1;
|
|
|
190
265
|
|
|
191
266
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
192
267
|
|
|
193
|
-
|
|
268
|
+
const getLiveFormula = (
|
|
194
269
|
properties: TemporalProperty[],
|
|
195
270
|
temporals: ScopedExpression[],
|
|
196
271
|
environment: Environment,
|
|
197
|
-
|
|
198
|
-
): LivenessChecker | undefined => {
|
|
199
|
-
if (properties.length === 0) return undefined;
|
|
272
|
+
) => {
|
|
200
273
|
const fairness = temporals.map((item) =>
|
|
201
274
|
toLiveExpression(item.expression, item.scope, environment),
|
|
202
275
|
);
|
|
203
|
-
const
|
|
204
|
-
|
|
276
|
+
const checks = properties.map((property) =>
|
|
277
|
+
toLiveExpression(property.expression, property.scope, environment),
|
|
205
278
|
);
|
|
279
|
+
const negations = checks.map((check) => createUnary("Not", check));
|
|
206
280
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
207
281
|
const formula =
|
|
208
282
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
209
|
-
|
|
283
|
+
return { formula, checks };
|
|
284
|
+
};
|
|
285
|
+
|
|
286
|
+
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
287
|
+
|
|
288
|
+
const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
|
|
289
|
+
switch (atom.kind) {
|
|
290
|
+
case "State":
|
|
291
|
+
return [atom];
|
|
292
|
+
case "Enabled":
|
|
293
|
+
return [{ expression: atom.step, scope: atom.scope }];
|
|
294
|
+
case "Action":
|
|
295
|
+
return [atom.expression, atom.subscript].flatMap((inner) =>
|
|
296
|
+
inner ? [{ expression: inner, scope: atom.scope }] : [],
|
|
297
|
+
);
|
|
298
|
+
}
|
|
299
|
+
};
|
|
300
|
+
|
|
301
|
+
const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
|
|
302
|
+
switch (expression.kind) {
|
|
303
|
+
case "Boolean":
|
|
304
|
+
return;
|
|
305
|
+
case "State":
|
|
306
|
+
case "Enabled":
|
|
307
|
+
case "Action":
|
|
308
|
+
atoms.add(expression);
|
|
309
|
+
return;
|
|
310
|
+
case "And":
|
|
311
|
+
case "Or":
|
|
312
|
+
expression.operands.forEach((operand) => collectAtoms(operand, atoms));
|
|
313
|
+
return;
|
|
314
|
+
default:
|
|
315
|
+
collectAtoms(expression.body, atoms);
|
|
316
|
+
}
|
|
317
|
+
};
|
|
318
|
+
|
|
319
|
+
// The atoms the checks of the solutions evaluate.
|
|
320
|
+
export const getLiveAtoms = (solutions: Solution[]) => {
|
|
321
|
+
const atoms = new Set<LiveAtom>();
|
|
322
|
+
for (const solution of solutions) {
|
|
323
|
+
[
|
|
324
|
+
...solution.stateChecks,
|
|
325
|
+
...solution.actionChecks,
|
|
326
|
+
...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
|
|
327
|
+
].forEach((check) => collectAtoms(check, atoms));
|
|
328
|
+
}
|
|
329
|
+
return [...atoms];
|
|
330
|
+
};
|
|
331
|
+
|
|
332
|
+
// The expressions the checks of the solutions evaluate.
|
|
333
|
+
export const getLiveExpressions = (solutions: Solution[]) =>
|
|
334
|
+
getLiveAtoms(solutions).flatMap((atom) =>
|
|
335
|
+
getAtomExpressions(atom).map((item) => item.expression),
|
|
336
|
+
);
|
|
337
|
+
|
|
338
|
+
const isSharingResults = (formula: LiveExpression, environment: Environment) => {
|
|
339
|
+
const formulaAtoms = new Set<LiveAtom>();
|
|
340
|
+
collectAtoms(formula, formulaAtoms);
|
|
341
|
+
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
342
|
+
return checked.every((item) => item.scope === undefined)
|
|
343
|
+
? !isExpressionImpure(
|
|
344
|
+
checked.map((item) => item.expression),
|
|
345
|
+
environment,
|
|
346
|
+
"repeated",
|
|
347
|
+
)
|
|
348
|
+
: !hasRepeatedEffects(environment);
|
|
349
|
+
};
|
|
350
|
+
|
|
351
|
+
const getViolatedProperties = (
|
|
352
|
+
properties: TemporalProperty[],
|
|
353
|
+
checks: LiveExpression[],
|
|
354
|
+
path: Value[][],
|
|
355
|
+
cycleStart: number,
|
|
356
|
+
environment: Environment,
|
|
357
|
+
failures?: TlaEvaluationError[],
|
|
358
|
+
) => [
|
|
359
|
+
...new Set(
|
|
360
|
+
properties
|
|
361
|
+
.filter((_property, position) => {
|
|
362
|
+
try {
|
|
363
|
+
return !evaluateOnLasso(checks[position], path, cycleStart, 0, environment);
|
|
364
|
+
} catch (error) {
|
|
365
|
+
if (!failures || !(error instanceof TlaEvaluationError)) throw error;
|
|
366
|
+
failures.push(error);
|
|
367
|
+
return false;
|
|
368
|
+
}
|
|
369
|
+
})
|
|
370
|
+
.map((property) => property.name),
|
|
371
|
+
),
|
|
372
|
+
];
|
|
373
|
+
|
|
374
|
+
export const createLivenessChecks = (
|
|
375
|
+
properties: TemporalProperty[],
|
|
376
|
+
temporals: ScopedExpression[],
|
|
377
|
+
environment: Environment,
|
|
378
|
+
): LivenessChecks | undefined => {
|
|
379
|
+
if (properties.length === 0) return undefined;
|
|
380
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
381
|
+
const solutions = getSolutions(live.formula);
|
|
382
|
+
const atoms = getInterpretedAtoms(environment);
|
|
383
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
384
|
+
return {
|
|
385
|
+
solutions,
|
|
386
|
+
findTraceViolation: (trace, fingerprints) => {
|
|
387
|
+
const lasso = findTraceLasso(trace, fingerprints, solutions, atoms, isShared);
|
|
388
|
+
if (!lasso) return undefined;
|
|
389
|
+
// Liveness#findViolatedProperties reports a property it fails to evaluate on the lasso and goes on.
|
|
390
|
+
const failures: TlaEvaluationError[] = [];
|
|
391
|
+
const violated = getViolatedProperties(
|
|
392
|
+
properties,
|
|
393
|
+
live.checks,
|
|
394
|
+
lasso.positions.map((position) => trace[position]),
|
|
395
|
+
lasso.cyclePosition - 1,
|
|
396
|
+
environment,
|
|
397
|
+
failures,
|
|
398
|
+
);
|
|
399
|
+
return { ...lasso, properties: violated, failures };
|
|
400
|
+
},
|
|
401
|
+
};
|
|
402
|
+
};
|
|
403
|
+
|
|
404
|
+
export const createLivenessChecker = (
|
|
405
|
+
properties: TemporalProperty[],
|
|
406
|
+
temporals: ScopedExpression[],
|
|
407
|
+
environment: Environment,
|
|
408
|
+
search: SearchGraph<Value[]>,
|
|
409
|
+
): LivenessChecker | undefined => {
|
|
410
|
+
if (properties.length === 0) return undefined;
|
|
411
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
412
|
+
const isShared = isSharingResults(live.formula, environment);
|
|
413
|
+
const solutions = getSolutions(live.formula);
|
|
414
|
+
const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
|
|
415
|
+
const graph = createLiveGraph(
|
|
416
|
+
solutions,
|
|
417
|
+
{
|
|
418
|
+
atoms: {
|
|
419
|
+
holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
|
|
420
|
+
holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
|
|
421
|
+
},
|
|
422
|
+
isShared,
|
|
423
|
+
isSame: isSameState,
|
|
424
|
+
evaluateFrom: (source, evaluate) => {
|
|
425
|
+
environment.runtime.setLivenessSource(source);
|
|
426
|
+
try {
|
|
427
|
+
return evaluate();
|
|
428
|
+
} finally {
|
|
429
|
+
environment.runtime.setLivenessSource(undefined);
|
|
430
|
+
}
|
|
431
|
+
},
|
|
432
|
+
},
|
|
433
|
+
{
|
|
434
|
+
getFingerprint: search.getFingerprint,
|
|
435
|
+
forEachActionSuccessors: (index, state, onSuccessors) =>
|
|
436
|
+
search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
|
|
437
|
+
},
|
|
438
|
+
environment.runtime.version !== "1.7.4",
|
|
439
|
+
);
|
|
440
|
+
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
441
|
+
if (replay === undefined) return run();
|
|
442
|
+
tracing.atoms = getInterpretedAtoms(replay);
|
|
443
|
+
tracing.replay = replay;
|
|
444
|
+
try {
|
|
445
|
+
return run();
|
|
446
|
+
} finally {
|
|
447
|
+
tracing.atoms = getInterpretedAtoms(environment);
|
|
448
|
+
tracing.replay = undefined;
|
|
449
|
+
}
|
|
450
|
+
};
|
|
451
|
+
return {
|
|
452
|
+
branches: graph.branches,
|
|
453
|
+
solutions,
|
|
454
|
+
addInitialState: (index, state, replay) =>
|
|
455
|
+
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
456
|
+
addState: (index, state, successors, replay) =>
|
|
457
|
+
traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
|
|
458
|
+
storeState: graph.storeState,
|
|
459
|
+
getStateCounts: graph.getStateCounts,
|
|
460
|
+
findViolation: graph.findViolation,
|
|
461
|
+
getViolatedProperties: (path, cycleStart) =>
|
|
462
|
+
getViolatedProperties(properties, live.checks, path, cycleStart, environment),
|
|
463
|
+
};
|
|
464
|
+
};
|
|
465
|
+
|
|
466
|
+
export const createLiveGraph = <State>(
|
|
467
|
+
solutions: Solution[],
|
|
468
|
+
evaluation: LiveEvaluation<State>,
|
|
469
|
+
search: SearchGraph<State>,
|
|
470
|
+
isAcceptingFound: boolean,
|
|
471
|
+
): LiveGraph<State> => {
|
|
210
472
|
const actionIds = new Map<string, number>();
|
|
211
|
-
|
|
473
|
+
let capacityMultiplier = 1;
|
|
474
|
+
const isShared = evaluation.isShared;
|
|
475
|
+
const atoms = evaluation.atoms;
|
|
476
|
+
const evaluateFrom = evaluation.evaluateFrom;
|
|
477
|
+
const stateAtoms = new Map<LiveState | LiveEnabled, number>();
|
|
478
|
+
const atomsById: (LiveState | LiveEnabled)[] = [];
|
|
479
|
+
const getAtomId = (atom: LiveState | LiveEnabled) => {
|
|
480
|
+
const id = stateAtoms.get(atom) ?? stateAtoms.size;
|
|
481
|
+
stateAtoms.set(atom, id);
|
|
482
|
+
atomsById[id] = atom;
|
|
483
|
+
return id;
|
|
484
|
+
};
|
|
485
|
+
const getLiterals = (expression: LiveExpression): number[] | undefined => {
|
|
486
|
+
if (expression.kind === "State" || expression.kind === "Enabled") {
|
|
487
|
+
return [getAtomId(expression) * 2 + 1];
|
|
488
|
+
}
|
|
489
|
+
if (expression.kind === "Not") {
|
|
490
|
+
const body = expression.body;
|
|
491
|
+
return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
|
|
492
|
+
}
|
|
493
|
+
if (expression.kind !== "And") return undefined;
|
|
494
|
+
const operands = expression.operands.map(getLiterals);
|
|
495
|
+
return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
|
|
496
|
+
};
|
|
497
|
+
// The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
|
|
498
|
+
// or -1 before it is evaluated.
|
|
499
|
+
const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
|
|
500
|
+
// The edge rows of steps hold the result of each action check, shared by the behaviors that
|
|
501
|
+
// check it.
|
|
502
|
+
const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
|
|
503
|
+
// Unless the checks share results, each check evaluates its atoms afresh.
|
|
504
|
+
const runCheck = (
|
|
505
|
+
check: Check<State>,
|
|
506
|
+
state: State,
|
|
507
|
+
row: Int8Array,
|
|
508
|
+
offset: number,
|
|
509
|
+
next?: State,
|
|
510
|
+
) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
|
|
511
|
+
const compileCheck = (expression: LiveExpression): Check<State> => {
|
|
512
|
+
switch (expression.kind) {
|
|
513
|
+
case "Boolean": {
|
|
514
|
+
const value = expression.value;
|
|
515
|
+
return () => value;
|
|
516
|
+
}
|
|
517
|
+
case "State":
|
|
518
|
+
case "Enabled": {
|
|
519
|
+
const id = getAtomId(expression);
|
|
520
|
+
return (state, row, offset) => {
|
|
521
|
+
if (row[offset + id] === -1) {
|
|
522
|
+
row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
|
|
523
|
+
}
|
|
524
|
+
return row[offset + id] === 1;
|
|
525
|
+
};
|
|
526
|
+
}
|
|
527
|
+
case "Action": {
|
|
528
|
+
const enabled = expression.enabled && getAtomId(expression.enabled);
|
|
529
|
+
return (state, row, offset, next) =>
|
|
530
|
+
!(enabled !== undefined && row[offset + enabled] === 0) &&
|
|
531
|
+
next !== undefined &&
|
|
532
|
+
atoms.holdsAction(expression, state, next);
|
|
533
|
+
}
|
|
534
|
+
case "Not": {
|
|
535
|
+
const body = compileCheck(expression.body);
|
|
536
|
+
return (state, row, offset, next) => !body(state, row, offset, next);
|
|
537
|
+
}
|
|
538
|
+
case "And": {
|
|
539
|
+
const operands = expression.operands.map(compileCheck);
|
|
540
|
+
return (state, row, offset, next) =>
|
|
541
|
+
operands.every((operand) => operand(state, row, offset, next));
|
|
542
|
+
}
|
|
543
|
+
case "Or": {
|
|
544
|
+
const operands = expression.operands.map(compileCheck);
|
|
545
|
+
return (state, row, offset, next) =>
|
|
546
|
+
operands.some((operand) => operand(state, row, offset, next));
|
|
547
|
+
}
|
|
548
|
+
case "Next": {
|
|
549
|
+
const body = compileCheck(expression.body);
|
|
550
|
+
return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
|
|
551
|
+
}
|
|
552
|
+
case "Always":
|
|
553
|
+
case "Eventually":
|
|
554
|
+
return () => {
|
|
555
|
+
throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
|
|
556
|
+
};
|
|
557
|
+
}
|
|
558
|
+
};
|
|
559
|
+
const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
|
|
212
560
|
solution,
|
|
561
|
+
checks: {
|
|
562
|
+
states: solution.stateChecks.map(compileCheck),
|
|
563
|
+
actions: solution.actionChecks.map(compileCheck),
|
|
564
|
+
nodes:
|
|
565
|
+
solution.tableau?.nodes.map((node) => {
|
|
566
|
+
const literals = isShared
|
|
567
|
+
? getLiterals({ kind: "And", operands: node.statePredicates })
|
|
568
|
+
: undefined;
|
|
569
|
+
return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
|
|
570
|
+
}) ?? [],
|
|
571
|
+
},
|
|
213
572
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
214
573
|
const key = getTermKey(predicate);
|
|
215
574
|
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
@@ -229,85 +588,88 @@ export const createLivenessChecker = (
|
|
|
229
588
|
nextSiblings: [],
|
|
230
589
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
231
590
|
isDone: [],
|
|
591
|
+
stateCount: 0,
|
|
232
592
|
errorNode: undefined,
|
|
233
593
|
}));
|
|
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
|
-
);
|
|
594
|
+
const checkState = (
|
|
595
|
+
behavior: BehaviorGraph<State>,
|
|
596
|
+
source: number,
|
|
597
|
+
state: State,
|
|
598
|
+
row: Int8Array,
|
|
599
|
+
offset: number,
|
|
600
|
+
) =>
|
|
601
|
+
evaluateFrom(source, () => {
|
|
602
|
+
const checks = behavior.checks.states;
|
|
603
|
+
const results = new Uint8Array(checks.length);
|
|
604
|
+
checks.forEach((check, position) => {
|
|
605
|
+
results[position] = runCheck(check, state, row, offset) ? 1 : 0;
|
|
606
|
+
});
|
|
607
|
+
return results;
|
|
608
|
+
});
|
|
609
|
+
// Writes the result of each action check of the step to successor at resultOffset in results.
|
|
267
610
|
const checkAction = (
|
|
268
|
-
behavior: BehaviorGraph
|
|
611
|
+
behavior: BehaviorGraph<State>,
|
|
269
612
|
source: number,
|
|
270
|
-
state:
|
|
271
|
-
|
|
613
|
+
state: State,
|
|
614
|
+
row: Int8Array,
|
|
615
|
+
offset: number,
|
|
616
|
+
successor: State,
|
|
617
|
+
edges: Int8Array,
|
|
618
|
+
edgeOffset: number,
|
|
619
|
+
results: Uint8Array,
|
|
620
|
+
resultOffset: number,
|
|
272
621
|
) =>
|
|
273
622
|
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],
|
|
623
|
+
const actions = behavior.checks.actions;
|
|
624
|
+
for (let position = 0; position < actions.length; position++) {
|
|
625
|
+
if (!isShared) {
|
|
626
|
+
results[resultOffset + position] = runCheck(
|
|
627
|
+
actions[position],
|
|
289
628
|
state,
|
|
629
|
+
row,
|
|
630
|
+
offset,
|
|
290
631
|
successor,
|
|
291
|
-
evaluationEnvironment,
|
|
292
|
-
stateCache,
|
|
293
632
|
)
|
|
294
633
|
? 1
|
|
295
634
|
: 0;
|
|
635
|
+
continue;
|
|
296
636
|
}
|
|
297
|
-
|
|
298
|
-
|
|
637
|
+
const edge = edgeOffset + behavior.actionIds[position];
|
|
638
|
+
if (edges[edge] === -1)
|
|
639
|
+
edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
|
|
640
|
+
results[resultOffset + position] = edges[edge];
|
|
641
|
+
}
|
|
299
642
|
});
|
|
643
|
+
const holdsNode = (
|
|
644
|
+
behavior: BehaviorGraph<State>,
|
|
645
|
+
node: number,
|
|
646
|
+
state: State,
|
|
647
|
+
row: Int8Array,
|
|
648
|
+
offset: number,
|
|
649
|
+
) => {
|
|
650
|
+
const checks = behavior.checks.nodes[node];
|
|
651
|
+
if (!(checks instanceof Int32Array)) {
|
|
652
|
+
return checks.every((check) => runCheck(check, state, row, offset));
|
|
653
|
+
}
|
|
654
|
+
for (let position = 0; position < checks.length; position++) {
|
|
655
|
+
const literal: number = checks[position];
|
|
656
|
+
const cell = offset + (literal >> 1);
|
|
657
|
+
if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
|
|
658
|
+
if (row[cell] !== (literal & 1)) return false;
|
|
659
|
+
}
|
|
660
|
+
return true;
|
|
661
|
+
};
|
|
300
662
|
const isConsistent = (
|
|
301
|
-
|
|
663
|
+
behavior: BehaviorGraph<State>,
|
|
302
664
|
node: number,
|
|
303
665
|
source: number | undefined,
|
|
304
|
-
state:
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
666
|
+
state: State,
|
|
667
|
+
row: Int8Array,
|
|
668
|
+
offset: number,
|
|
669
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
670
|
+
|
|
309
671
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
310
|
-
if (
|
|
672
|
+
if (!isAcceptingFound) return false;
|
|
311
673
|
const tableauNode = tableau.nodes[node];
|
|
312
674
|
return (
|
|
313
675
|
tableauNode.particle.length === 0 &&
|
|
@@ -315,22 +677,19 @@ export const createLivenessChecker = (
|
|
|
315
677
|
tableauNode.successors[0] === node
|
|
316
678
|
);
|
|
317
679
|
};
|
|
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
680
|
|
|
326
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
681
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
327
682
|
if (!behavior.solution.tableau) return state;
|
|
328
683
|
const slots = behavior.nodeIds.slots;
|
|
329
684
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
330
685
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
331
686
|
};
|
|
332
|
-
const
|
|
333
|
-
|
|
687
|
+
const linkNode = (
|
|
688
|
+
behavior: BehaviorGraph<State>,
|
|
689
|
+
state: number,
|
|
690
|
+
tableauNode: number,
|
|
691
|
+
node: number,
|
|
692
|
+
) => {
|
|
334
693
|
const table = behavior.nodeIds;
|
|
335
694
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
336
695
|
const old = table.slots;
|
|
@@ -346,24 +705,43 @@ export const createLivenessChecker = (
|
|
|
346
705
|
}
|
|
347
706
|
}
|
|
348
707
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
708
|
+
if (state < 0) return node;
|
|
349
709
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
350
710
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
351
711
|
else behavior.nextSiblings[last] = node;
|
|
352
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
353
713
|
return node;
|
|
354
714
|
};
|
|
715
|
+
const hasState = (behavior: BehaviorGraph<State>, state: number) =>
|
|
716
|
+
state < 0
|
|
717
|
+
? behavior.checks.nodes.some(
|
|
718
|
+
(_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
|
|
719
|
+
)
|
|
720
|
+
: behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
|
|
721
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
722
|
+
if (!hasState(behavior, state)) behavior.stateCount++;
|
|
723
|
+
return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
|
|
724
|
+
};
|
|
725
|
+
// The action results of the edge to each target are at its position in actions.
|
|
355
726
|
const writeNode = (
|
|
356
|
-
behavior: BehaviorGraph
|
|
727
|
+
behavior: BehaviorGraph<State>,
|
|
357
728
|
node: number,
|
|
358
729
|
targets: number[],
|
|
359
|
-
|
|
730
|
+
actionResults: Uint8Array,
|
|
731
|
+
actions: number[],
|
|
360
732
|
stateResults: Uint8Array,
|
|
361
733
|
) => {
|
|
362
734
|
const start = behavior.edgeTargets.length;
|
|
363
735
|
const actionCount = behavior.solution.actionChecks.length;
|
|
364
736
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
365
|
-
actions.forEach((
|
|
366
|
-
writeToPool(
|
|
737
|
+
actions.forEach((position, edge) =>
|
|
738
|
+
writeToPool(
|
|
739
|
+
behavior.edgeActions,
|
|
740
|
+
(start + edge) * actionCount,
|
|
741
|
+
actionResults,
|
|
742
|
+
position * actionCount,
|
|
743
|
+
actionCount,
|
|
744
|
+
),
|
|
367
745
|
);
|
|
368
746
|
writeToPool(
|
|
369
747
|
behavior.stateResults,
|
|
@@ -375,61 +753,72 @@ export const createLivenessChecker = (
|
|
|
375
753
|
};
|
|
376
754
|
|
|
377
755
|
// 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
|
-
|
|
756
|
+
// Each slot holds a candidate's position plus one, or 0 when it is empty.
|
|
757
|
+
const successorSet = { slots: new Int32Array(0) };
|
|
758
|
+
const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
|
|
759
|
+
const candidates = [...successors, { index, state }];
|
|
760
|
+
const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
|
|
761
|
+
successorSet.slots =
|
|
762
|
+
successorSet.slots.length === capacity
|
|
763
|
+
? successorSet.slots.fill(0)
|
|
764
|
+
: new Int32Array(capacity);
|
|
765
|
+
const insert = (position: number) => {
|
|
766
|
+
const slots = successorSet.slots;
|
|
767
|
+
const candidate = candidates[position];
|
|
384
768
|
for (
|
|
385
|
-
let slot = (search.getFingerprint(
|
|
769
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
386
770
|
;
|
|
387
771
|
slot = (slot + 1) % slots.length
|
|
388
772
|
) {
|
|
389
773
|
const entry = slots[slot];
|
|
390
|
-
if (entry ===
|
|
391
|
-
slots[slot] =
|
|
774
|
+
if (entry === 0) {
|
|
775
|
+
slots[slot] = position + 1;
|
|
392
776
|
return true;
|
|
393
777
|
}
|
|
394
|
-
|
|
778
|
+
const stored = candidates[entry - 1];
|
|
779
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
395
780
|
return false;
|
|
396
781
|
}
|
|
397
782
|
};
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
783
|
+
let count = 0;
|
|
784
|
+
for (let position = 0; position < candidates.length; position++) {
|
|
785
|
+
if (count >= successorSet.slots.length >> 1) {
|
|
786
|
+
const old = successorSet.slots;
|
|
787
|
+
successorSet.slots = new Int32Array(2 * old.length + 1);
|
|
788
|
+
for (const entry of old) if (entry !== 0) insert(entry - 1);
|
|
403
789
|
}
|
|
404
|
-
if (
|
|
405
|
-
}
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
return
|
|
790
|
+
if (insert(position)) count++;
|
|
791
|
+
}
|
|
792
|
+
if (successorSet.slots.length > capacity) capacityMultiplier++;
|
|
793
|
+
const set: LiveSuccessor<State>[] = [];
|
|
794
|
+
for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
|
|
795
|
+
return set;
|
|
410
796
|
};
|
|
411
797
|
|
|
412
798
|
const expandLate = (
|
|
413
|
-
behavior: BehaviorGraph
|
|
799
|
+
behavior: BehaviorGraph<State>,
|
|
414
800
|
tableau: Tableau,
|
|
415
|
-
state:
|
|
801
|
+
state: State,
|
|
416
802
|
index: number,
|
|
417
803
|
node: number,
|
|
804
|
+
row: Int8Array,
|
|
805
|
+
offset: number,
|
|
418
806
|
) => {
|
|
419
|
-
const stateResults = checkState(behavior, index, state);
|
|
807
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
420
808
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
421
|
-
const
|
|
809
|
+
const actionCount = behavior.checks.actions.length;
|
|
810
|
+
const actions: number[] = [];
|
|
422
811
|
const successors: number[] = [];
|
|
423
|
-
const
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
812
|
+
const selfResults = new Uint8Array(actionCount);
|
|
813
|
+
if (tableauNode.successors.length > 0) {
|
|
814
|
+
checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
|
|
815
|
+
}
|
|
427
816
|
for (const next of tableauNode.successors) {
|
|
428
|
-
if (!isConsistent(
|
|
817
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
429
818
|
if (
|
|
430
819
|
isAccepting(tableau, next) &&
|
|
431
820
|
behavior.errorNode === undefined &&
|
|
432
|
-
|
|
821
|
+
behavior.solution.models.some(isEmptyModel)
|
|
433
822
|
) {
|
|
434
823
|
behavior.errorNode = node;
|
|
435
824
|
return;
|
|
@@ -438,88 +827,140 @@ export const createLivenessChecker = (
|
|
|
438
827
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
439
828
|
const target = existing ?? recordNode(behavior, index, next);
|
|
440
829
|
successors.push(target);
|
|
441
|
-
actions.push(
|
|
442
|
-
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
830
|
+
actions.push(0);
|
|
831
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
443
832
|
}
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
const
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
833
|
+
// The results of the step to the state itself come first, then those of each successor.
|
|
834
|
+
const actionBatches = [selfResults];
|
|
835
|
+
let stepCount = 1;
|
|
836
|
+
search.forEachActionSuccessors(index, state, (nextStates) => {
|
|
837
|
+
const edges = createEdgeRows(nextStates.length);
|
|
838
|
+
const results = new Uint8Array(nextStates.length * actionCount);
|
|
839
|
+
actionBatches.push(results);
|
|
840
|
+
for (let position = 0; position < nextStates.length; position++) {
|
|
841
|
+
const successor = nextStates[position];
|
|
842
|
+
const successorRow = createRows(1);
|
|
843
|
+
checkAction(
|
|
844
|
+
behavior,
|
|
845
|
+
index,
|
|
846
|
+
state,
|
|
847
|
+
row,
|
|
848
|
+
offset,
|
|
849
|
+
successor.state,
|
|
850
|
+
edges,
|
|
851
|
+
position * actionIds.size,
|
|
852
|
+
results,
|
|
853
|
+
position * actionCount,
|
|
854
|
+
);
|
|
855
|
+
const isDone = behavior.isDone[successor.index] === true;
|
|
856
|
+
for (const next of tableauNode.successors) {
|
|
857
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
858
|
+
const existing = getNodeId(behavior, successor.index, next);
|
|
859
|
+
if (existing !== undefined && successors.includes(existing)) continue;
|
|
860
|
+
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
861
|
+
successors.push(target);
|
|
862
|
+
actions.push(stepCount + position);
|
|
863
|
+
if (existing === undefined && isDone) {
|
|
864
|
+
expandLate(
|
|
865
|
+
behavior,
|
|
866
|
+
tableau,
|
|
867
|
+
successor.state,
|
|
868
|
+
successor.index,
|
|
869
|
+
target,
|
|
870
|
+
successorRow,
|
|
871
|
+
0,
|
|
872
|
+
);
|
|
873
|
+
}
|
|
458
874
|
}
|
|
459
875
|
}
|
|
876
|
+
stepCount += nextStates.length;
|
|
877
|
+
});
|
|
878
|
+
if (successors.length > 0) {
|
|
879
|
+
const actionResults = new Uint8Array(stepCount * actionCount);
|
|
880
|
+
for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
|
|
881
|
+
actionResults.set(actionBatches[batch], resultOffset);
|
|
882
|
+
resultOffset += actionBatches[batch].length;
|
|
883
|
+
}
|
|
884
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
460
885
|
}
|
|
461
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
462
886
|
};
|
|
463
887
|
|
|
464
888
|
const addTableauState = (
|
|
465
|
-
behavior: BehaviorGraph
|
|
889
|
+
behavior: BehaviorGraph<State>,
|
|
466
890
|
tableau: Tableau,
|
|
467
|
-
set: LiveSuccessor[],
|
|
468
|
-
|
|
891
|
+
set: LiveSuccessor<State>[],
|
|
892
|
+
rows: Int8Array,
|
|
893
|
+
actionResults: Uint8Array,
|
|
469
894
|
stateResults: Uint8Array,
|
|
470
895
|
index: number,
|
|
471
896
|
) => {
|
|
472
|
-
const
|
|
473
|
-
|
|
474
|
-
);
|
|
897
|
+
const atomCount = stateAtoms.size;
|
|
898
|
+
// Whether each successor is consistent with each tableau node, node by node.
|
|
899
|
+
const consistency = new Uint8Array(tableau.nodes.length * set.length);
|
|
900
|
+
evaluateFrom(index, () => {
|
|
901
|
+
for (let node = 0; node < tableau.nodes.length; node++) {
|
|
902
|
+
for (let position = 0; position < set.length; position++) {
|
|
903
|
+
if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
|
|
904
|
+
consistency[node * set.length + position] = 1;
|
|
905
|
+
}
|
|
906
|
+
}
|
|
907
|
+
}
|
|
908
|
+
});
|
|
909
|
+
if (!hasState(behavior, index)) behavior.stateCount++;
|
|
475
910
|
behavior.isDone[index] = true;
|
|
476
911
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
477
912
|
for (const node of getStateNodes(behavior, index)) {
|
|
478
913
|
const successors: number[] = [];
|
|
479
|
-
const actions:
|
|
914
|
+
const actions: number[] = [];
|
|
480
915
|
set.forEach((successor, position) => {
|
|
481
916
|
const isDone = behavior.isDone[successor.index] === true;
|
|
482
917
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
483
|
-
if (
|
|
918
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
484
919
|
const existing = getNodeId(behavior, successor.index, next);
|
|
485
920
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
486
921
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
487
922
|
successors.push(target);
|
|
488
|
-
actions.push(
|
|
923
|
+
actions.push(position);
|
|
489
924
|
if (existing === undefined && isDone) {
|
|
490
|
-
expandLate(
|
|
925
|
+
expandLate(
|
|
926
|
+
behavior,
|
|
927
|
+
tableau,
|
|
928
|
+
successor.state,
|
|
929
|
+
successor.index,
|
|
930
|
+
target,
|
|
931
|
+
rows,
|
|
932
|
+
position * atomCount,
|
|
933
|
+
);
|
|
491
934
|
}
|
|
492
935
|
}
|
|
493
936
|
});
|
|
494
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
937
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
495
938
|
}
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
.reverse()
|
|
500
|
-
.map((node) => behavior.nodeStates[node]),
|
|
501
|
-
);
|
|
939
|
+
return behavior.errorNode === undefined
|
|
940
|
+
? undefined
|
|
941
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
502
942
|
};
|
|
503
943
|
|
|
504
944
|
const addPlainState = (
|
|
505
|
-
behavior: BehaviorGraph
|
|
506
|
-
set: LiveSuccessor[],
|
|
507
|
-
actionResults: Uint8Array
|
|
945
|
+
behavior: BehaviorGraph<State>,
|
|
946
|
+
set: LiveSuccessor<State>[],
|
|
947
|
+
actionResults: Uint8Array,
|
|
508
948
|
stateResults: Uint8Array,
|
|
509
949
|
index: number,
|
|
510
950
|
) => {
|
|
511
951
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
512
952
|
const successors: number[] = [];
|
|
513
|
-
const actions:
|
|
953
|
+
const actions: number[] = [];
|
|
514
954
|
set.forEach((successor, position) => {
|
|
515
955
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
516
956
|
successors.push(successor.index);
|
|
517
|
-
actions.push(
|
|
957
|
+
actions.push(position);
|
|
518
958
|
});
|
|
519
|
-
|
|
959
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
960
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
520
961
|
};
|
|
521
962
|
|
|
522
|
-
const getPath = (behavior: BehaviorGraph
|
|
963
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
523
964
|
if (behavior.initial.includes(target)) return [target];
|
|
524
965
|
const parents = new Map<number, number>();
|
|
525
966
|
const queue: number[] = [];
|
|
@@ -545,8 +986,15 @@ export const createLivenessChecker = (
|
|
|
545
986
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
546
987
|
};
|
|
547
988
|
|
|
989
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
990
|
+
removeRepeats(
|
|
991
|
+
getPath(behavior, target)
|
|
992
|
+
.reverse()
|
|
993
|
+
.map((node) => behavior.nodeStates[node]),
|
|
994
|
+
);
|
|
995
|
+
|
|
548
996
|
const findLassoInModel = (
|
|
549
|
-
behavior: BehaviorGraph
|
|
997
|
+
behavior: BehaviorGraph<State>,
|
|
550
998
|
model: Solution["models"][number],
|
|
551
999
|
): Lasso | undefined => {
|
|
552
1000
|
const solution = behavior.solution;
|
|
@@ -606,11 +1054,7 @@ export const createLivenessChecker = (
|
|
|
606
1054
|
members: Set<number>,
|
|
607
1055
|
membersByState: Map<number, number[]>,
|
|
608
1056
|
) => {
|
|
609
|
-
const prefix =
|
|
610
|
-
getPath(behavior, root)
|
|
611
|
-
.reverse()
|
|
612
|
-
.map((node) => behavior.nodeStates[node]),
|
|
613
|
-
);
|
|
1057
|
+
const prefix = getStatePath(behavior, root);
|
|
614
1058
|
const cycleStack: number[] = [];
|
|
615
1059
|
const seen = new Set<number>([root]);
|
|
616
1060
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
@@ -618,7 +1062,6 @@ export const createLivenessChecker = (
|
|
|
618
1062
|
const promiseDone = solution.promises.map(() => false);
|
|
619
1063
|
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
620
1064
|
let currentNode = root;
|
|
621
|
-
const isMember = (node: number) => members.has(node);
|
|
622
1065
|
const moveTo = (next: number) => {
|
|
623
1066
|
cycleStack.push(currentNode);
|
|
624
1067
|
currentNode = next;
|
|
@@ -644,7 +1087,7 @@ export const createLivenessChecker = (
|
|
|
644
1087
|
const countBeforeActions = remainingCount;
|
|
645
1088
|
const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
|
|
646
1089
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
647
|
-
if (!
|
|
1090
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
648
1091
|
lastNext = next;
|
|
649
1092
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
650
1093
|
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
@@ -658,7 +1101,7 @@ export const createLivenessChecker = (
|
|
|
658
1101
|
seen.clear();
|
|
659
1102
|
return true;
|
|
660
1103
|
}
|
|
661
|
-
if (
|
|
1104
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
662
1105
|
return false;
|
|
663
1106
|
});
|
|
664
1107
|
if (isTaken) break;
|
|
@@ -677,14 +1120,14 @@ export const createLivenessChecker = (
|
|
|
677
1120
|
currentNode = previous;
|
|
678
1121
|
unvisitedNext =
|
|
679
1122
|
getNodeSuccessors(behavior, previous).find(
|
|
680
|
-
(next) =>
|
|
1123
|
+
(next) => members.has(next) && !seen.has(next),
|
|
681
1124
|
) ?? -1;
|
|
682
1125
|
}
|
|
683
1126
|
moveTo(unvisitedNext);
|
|
684
1127
|
seen.add(unvisitedNext);
|
|
685
1128
|
}
|
|
686
1129
|
}
|
|
687
|
-
const postfix = getClosingPath(root, currentNode, membersByState
|
|
1130
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
688
1131
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
689
1132
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
690
1133
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -698,12 +1141,7 @@ export const createLivenessChecker = (
|
|
|
698
1141
|
};
|
|
699
1142
|
};
|
|
700
1143
|
|
|
701
|
-
const getClosingPath = (
|
|
702
|
-
root: number,
|
|
703
|
-
end: number,
|
|
704
|
-
membersByState: Map<number, number[]>,
|
|
705
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
706
|
-
) => {
|
|
1144
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
707
1145
|
if (end === root) return [];
|
|
708
1146
|
const start = behavior.nodeStates[end];
|
|
709
1147
|
const parents = new Map<number, number>();
|
|
@@ -712,7 +1150,7 @@ export const createLivenessChecker = (
|
|
|
712
1150
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
713
1151
|
for (const node of membersByState.get(state) ?? []) {
|
|
714
1152
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
715
|
-
if (next === node || !
|
|
1153
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
716
1154
|
if (next === root) {
|
|
717
1155
|
const path: number[] = [];
|
|
718
1156
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -781,59 +1219,89 @@ export const createLivenessChecker = (
|
|
|
781
1219
|
|
|
782
1220
|
return {
|
|
783
1221
|
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
|
-
}
|
|
1222
|
+
addInitialState: (index, state) => {
|
|
1223
|
+
const row = createRows(1);
|
|
1224
|
+
for (const behavior of behaviors) {
|
|
1225
|
+
const tableau = behavior.solution.tableau;
|
|
1226
|
+
if (!tableau) {
|
|
1227
|
+
behavior.initial.push(index);
|
|
1228
|
+
continue;
|
|
1229
|
+
}
|
|
1230
|
+
for (let node = 0; node < tableau.initialCount; node++) {
|
|
1231
|
+
if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
|
|
1232
|
+
behavior.initial.push(
|
|
1233
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
1234
|
+
);
|
|
801
1235
|
}
|
|
802
|
-
} finally {
|
|
803
|
-
evaluationEnvironment = environment;
|
|
804
1236
|
}
|
|
805
1237
|
},
|
|
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(
|
|
1238
|
+
addState: (index, state, successors, isRerun) => {
|
|
1239
|
+
const set = getSuccessorSet(index, state, successors);
|
|
1240
|
+
const rows = createRows(set.length);
|
|
1241
|
+
// The set holds the state itself, as a successor of the same index.
|
|
1242
|
+
const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
|
|
1243
|
+
const edges = createEdgeRows(set.length);
|
|
1244
|
+
for (const behavior of behaviors) {
|
|
1245
|
+
const actionCount = behavior.checks.actions.length;
|
|
1246
|
+
const actionResults = new Uint8Array(set.length * actionCount);
|
|
1247
|
+
set.forEach((successor, position) =>
|
|
1248
|
+
checkAction(
|
|
823
1249
|
behavior,
|
|
824
|
-
tableau,
|
|
825
|
-
set,
|
|
826
|
-
actionResults,
|
|
827
|
-
stateResults,
|
|
828
1250
|
index,
|
|
829
|
-
|
|
830
|
-
|
|
1251
|
+
state,
|
|
1252
|
+
rows,
|
|
1253
|
+
offset,
|
|
1254
|
+
successor.state,
|
|
1255
|
+
edges,
|
|
1256
|
+
position * actionIds.size,
|
|
1257
|
+
actionResults,
|
|
1258
|
+
position * actionCount,
|
|
1259
|
+
),
|
|
1260
|
+
);
|
|
1261
|
+
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1262
|
+
const tableau = behavior.solution.tableau;
|
|
1263
|
+
// TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
|
|
1264
|
+
if (
|
|
1265
|
+
isRerun &&
|
|
1266
|
+
(tableau
|
|
1267
|
+
? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
|
|
1268
|
+
: set.every((successor) => isWritten(behavior, successor.index)))
|
|
1269
|
+
) {
|
|
1270
|
+
throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
|
|
1271
|
+
}
|
|
1272
|
+
if (!tableau) {
|
|
1273
|
+
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1274
|
+
continue;
|
|
1275
|
+
}
|
|
1276
|
+
const accepted = addTableauState(
|
|
1277
|
+
behavior,
|
|
1278
|
+
tableau,
|
|
1279
|
+
set,
|
|
1280
|
+
rows,
|
|
1281
|
+
actionResults,
|
|
1282
|
+
stateResults,
|
|
1283
|
+
index,
|
|
1284
|
+
);
|
|
1285
|
+
if (accepted) return accepted;
|
|
1286
|
+
}
|
|
1287
|
+
return undefined;
|
|
1288
|
+
},
|
|
1289
|
+
storeState: (pending, index) => {
|
|
1290
|
+
for (const behavior of behaviors) {
|
|
1291
|
+
const tableau = behavior.solution.tableau;
|
|
1292
|
+
if (!tableau) continue;
|
|
1293
|
+
const nodes: number[] = [];
|
|
1294
|
+
for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
|
|
1295
|
+
const node = getNodeId(behavior, pending, tableauNode);
|
|
1296
|
+
if (node !== undefined) nodes.push(node);
|
|
1297
|
+
}
|
|
1298
|
+
for (const node of nodes.sort((left, right) => left - right)) {
|
|
1299
|
+
behavior.nodeStates[node] = index;
|
|
1300
|
+
linkNode(behavior, index, behavior.nodeTableaux[node], node);
|
|
831
1301
|
}
|
|
832
|
-
return undefined;
|
|
833
|
-
} finally {
|
|
834
|
-
evaluationEnvironment = environment;
|
|
835
1302
|
}
|
|
836
1303
|
},
|
|
1304
|
+
getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
|
|
837
1305
|
findViolation: () => {
|
|
838
1306
|
for (const behavior of behaviors) {
|
|
839
1307
|
for (const model of behavior.solution.models) {
|
|
@@ -843,15 +1311,5 @@ export const createLivenessChecker = (
|
|
|
843
1311
|
}
|
|
844
1312
|
return undefined;
|
|
845
1313
|
},
|
|
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
1314
|
};
|
|
857
1315
|
};
|