tla-ts 0.0.9 → 0.0.10-dev.06b481ee0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +48 -44
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +122 -12
- package/dist/index.d.ts +122 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2746 -410
- package/dist/prove.js +2745 -409
- package/dist/run.cjs +144 -31
- package/dist/run.js +144 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +134 -104
- package/dist/transfer.js +134 -104
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +3 -1
- package/src/ast.ts +56 -60
- package/src/bags.ts +128 -110
- package/src/builtins.ts +31 -77
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +320 -0
- package/src/check.ts +1156 -888
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +100 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +433 -82
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +360 -0
- package/src/cli/tlc.ts +330 -659
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +217 -82
- package/src/config.ts +140 -109
- package/src/coverage.ts +1019 -0
- package/src/dependencies.ts +101 -66
- package/src/dfid.ts +683 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +263 -370
- package/src/errors.ts +107 -57
- package/src/evaluate.ts +898 -369
- package/src/exit-codes.ts +63 -13
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +137 -22
- package/src/java-hash.ts +21 -0
- package/src/java-overrides.ts +6 -21
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +231 -154
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +743 -322
- package/src/liveness.ts +230 -133
- package/src/obligations/action.ts +17 -44
- package/src/obligations/anonymize.ts +120 -95
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +37 -26
- package/src/obligations/format.ts +0 -10
- package/src/obligations/generate.ts +66 -64
- package/src/obligations/index.ts +39 -20
- package/src/obligations/levels.ts +27 -18
- package/src/obligations/module.ts +28 -55
- package/src/obligations/normalize.ts +31 -41
- package/src/obligations/operators.ts +0 -3
- package/src/obligations/pragma.ts +52 -24
- package/src/obligations/printer.ts +94 -63
- package/src/obligations/proof.ts +3 -6
- package/src/obligations/regroup.ts +0 -5
- package/src/obligations/simplify.ts +57 -63
- package/src/obligations/source.ts +121 -95
- package/src/obligations/subexpression.ts +49 -28
- package/src/obligations/substitution.ts +1 -5
- package/src/obligations/temporal.ts +12 -20
- package/src/obligations/tuples.ts +2 -10
- package/src/parallel-worker.ts +36 -60
- package/src/parallel.ts +64 -73
- package/src/parser.ts +1184 -531
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +12 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -64
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +510 -226
- package/src/prover/isabelle/isar/proof.ts +570 -23
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +488 -88
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +99 -38
- package/src/prover/isabelle/provers/blast/blast.ts +16 -105
- package/src/prover/isabelle/provers/blast/branch.ts +0 -33
- package/src/prover/isabelle/provers/blast/prove.ts +0 -36
- package/src/prover/isabelle/provers/blast/rules.ts +5 -45
- package/src/prover/isabelle/provers/blast/state.ts +1 -29
- package/src/prover/isabelle/provers/blast/term.ts +8 -37
- package/src/prover/isabelle/provers/clasimp.ts +1 -15
- package/src/prover/isabelle/provers/classical.ts +58 -61
- package/src/prover/isabelle/provers/hypsubst.ts +29 -54
- package/src/prover/isabelle/pure/bicompose.ts +24 -39
- package/src/prover/isabelle/pure/consts.ts +0 -8
- package/src/prover/isabelle/pure/conv.ts +2 -18
- package/src/prover/isabelle/pure/drule.ts +95 -45
- package/src/prover/isabelle/pure/envir.ts +2 -53
- package/src/prover/isabelle/pure/goal.ts +1 -9
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +1 -16
- package/src/prover/isabelle/pure/name.ts +1 -10
- package/src/prover/isabelle/pure/net.ts +2 -60
- package/src/prover/isabelle/pure/object-logic.ts +15 -16
- package/src/prover/isabelle/pure/pattern.ts +1 -20
- package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
- package/src/prover/isabelle/pure/rewriter.ts +34 -77
- package/src/prover/isabelle/pure/search.ts +2 -11
- package/src/prover/isabelle/pure/seq.ts +0 -11
- package/src/prover/isabelle/pure/simplifier.ts +27 -16
- package/src/prover/isabelle/pure/table.ts +2 -33
- package/src/prover/isabelle/pure/tactic.ts +11 -23
- package/src/prover/isabelle/pure/tactical.ts +47 -48
- package/src/prover/isabelle/pure/term-ord.ts +1 -7
- package/src/prover/isabelle/pure/term.ts +4 -47
- package/src/prover/isabelle/pure/thm.ts +26 -48
- package/src/prover/isabelle/pure/type.ts +1 -16
- package/src/prover/isabelle/pure/unify.ts +19 -31
- package/src/prover/isabelle/pure/variable.ts +2 -8
- package/src/prover/isabelle/tla/classical-setup.ts +17 -25
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +45 -44
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
- package/src/prover/ocaml.ts +4 -7
- package/src/prover/prep/action.ts +33 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +26 -31
- package/src/prover/prep/methods.ts +189 -86
- package/src/prover/prep/normalize.ts +42 -37
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +398 -133
- package/src/prover/ptl/decide.ts +96 -56
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +60 -32
- package/src/prover/smt/data.ts +517 -401
- package/src/prover/smt/encode.ts +155 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1021 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -16
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +626 -56
- 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/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +241 -99
- package/src/prover/smt/solver/ast-lt.ts +165 -21
- package/src/prover/smt/solver/ast-util.ts +160 -7
- package/src/prover/smt/solver/ast.ts +1480 -184
- package/src/prover/smt/solver/auf-solver.ts +30 -56
- 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 -10
- package/src/prover/smt/solver/cg-table.ts +39 -42
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -11
- package/src/prover/smt/solver/context.ts +600 -187
- package/src/prover/smt/solver/ctx-simplify.ts +34 -52
- 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 +39 -30
- package/src/prover/smt/solver/diff-neq.ts +205 -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 +296 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -11
- package/src/prover/smt/solver/e-matching.ts +9 -41
- package/src/prover/smt/solver/elim-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 +542 -0
- package/src/prover/smt/solver/enode.ts +100 -23
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +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 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
- 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 -26
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -9
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +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 +179 -28
- 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 -9
- package/src/prover/smt/solver/hashtable.ts +30 -23
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +113 -133
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -2
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -4
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
- package/src/prover/smt/solver/lp/constraints.ts +1 -8
- package/src/prover/smt/solver/lp/containers.ts +18 -31
- package/src/prover/smt/solver/lp/core-solver.ts +35 -37
- package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
- package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
- package/src/prover/smt/solver/lp/dependency.ts +0 -5
- package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
- package/src/prover/smt/solver/lp/explanation.ts +0 -6
- package/src/prover/smt/solver/lp/gomory.ts +8 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
- package/src/prover/smt/solver/lp/hnf.ts +10 -28
- package/src/prover/smt/solver/lp/int-cube.ts +17 -39
- package/src/prover/smt/solver/lp/int-solver.ts +3 -35
- package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
- package/src/prover/smt/solver/lp/lar-term.ts +0 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
- package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
- package/src/prover/smt/solver/lp/nex.ts +2 -7
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
- package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
- package/src/prover/smt/solver/lp/nla-core.ts +92 -136
- package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
- package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
- package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
- package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
- package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
- package/src/prover/smt/solver/lp/nla-order.ts +0 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -12
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
- package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
- package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
- package/src/prover/smt/solver/lp/pdd.ts +730 -358
- package/src/prover/smt/solver/lp/random-updater.ts +0 -9
- package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
- package/src/prover/smt/solver/lp/union-find.ts +5 -5
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +129 -139
- package/src/prover/smt/solver/mam-interpreter.ts +0 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +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 +20 -63
- package/src/prover/smt/solver/model-evaluator.ts +192 -40
- package/src/prover/smt/solver/model-finder.ts +14 -32
- package/src/prover/smt/solver/model-generator.ts +104 -46
- package/src/prover/smt/solver/model-macro-solver.ts +60 -114
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +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 +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
- package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
- package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
- package/src/prover/smt/solver/nlsat/explain.ts +429 -275
- package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
- package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
- package/src/prover/smt/solver/nlsat/solver.ts +297 -156
- 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 -9
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
- package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +112 -61
- 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 +21 -26
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +261 -79
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -30
- package/src/prover/smt/solver/proto-model.ts +650 -66
- package/src/prover/smt/solver/pull-quant.ts +28 -23
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/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 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
- package/src/prover/smt/solver/qe-lite.ts +41 -51
- 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 -16
- 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 +17 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
- package/src/prover/smt/solver/quantifier-manager.ts +22 -32
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -2
- package/src/prover/smt/solver/rational.ts +45 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +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 -6
- package/src/prover/smt/solver/relevancy.ts +2 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
- package/src/prover/smt/solver/rewriter.ts +507 -144
- package/src/prover/smt/solver/rlimit.ts +46 -24
- 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 +579 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -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 +53 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +189 -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 +3546 -406
- package/src/prover/smt/solver/smtlib-script.ts +2134 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +135 -40
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -6
- package/src/prover/smt/solver/tactic.ts +2141 -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 +55 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
- package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
- package/src/prover/smt/solver/theory-lra-model.ts +23 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
- package/src/prover/smt/solver/theory-lra-state.ts +7 -28
- package/src/prover/smt/solver/theory-lra.ts +189 -9
- 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 +486 -0
- package/src/prover/smt/solver/var-subst.ts +37 -39
- package/src/prover/smt/table.ts +3 -10
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +74 -48
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -19
- package/src/prover/zenon/encode.ts +0 -9
- package/src/prover/zenon/eqrel.ts +2 -15
- package/src/prover/zenon/equality-rules.ts +24 -6
- package/src/prover/zenon/expr.ts +29 -28
- package/src/prover/zenon/index-table.ts +33 -61
- package/src/prover/zenon/isar-case.ts +9 -21
- package/src/prover/zenon/isar.ts +37 -67
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -22
- package/src/prover/zenon/mltoll.ts +66 -106
- package/src/prover/zenon/node.ts +20 -15
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +9 -13
- package/src/prover/zenon/phrase.ts +2 -14
- package/src/prover/zenon/proof.ts +0 -11
- package/src/prover/zenon/propositional-rules.ts +0 -7
- package/src/prover/zenon/rules.ts +3 -8
- package/src/prover/zenon/search.ts +11 -35
- package/src/prover/zenon/tla/functions.ts +59 -33
- package/src/prover/zenon/tla/llproof.ts +67 -78
- package/src/prover/zenon/tla/records.ts +57 -35
- package/src/prover/zenon/tla/rewrites.ts +12 -21
- package/src/prover/zenon/tla/sets.ts +88 -59
- package/src/prover/zenon/tla/terms.ts +0 -8
- package/src/prover/zenon/tla/tla.ts +66 -66
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +1132 -430
- package/src/runtime.ts +33 -23
- package/src/sany/builtins.ts +11 -14
- package/src/sany/generation.ts +383 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1108 -0
- package/src/sany/generator-proofs.ts +665 -0
- package/src/sany/generator.ts +192 -2764
- package/src/sany/levels.ts +5 -35
- package/src/sany/lexer.ts +61 -80
- package/src/sany/linter.ts +0 -10
- package/src/sany/modules.ts +5 -7
- package/src/sany/nodes.ts +6 -44
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +60 -82
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +37 -120
- package/src/search.ts +913 -227
- package/src/simulate.ts +765 -0
- package/src/spec-description.ts +198 -104
- package/src/standard-definitions.ts +4 -4
- package/src/standard-modules.ts +302 -99
- package/src/state-graph.ts +52 -33
- package/src/subexpressions.ts +578 -166
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +299 -108
- package/src/symmetry.ts +37 -28
- package/src/tableau.ts +29 -26
- package/src/tlc/fingerprint.ts +267 -79
- package/src/tlc/jar-data.ts +122 -6
- package/src/tlc/messages.ts +127 -56
- package/src/tlc/order.ts +53 -72
- package/src/tlc/random.ts +38 -49
- package/src/tlc/replay.ts +579 -230
- package/src/tlc/summary.ts +64 -60
- package/src/tlc/tlc-operators.ts +83 -47
- package/src/tlc/tlcext-operators.ts +205 -127
- package/src/tlc/trace-spec.ts +235 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/trace-liveness.ts +529 -0
- package/src/transfer.ts +22 -25
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +945 -526
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/liveness-checker.ts
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
import { TlaEvaluationError } from "./errors";
|
|
2
|
+
import { isExpressionImpure } from "./dependencies";
|
|
2
3
|
import { hasRepeatedEffects, type Environment } from "./evaluate";
|
|
3
4
|
import {
|
|
4
|
-
createTautologyError,
|
|
5
|
-
evaluateLive,
|
|
6
5
|
evaluateOnLasso,
|
|
6
|
+
getInterpretedAtoms,
|
|
7
7
|
toLiveExpression,
|
|
8
|
+
type LiveAtoms,
|
|
8
9
|
type ScopedExpression,
|
|
9
10
|
type TemporalProperty,
|
|
10
11
|
} from "./liveness";
|
|
@@ -14,30 +15,30 @@ import {
|
|
|
14
15
|
getSolutions,
|
|
15
16
|
getTermKey,
|
|
16
17
|
isFulfilling,
|
|
18
|
+
type LiveAction,
|
|
19
|
+
type LiveEnabled,
|
|
17
20
|
type LiveExpression,
|
|
21
|
+
type LiveState,
|
|
18
22
|
type Solution,
|
|
19
23
|
type Tableau,
|
|
20
24
|
} from "./tableau";
|
|
25
|
+
import { findTraceLasso, type TraceLasso } from "./trace-liveness";
|
|
21
26
|
import { isSameValue, type Value } from "./values";
|
|
22
27
|
|
|
23
|
-
export interface LiveSuccessor {
|
|
28
|
+
export interface LiveSuccessor<State = Value[]> {
|
|
24
29
|
index: number;
|
|
25
|
-
state:
|
|
30
|
+
state: State;
|
|
26
31
|
}
|
|
27
32
|
|
|
28
33
|
export interface Lasso {
|
|
29
34
|
prefix: number[];
|
|
30
35
|
cycle: number[];
|
|
31
|
-
// Whether the solution that the lasso violates constrains the cycle, as a liveness property does.
|
|
32
|
-
// TLC warns that a stuttering counterexample to one may come from a missing fairness constraint.
|
|
33
36
|
isCycleConstrained: boolean;
|
|
34
37
|
}
|
|
35
38
|
|
|
36
39
|
export interface LivenessChecker {
|
|
37
|
-
// How many solutions of the negated properties TLC checks, which it calls branches.
|
|
38
40
|
branches: number;
|
|
39
|
-
|
|
40
|
-
// check does.
|
|
41
|
+
solutions: Solution[];
|
|
41
42
|
addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
|
|
42
43
|
addState: (
|
|
43
44
|
index: number,
|
|
@@ -45,46 +46,101 @@ export interface LivenessChecker {
|
|
|
45
46
|
successors: LiveSuccessor[],
|
|
46
47
|
tracing?: Environment,
|
|
47
48
|
) => number[] | undefined;
|
|
49
|
+
storeState: (pending: number, index: number) => void;
|
|
50
|
+
getStateCounts: () => number[];
|
|
48
51
|
findViolation: () => Lasso | undefined;
|
|
49
52
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
50
53
|
}
|
|
51
54
|
|
|
52
|
-
interface
|
|
53
|
-
|
|
54
|
-
|
|
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;
|
|
55
102
|
}
|
|
56
103
|
|
|
57
|
-
// Numbers in a typed array that doubles as it fills, so a graph of millions of nodes takes a few
|
|
58
|
-
// bytes for each.
|
|
59
104
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
60
105
|
data: Data;
|
|
61
106
|
length: number;
|
|
62
107
|
create: (length: number) => Data;
|
|
63
108
|
}
|
|
64
109
|
|
|
65
|
-
//
|
|
66
|
-
|
|
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> {
|
|
67
127
|
solution: Solution;
|
|
68
|
-
|
|
128
|
+
checks: BehaviorChecks<State>;
|
|
69
129
|
actionIds: Int32Array;
|
|
70
130
|
nodeStates: number[];
|
|
71
131
|
nodeTableaux: number[];
|
|
72
|
-
// Where a node's edges start in edgeTargets, or UNWRITTEN until TLC writes the node with its
|
|
73
|
-
// successors, and how many it has.
|
|
74
132
|
edgeStarts: number[];
|
|
75
133
|
edgeCounts: number[];
|
|
76
134
|
edgeTargets: Pool<Int32Array>;
|
|
77
|
-
// The results of the action checks on each edge, and of the state checks on each state, which
|
|
78
|
-
// are the same for every node of the state.
|
|
79
135
|
edgeActions: Pool<Uint8Array>;
|
|
80
136
|
stateResults: Pool<Uint8Array>;
|
|
81
137
|
initial: number[];
|
|
82
|
-
// The nodes of each state in the order they are recorded, a list through nextSiblings.
|
|
83
138
|
firstNodes: Pool<Int32Array>;
|
|
84
139
|
lastNodes: Pool<Int32Array>;
|
|
85
140
|
nextSiblings: number[];
|
|
86
141
|
nodeIds: NodeTable;
|
|
87
142
|
isDone: boolean[];
|
|
143
|
+
stateCount: number;
|
|
88
144
|
errorNode: number | undefined;
|
|
89
145
|
}
|
|
90
146
|
|
|
@@ -104,15 +160,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
|
|
|
104
160
|
}
|
|
105
161
|
};
|
|
106
162
|
|
|
107
|
-
|
|
163
|
+
const isEmptyModel = (model: Solution["models"][number]) =>
|
|
164
|
+
model.eventuallyAlways.length === 0 &&
|
|
165
|
+
model.infinitelyOftenStates.length === 0 &&
|
|
166
|
+
model.infinitelyOftenActions.length === 0;
|
|
167
|
+
|
|
108
168
|
const isCycleConstrained = (solution: Solution) =>
|
|
109
169
|
solution.promises.some((promise) => containsAlways(promise.body)) ||
|
|
110
|
-
solution.models.some(
|
|
111
|
-
(model) =>
|
|
112
|
-
model.eventuallyAlways.length > 0 ||
|
|
113
|
-
model.infinitelyOftenStates.length > 0 ||
|
|
114
|
-
model.infinitelyOftenActions.length > 0,
|
|
115
|
-
);
|
|
170
|
+
solution.models.some((model) => !isEmptyModel(model));
|
|
116
171
|
|
|
117
172
|
const isSameState = (left: Value[], right: Value[]) =>
|
|
118
173
|
left.every((value, position) => isSameValue(value, right[position]));
|
|
@@ -128,21 +183,24 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
128
183
|
pool: Pool<Data>,
|
|
129
184
|
offset: number,
|
|
130
185
|
values: ArrayLike<number>,
|
|
186
|
+
start = 0,
|
|
187
|
+
length = values.length - start,
|
|
131
188
|
) => {
|
|
132
|
-
const end = offset +
|
|
189
|
+
const end = offset + length;
|
|
133
190
|
if (end > pool.data.length) {
|
|
134
191
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
135
192
|
data.set(pool.data);
|
|
136
193
|
pool.data = data;
|
|
137
194
|
}
|
|
138
|
-
|
|
195
|
+
for (let position = 0; position < length; position++) {
|
|
196
|
+
pool.data[offset + position] = values[start + position];
|
|
197
|
+
}
|
|
139
198
|
pool.length = Math.max(pool.length, end);
|
|
140
199
|
};
|
|
141
200
|
|
|
142
201
|
const NO_NODE = -1;
|
|
143
202
|
|
|
144
|
-
// A Map holds at most 2^24 entries, so
|
|
145
|
-
// open-addressing table of (state plus one, tableau node, node) triples.
|
|
203
|
+
// A Map holds at most 2^24 entries, so an open-addressing table of (state plus one, tableau node, node) triples finds each node.
|
|
146
204
|
interface NodeTable {
|
|
147
205
|
slots: Int32Array;
|
|
148
206
|
size: number;
|
|
@@ -165,21 +223,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
165
223
|
|
|
166
224
|
const UNWRITTEN = -1;
|
|
167
225
|
|
|
168
|
-
const isWritten = (behavior: BehaviorGraph
|
|
226
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
169
227
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
170
228
|
|
|
171
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
229
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
172
230
|
const start = behavior.edgeStarts[node];
|
|
173
231
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
174
232
|
};
|
|
175
233
|
|
|
176
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
234
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
177
235
|
behavior.stateResults.data[
|
|
178
236
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
179
237
|
] === 1;
|
|
180
238
|
|
|
181
|
-
|
|
182
|
-
const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
|
|
239
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
183
240
|
behavior.nodeStates.push(state);
|
|
184
241
|
behavior.nodeTableaux.push(tableauNode);
|
|
185
242
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -188,7 +245,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
188
245
|
return behavior.nodeStates.length - 1;
|
|
189
246
|
};
|
|
190
247
|
|
|
191
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
248
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
192
249
|
const nodes: number[] = [];
|
|
193
250
|
for (
|
|
194
251
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -208,34 +265,315 @@ const UNVISITED = -1;
|
|
|
208
265
|
|
|
209
266
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
210
267
|
|
|
211
|
-
|
|
268
|
+
const getLiveFormula = (
|
|
212
269
|
properties: TemporalProperty[],
|
|
213
270
|
temporals: ScopedExpression[],
|
|
214
271
|
environment: Environment,
|
|
215
|
-
|
|
216
|
-
): LivenessChecker | undefined => {
|
|
217
|
-
if (properties.length === 0) return undefined;
|
|
272
|
+
) => {
|
|
218
273
|
const fairness = temporals.map((item) =>
|
|
219
274
|
toLiveExpression(item.expression, item.scope, environment),
|
|
220
275
|
);
|
|
221
|
-
const
|
|
222
|
-
|
|
276
|
+
const checks = properties.map((property) =>
|
|
277
|
+
toLiveExpression(property.expression, property.scope, environment),
|
|
223
278
|
);
|
|
279
|
+
const negations = checks.map((check) => createUnary("Not", check));
|
|
224
280
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
225
281
|
const formula =
|
|
226
282
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
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
|
+
);
|
|
230
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> => {
|
|
231
472
|
const actionIds = new Map<string, number>();
|
|
232
|
-
|
|
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> => ({
|
|
233
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
|
+
},
|
|
234
572
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
235
573
|
const key = getTermKey(predicate);
|
|
236
|
-
const
|
|
237
|
-
actionIds.set(key,
|
|
238
|
-
return
|
|
574
|
+
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
575
|
+
actionIds.set(key, actionId);
|
|
576
|
+
return actionId;
|
|
239
577
|
}),
|
|
240
578
|
nodeStates: [],
|
|
241
579
|
nodeTableaux: [],
|
|
@@ -250,90 +588,88 @@ export const createLivenessChecker = (
|
|
|
250
588
|
nextSiblings: [],
|
|
251
589
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
252
590
|
isDone: [],
|
|
591
|
+
stateCount: 0,
|
|
253
592
|
errorNode: undefined,
|
|
254
593
|
}));
|
|
255
|
-
const
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
//
|
|
271
|
-
const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
|
|
272
|
-
environment.runtime.setLivenessSource(source);
|
|
273
|
-
const result = evaluate();
|
|
274
|
-
environment.runtime.setLivenessSource(undefined);
|
|
275
|
-
return result;
|
|
276
|
-
};
|
|
277
|
-
const evaluateState = (predicate: LiveExpression, state: Value[]) =>
|
|
278
|
-
evaluateLive(
|
|
279
|
-
predicate,
|
|
280
|
-
state,
|
|
281
|
-
undefined,
|
|
282
|
-
evaluation.environment,
|
|
283
|
-
isShared ? getStateCache(state) : new Map(),
|
|
284
|
-
);
|
|
285
|
-
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
286
|
-
evaluateFrom(source, () =>
|
|
287
|
-
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
288
|
-
evaluateState(predicate, state) ? 1 : 0,
|
|
289
|
-
),
|
|
290
|
-
);
|
|
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.
|
|
291
610
|
const checkAction = (
|
|
292
|
-
behavior: BehaviorGraph
|
|
611
|
+
behavior: BehaviorGraph<State>,
|
|
293
612
|
source: number,
|
|
294
|
-
state:
|
|
295
|
-
|
|
613
|
+
state: State,
|
|
614
|
+
row: Int8Array,
|
|
615
|
+
offset: number,
|
|
616
|
+
successor: State,
|
|
617
|
+
edges: Int8Array,
|
|
618
|
+
edgeOffset: number,
|
|
619
|
+
results: Uint8Array,
|
|
620
|
+
resultOffset: number,
|
|
296
621
|
) =>
|
|
297
622
|
evaluateFrom(source, () => {
|
|
298
|
-
const
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
}
|
|
304
|
-
const stateCache = getStateCache(state);
|
|
305
|
-
const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
|
|
306
|
-
shared.actions.set(state, results);
|
|
307
|
-
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
308
|
-
results.set(successor, known);
|
|
309
|
-
return Uint8Array.from(behavior.actionIds, (id, position) => {
|
|
310
|
-
if (known[id] === -1) {
|
|
311
|
-
known[id] = evaluateLive(
|
|
312
|
-
predicates[position],
|
|
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],
|
|
313
628
|
state,
|
|
629
|
+
row,
|
|
630
|
+
offset,
|
|
314
631
|
successor,
|
|
315
|
-
evaluation.environment,
|
|
316
|
-
stateCache,
|
|
317
632
|
)
|
|
318
633
|
? 1
|
|
319
634
|
: 0;
|
|
635
|
+
continue;
|
|
320
636
|
}
|
|
321
|
-
|
|
322
|
-
|
|
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
|
+
}
|
|
323
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
|
+
};
|
|
324
662
|
const isConsistent = (
|
|
325
|
-
|
|
663
|
+
behavior: BehaviorGraph<State>,
|
|
326
664
|
node: number,
|
|
327
665
|
source: number | undefined,
|
|
328
|
-
state:
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
// TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
|
|
334
|
-
// of a property like a safety property only in its liveness checks.
|
|
666
|
+
state: State,
|
|
667
|
+
row: Int8Array,
|
|
668
|
+
offset: number,
|
|
669
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
670
|
+
|
|
335
671
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
336
|
-
if (
|
|
672
|
+
if (!isAcceptingFound) return false;
|
|
337
673
|
const tableauNode = tableau.nodes[node];
|
|
338
674
|
return (
|
|
339
675
|
tableauNode.particle.length === 0 &&
|
|
@@ -341,22 +677,19 @@ export const createLivenessChecker = (
|
|
|
341
677
|
tableauNode.successors[0] === node
|
|
342
678
|
);
|
|
343
679
|
};
|
|
344
|
-
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
345
|
-
behavior.solution.models.some(
|
|
346
|
-
(model) =>
|
|
347
|
-
model.eventuallyAlways.length === 0 &&
|
|
348
|
-
model.infinitelyOftenStates.length === 0 &&
|
|
349
|
-
model.infinitelyOftenActions.length === 0,
|
|
350
|
-
);
|
|
351
680
|
|
|
352
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
681
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
353
682
|
if (!behavior.solution.tableau) return state;
|
|
354
683
|
const slots = behavior.nodeIds.slots;
|
|
355
684
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
356
685
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
357
686
|
};
|
|
358
|
-
const
|
|
359
|
-
|
|
687
|
+
const linkNode = (
|
|
688
|
+
behavior: BehaviorGraph<State>,
|
|
689
|
+
state: number,
|
|
690
|
+
tableauNode: number,
|
|
691
|
+
node: number,
|
|
692
|
+
) => {
|
|
360
693
|
const table = behavior.nodeIds;
|
|
361
694
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
362
695
|
const old = table.slots;
|
|
@@ -372,24 +705,43 @@ export const createLivenessChecker = (
|
|
|
372
705
|
}
|
|
373
706
|
}
|
|
374
707
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
708
|
+
if (state < 0) return node;
|
|
375
709
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
376
710
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
377
711
|
else behavior.nextSiblings[last] = node;
|
|
378
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
379
713
|
return node;
|
|
380
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.
|
|
381
726
|
const writeNode = (
|
|
382
|
-
behavior: BehaviorGraph
|
|
727
|
+
behavior: BehaviorGraph<State>,
|
|
383
728
|
node: number,
|
|
384
729
|
targets: number[],
|
|
385
|
-
|
|
730
|
+
actionResults: Uint8Array,
|
|
731
|
+
actions: number[],
|
|
386
732
|
stateResults: Uint8Array,
|
|
387
733
|
) => {
|
|
388
734
|
const start = behavior.edgeTargets.length;
|
|
389
735
|
const actionCount = behavior.solution.actionChecks.length;
|
|
390
736
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
391
|
-
actions.forEach((
|
|
392
|
-
writeToPool(
|
|
737
|
+
actions.forEach((position, edge) =>
|
|
738
|
+
writeToPool(
|
|
739
|
+
behavior.edgeActions,
|
|
740
|
+
(start + edge) * actionCount,
|
|
741
|
+
actionResults,
|
|
742
|
+
position * actionCount,
|
|
743
|
+
actionCount,
|
|
744
|
+
),
|
|
393
745
|
);
|
|
394
746
|
writeToPool(
|
|
395
747
|
behavior.stateResults,
|
|
@@ -400,67 +752,73 @@ export const createLivenessChecker = (
|
|
|
400
752
|
behavior.edgeCounts[node] = targets.length;
|
|
401
753
|
};
|
|
402
754
|
|
|
403
|
-
// TLC
|
|
404
|
-
//
|
|
405
|
-
|
|
406
|
-
const getSuccessorSet = (index: number, state:
|
|
407
|
-
const
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
const
|
|
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.
|
|
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];
|
|
414
768
|
for (
|
|
415
|
-
let slot = (search.getFingerprint(
|
|
769
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
416
770
|
;
|
|
417
771
|
slot = (slot + 1) % slots.length
|
|
418
772
|
) {
|
|
419
773
|
const entry = slots[slot];
|
|
420
|
-
if (entry ===
|
|
421
|
-
slots[slot] =
|
|
774
|
+
if (entry === 0) {
|
|
775
|
+
slots[slot] = position + 1;
|
|
422
776
|
return true;
|
|
423
777
|
}
|
|
424
|
-
|
|
778
|
+
const stored = candidates[entry - 1];
|
|
779
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
425
780
|
return false;
|
|
426
781
|
}
|
|
427
782
|
};
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
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);
|
|
433
789
|
}
|
|
434
|
-
if (
|
|
435
|
-
}
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
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;
|
|
440
796
|
};
|
|
441
797
|
|
|
442
|
-
// TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
|
|
443
798
|
const expandLate = (
|
|
444
|
-
behavior: BehaviorGraph
|
|
799
|
+
behavior: BehaviorGraph<State>,
|
|
445
800
|
tableau: Tableau,
|
|
446
|
-
state:
|
|
801
|
+
state: State,
|
|
447
802
|
index: number,
|
|
448
803
|
node: number,
|
|
804
|
+
row: Int8Array,
|
|
805
|
+
offset: number,
|
|
449
806
|
) => {
|
|
450
|
-
const stateResults = checkState(behavior, index, state);
|
|
807
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
451
808
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
452
|
-
const
|
|
809
|
+
const actionCount = behavior.checks.actions.length;
|
|
810
|
+
const actions: number[] = [];
|
|
453
811
|
const successors: number[] = [];
|
|
454
|
-
const
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
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
|
+
}
|
|
458
816
|
for (const next of tableauNode.successors) {
|
|
459
|
-
if (!isConsistent(
|
|
817
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
460
818
|
if (
|
|
461
819
|
isAccepting(tableau, next) &&
|
|
462
820
|
behavior.errorNode === undefined &&
|
|
463
|
-
|
|
821
|
+
behavior.solution.models.some(isEmptyModel)
|
|
464
822
|
) {
|
|
465
823
|
behavior.errorNode = node;
|
|
466
824
|
return;
|
|
@@ -469,90 +827,140 @@ export const createLivenessChecker = (
|
|
|
469
827
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
470
828
|
const target = existing ?? recordNode(behavior, index, next);
|
|
471
829
|
successors.push(target);
|
|
472
|
-
actions.push(
|
|
473
|
-
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);
|
|
474
832
|
}
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
const
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
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
|
+
}
|
|
490
874
|
}
|
|
491
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);
|
|
492
885
|
}
|
|
493
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
494
886
|
};
|
|
495
887
|
|
|
496
888
|
const addTableauState = (
|
|
497
|
-
behavior: BehaviorGraph
|
|
889
|
+
behavior: BehaviorGraph<State>,
|
|
498
890
|
tableau: Tableau,
|
|
499
|
-
set: LiveSuccessor[],
|
|
500
|
-
|
|
891
|
+
set: LiveSuccessor<State>[],
|
|
892
|
+
rows: Int8Array,
|
|
893
|
+
actionResults: Uint8Array,
|
|
501
894
|
stateResults: Uint8Array,
|
|
502
895
|
index: number,
|
|
503
896
|
) => {
|
|
504
|
-
const
|
|
505
|
-
|
|
506
|
-
);
|
|
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++;
|
|
507
910
|
behavior.isDone[index] = true;
|
|
508
911
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
509
912
|
for (const node of getStateNodes(behavior, index)) {
|
|
510
913
|
const successors: number[] = [];
|
|
511
|
-
const actions:
|
|
914
|
+
const actions: number[] = [];
|
|
512
915
|
set.forEach((successor, position) => {
|
|
513
916
|
const isDone = behavior.isDone[successor.index] === true;
|
|
514
917
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
515
|
-
if (
|
|
918
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
516
919
|
const existing = getNodeId(behavior, successor.index, next);
|
|
517
920
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
518
921
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
519
922
|
successors.push(target);
|
|
520
|
-
actions.push(
|
|
923
|
+
actions.push(position);
|
|
521
924
|
if (existing === undefined && isDone) {
|
|
522
|
-
expandLate(
|
|
925
|
+
expandLate(
|
|
926
|
+
behavior,
|
|
927
|
+
tableau,
|
|
928
|
+
successor.state,
|
|
929
|
+
successor.index,
|
|
930
|
+
target,
|
|
931
|
+
rows,
|
|
932
|
+
position * atomCount,
|
|
933
|
+
);
|
|
523
934
|
}
|
|
524
935
|
}
|
|
525
936
|
});
|
|
526
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
937
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
527
938
|
}
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
.reverse()
|
|
532
|
-
.map((node) => behavior.nodeStates[node]),
|
|
533
|
-
);
|
|
939
|
+
return behavior.errorNode === undefined
|
|
940
|
+
? undefined
|
|
941
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
534
942
|
};
|
|
535
943
|
|
|
536
944
|
const addPlainState = (
|
|
537
|
-
behavior: BehaviorGraph
|
|
538
|
-
set: LiveSuccessor[],
|
|
539
|
-
actionResults: Uint8Array
|
|
945
|
+
behavior: BehaviorGraph<State>,
|
|
946
|
+
set: LiveSuccessor<State>[],
|
|
947
|
+
actionResults: Uint8Array,
|
|
540
948
|
stateResults: Uint8Array,
|
|
541
949
|
index: number,
|
|
542
950
|
) => {
|
|
543
951
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
544
952
|
const successors: number[] = [];
|
|
545
|
-
const actions:
|
|
953
|
+
const actions: number[] = [];
|
|
546
954
|
set.forEach((successor, position) => {
|
|
547
955
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
548
956
|
successors.push(successor.index);
|
|
549
|
-
actions.push(
|
|
957
|
+
actions.push(position);
|
|
550
958
|
});
|
|
551
|
-
|
|
959
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
960
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
552
961
|
};
|
|
553
962
|
|
|
554
|
-
|
|
555
|
-
const getPath = (behavior: BehaviorGraph, target: number) => {
|
|
963
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
556
964
|
if (behavior.initial.includes(target)) return [target];
|
|
557
965
|
const parents = new Map<number, number>();
|
|
558
966
|
const queue: number[] = [];
|
|
@@ -578,9 +986,15 @@ export const createLivenessChecker = (
|
|
|
578
986
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
579
987
|
};
|
|
580
988
|
|
|
581
|
-
|
|
989
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
990
|
+
removeRepeats(
|
|
991
|
+
getPath(behavior, target)
|
|
992
|
+
.reverse()
|
|
993
|
+
.map((node) => behavior.nodeStates[node]),
|
|
994
|
+
);
|
|
995
|
+
|
|
582
996
|
const findLassoInModel = (
|
|
583
|
-
behavior: BehaviorGraph
|
|
997
|
+
behavior: BehaviorGraph<State>,
|
|
584
998
|
model: Solution["models"][number],
|
|
585
999
|
): Lasso | undefined => {
|
|
586
1000
|
const solution = behavior.solution;
|
|
@@ -635,91 +1049,85 @@ export const createLivenessChecker = (
|
|
|
635
1049
|
return getLasso(root, members, membersByState);
|
|
636
1050
|
};
|
|
637
1051
|
|
|
638
|
-
// TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component
|
|
639
|
-
// until it satisfies every check, and a breadth-first path back to the root.
|
|
640
1052
|
const getLasso = (
|
|
641
1053
|
root: number,
|
|
642
1054
|
members: Set<number>,
|
|
643
1055
|
membersByState: Map<number, number[]>,
|
|
644
1056
|
) => {
|
|
645
|
-
const prefix =
|
|
646
|
-
getPath(behavior, root)
|
|
647
|
-
.reverse()
|
|
648
|
-
.map((node) => behavior.nodeStates[node]),
|
|
649
|
-
);
|
|
1057
|
+
const prefix = getStatePath(behavior, root);
|
|
650
1058
|
const cycleStack: number[] = [];
|
|
651
1059
|
const seen = new Set<number>([root]);
|
|
652
1060
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
653
1061
|
const actionDone = model.infinitelyOftenActions.map(() => false);
|
|
654
1062
|
const promiseDone = solution.promises.map(() => false);
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
const isMember = (node: number) => members.has(node);
|
|
1063
|
+
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
1064
|
+
let currentNode = root;
|
|
658
1065
|
const moveTo = (next: number) => {
|
|
659
|
-
cycleStack.push(
|
|
660
|
-
|
|
1066
|
+
cycleStack.push(currentNode);
|
|
1067
|
+
currentNode = next;
|
|
661
1068
|
};
|
|
662
|
-
while (
|
|
663
|
-
const countAtStart =
|
|
1069
|
+
while (remainingCount > 0) {
|
|
1070
|
+
const countAtStart = remainingCount;
|
|
664
1071
|
while (true) {
|
|
665
1072
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
666
|
-
if (!stateDone[slot] && getStateResult(behavior,
|
|
1073
|
+
if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
|
|
667
1074
|
stateDone[slot] = true;
|
|
668
|
-
|
|
1075
|
+
remainingCount--;
|
|
669
1076
|
}
|
|
670
1077
|
});
|
|
671
1078
|
solution.promises.forEach((promise, position) => {
|
|
672
|
-
if (!promiseDone[position] && isFulfilled(
|
|
1079
|
+
if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
|
|
673
1080
|
promiseDone[position] = true;
|
|
674
|
-
|
|
1081
|
+
remainingCount--;
|
|
675
1082
|
}
|
|
676
1083
|
});
|
|
677
|
-
if (
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
const
|
|
1084
|
+
if (remainingCount <= 0) break;
|
|
1085
|
+
let lastNext = -1;
|
|
1086
|
+
let unvisitedNext = -1;
|
|
1087
|
+
const countBeforeActions = remainingCount;
|
|
1088
|
+
const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
|
|
681
1089
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
682
|
-
if (!
|
|
683
|
-
|
|
1090
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
1091
|
+
lastNext = next;
|
|
684
1092
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
685
|
-
if (!actionDone[slot] && getAction(
|
|
1093
|
+
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
686
1094
|
actionDone[slot] = true;
|
|
687
|
-
|
|
1095
|
+
remainingCount--;
|
|
688
1096
|
}
|
|
689
1097
|
});
|
|
690
1098
|
}
|
|
691
|
-
if (
|
|
1099
|
+
if (remainingCount < countBeforeActions) {
|
|
692
1100
|
moveTo(next);
|
|
693
1101
|
seen.clear();
|
|
694
1102
|
return true;
|
|
695
1103
|
}
|
|
696
|
-
if (
|
|
1104
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
697
1105
|
return false;
|
|
698
1106
|
});
|
|
699
|
-
if (
|
|
700
|
-
if (
|
|
701
|
-
moveTo(
|
|
1107
|
+
if (isTaken) break;
|
|
1108
|
+
if (remainingCount < countAtStart) {
|
|
1109
|
+
moveTo(lastNext);
|
|
702
1110
|
seen.clear();
|
|
703
1111
|
break;
|
|
704
1112
|
}
|
|
705
|
-
while (
|
|
1113
|
+
while (unvisitedNext === -1) {
|
|
706
1114
|
const previous = cycleStack.pop();
|
|
707
1115
|
if (previous === undefined) {
|
|
708
1116
|
throw new TlaEvaluationError(
|
|
709
1117
|
"TLC failed to build the counterexample of a liveness property",
|
|
710
1118
|
);
|
|
711
1119
|
}
|
|
712
|
-
|
|
713
|
-
|
|
1120
|
+
currentNode = previous;
|
|
1121
|
+
unvisitedNext =
|
|
714
1122
|
getNodeSuccessors(behavior, previous).find(
|
|
715
|
-
(next) =>
|
|
1123
|
+
(next) => members.has(next) && !seen.has(next),
|
|
716
1124
|
) ?? -1;
|
|
717
1125
|
}
|
|
718
|
-
moveTo(
|
|
719
|
-
seen.add(
|
|
1126
|
+
moveTo(unvisitedNext);
|
|
1127
|
+
seen.add(unvisitedNext);
|
|
720
1128
|
}
|
|
721
1129
|
}
|
|
722
|
-
const postfix = getClosingPath(root,
|
|
1130
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
723
1131
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
724
1132
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
725
1133
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -733,13 +1141,7 @@ export const createLivenessChecker = (
|
|
|
733
1141
|
};
|
|
734
1142
|
};
|
|
735
1143
|
|
|
736
|
-
|
|
737
|
-
const getClosingPath = (
|
|
738
|
-
root: number,
|
|
739
|
-
end: number,
|
|
740
|
-
membersByState: Map<number, number[]>,
|
|
741
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
742
|
-
) => {
|
|
1144
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
743
1145
|
if (end === root) return [];
|
|
744
1146
|
const start = behavior.nodeStates[end];
|
|
745
1147
|
const parents = new Map<number, number>();
|
|
@@ -748,7 +1150,7 @@ export const createLivenessChecker = (
|
|
|
748
1150
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
749
1151
|
for (const node of membersByState.get(state) ?? []) {
|
|
750
1152
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
751
|
-
if (next === node || !
|
|
1153
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
752
1154
|
if (next === root) {
|
|
753
1155
|
const path: number[] = [];
|
|
754
1156
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -779,7 +1181,7 @@ export const createLivenessChecker = (
|
|
|
779
1181
|
|
|
780
1182
|
for (let position = 0; position < queue.length; position++) {
|
|
781
1183
|
const stack = [queue[position], UNVISITED, 0];
|
|
782
|
-
|
|
1184
|
+
let nextLink = 0;
|
|
783
1185
|
while (stack.length >= 3) {
|
|
784
1186
|
const lowLink = stack.pop() ?? 0;
|
|
785
1187
|
const location = stack.pop();
|
|
@@ -796,10 +1198,10 @@ export const createLivenessChecker = (
|
|
|
796
1198
|
stack.push(Math.min(lowLink, links[node]));
|
|
797
1199
|
continue;
|
|
798
1200
|
}
|
|
799
|
-
links[node] =
|
|
1201
|
+
links[node] = nextLink;
|
|
800
1202
|
stack.push(lowLink, node, SCC_MARKER);
|
|
801
1203
|
components.push(node);
|
|
802
|
-
|
|
1204
|
+
let nextLowLink = nextLink++;
|
|
803
1205
|
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
804
1206
|
if (!isWritten(behavior, next)) return;
|
|
805
1207
|
if (!isAllowed(node, edge)) {
|
|
@@ -807,9 +1209,9 @@ export const createLivenessChecker = (
|
|
|
807
1209
|
return;
|
|
808
1210
|
}
|
|
809
1211
|
if (links[next] === UNVISITED) stack.push(next, UNVISITED);
|
|
810
|
-
else nextLowLink
|
|
1212
|
+
else nextLowLink = Math.min(nextLowLink, links[next]);
|
|
811
1213
|
});
|
|
812
|
-
stack.push(nextLowLink
|
|
1214
|
+
stack.push(nextLowLink);
|
|
813
1215
|
}
|
|
814
1216
|
}
|
|
815
1217
|
return undefined;
|
|
@@ -817,59 +1219,89 @@ export const createLivenessChecker = (
|
|
|
817
1219
|
|
|
818
1220
|
return {
|
|
819
1221
|
branches: behaviors.length,
|
|
820
|
-
addInitialState: (index, state
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
behavior.initial.push(
|
|
834
|
-
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
835
|
-
);
|
|
836
|
-
}
|
|
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
|
+
);
|
|
837
1235
|
}
|
|
838
|
-
} finally {
|
|
839
|
-
evaluation.environment = environment;
|
|
840
1236
|
}
|
|
841
1237
|
},
|
|
842
|
-
addState: (index, state, successors,
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
const tableau = behavior.solution.tableau;
|
|
854
|
-
if (!tableau) {
|
|
855
|
-
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
856
|
-
continue;
|
|
857
|
-
}
|
|
858
|
-
const accepted = addTableauState(
|
|
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(
|
|
859
1249
|
behavior,
|
|
860
|
-
tableau,
|
|
861
|
-
set,
|
|
862
|
-
actionResults,
|
|
863
|
-
stateResults,
|
|
864
1250
|
index,
|
|
865
|
-
|
|
866
|
-
|
|
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.");
|
|
867
1271
|
}
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
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;
|
|
871
1286
|
}
|
|
1287
|
+
return undefined;
|
|
872
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);
|
|
1301
|
+
}
|
|
1302
|
+
}
|
|
1303
|
+
},
|
|
1304
|
+
getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
|
|
873
1305
|
findViolation: () => {
|
|
874
1306
|
for (const behavior of behaviors) {
|
|
875
1307
|
for (const model of behavior.solution.models) {
|
|
@@ -879,16 +1311,5 @@ export const createLivenessChecker = (
|
|
|
879
1311
|
}
|
|
880
1312
|
return undefined;
|
|
881
1313
|
},
|
|
882
|
-
// TLC names every property that the counterexample violates, once each.
|
|
883
|
-
getViolatedProperties: (path, cycleStart) => [
|
|
884
|
-
...new Set(
|
|
885
|
-
properties
|
|
886
|
-
.filter(
|
|
887
|
-
(_, position) =>
|
|
888
|
-
!evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
|
|
889
|
-
)
|
|
890
|
-
.map((property) => property.name),
|
|
891
|
-
),
|
|
892
|
-
],
|
|
893
1314
|
};
|
|
894
1315
|
};
|