tla-ts 0.0.9-dev.8298a52 → 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 +8 -0
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +57 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +121 -12
- package/dist/index.d.ts +121 -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 +1 -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 +1155 -900
- 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 +318 -656
- package/src/cli/typescript.ts +0 -3
- 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 +260 -371
- package/src/errors.ts +93 -58
- package/src/evaluate.ts +848 -374
- package/src/exit-codes.ts +63 -13
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +97 -43
- 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 -325
- package/src/liveness.ts +224 -131
- 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 +34 -57
- package/src/parallel.ts +62 -72
- 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 +129 -38
- 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 +296 -105
- 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 +10 -25
- package/src/typescript/collections.ts +34 -35
- package/src/typescript/compile.ts +1 -8
- package/src/typescript/context.ts +0 -12
- package/src/typescript/emit.ts +0 -1
- package/src/typescript/expressions.ts +0 -12
- package/src/typescript/formula.ts +9 -15
- package/src/typescript/functions.ts +6 -17
- package/src/typescript/model.ts +14 -16
- package/src/typescript/names.ts +0 -2
- package/src/typescript/program.ts +0 -3
- package/src/typescript/properties.ts +6 -8
- package/src/typescript/scope.ts +0 -5
- package/src/typescript/steps.ts +20 -28
- package/src/typescript/types.ts +3 -10
- package/src/values.ts +917 -522
- 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
|
+
);
|
|
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));
|
|
230
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,93 +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
|
-
// A check that fails leaves no source, so the failure's trace reads the levels of the search.
|
|
272
|
-
const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
|
|
273
|
-
environment.runtime.setLivenessSource(source);
|
|
274
|
-
try {
|
|
275
|
-
return evaluate();
|
|
276
|
-
} finally {
|
|
277
|
-
environment.runtime.setLivenessSource(undefined);
|
|
278
|
-
}
|
|
279
|
-
};
|
|
280
|
-
const evaluateState = (predicate: LiveExpression, state: Value[]) =>
|
|
281
|
-
evaluateLive(
|
|
282
|
-
predicate,
|
|
283
|
-
state,
|
|
284
|
-
undefined,
|
|
285
|
-
evaluation.environment,
|
|
286
|
-
isShared ? getStateCache(state) : new Map(),
|
|
287
|
-
);
|
|
288
|
-
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
289
|
-
evaluateFrom(source, () =>
|
|
290
|
-
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
291
|
-
evaluateState(predicate, state) ? 1 : 0,
|
|
292
|
-
),
|
|
293
|
-
);
|
|
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.
|
|
294
610
|
const checkAction = (
|
|
295
|
-
behavior: BehaviorGraph
|
|
611
|
+
behavior: BehaviorGraph<State>,
|
|
296
612
|
source: number,
|
|
297
|
-
state:
|
|
298
|
-
|
|
613
|
+
state: State,
|
|
614
|
+
row: Int8Array,
|
|
615
|
+
offset: number,
|
|
616
|
+
successor: State,
|
|
617
|
+
edges: Int8Array,
|
|
618
|
+
edgeOffset: number,
|
|
619
|
+
results: Uint8Array,
|
|
620
|
+
resultOffset: number,
|
|
299
621
|
) =>
|
|
300
622
|
evaluateFrom(source, () => {
|
|
301
|
-
const
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
}
|
|
307
|
-
const stateCache = getStateCache(state);
|
|
308
|
-
const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
|
|
309
|
-
shared.actions.set(state, results);
|
|
310
|
-
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
311
|
-
results.set(successor, known);
|
|
312
|
-
return Uint8Array.from(behavior.actionIds, (id, position) => {
|
|
313
|
-
if (known[id] === -1) {
|
|
314
|
-
known[id] = evaluateLive(
|
|
315
|
-
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],
|
|
316
628
|
state,
|
|
629
|
+
row,
|
|
630
|
+
offset,
|
|
317
631
|
successor,
|
|
318
|
-
evaluation.environment,
|
|
319
|
-
stateCache,
|
|
320
632
|
)
|
|
321
633
|
? 1
|
|
322
634
|
: 0;
|
|
635
|
+
continue;
|
|
323
636
|
}
|
|
324
|
-
|
|
325
|
-
|
|
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
|
+
}
|
|
326
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
|
+
};
|
|
327
662
|
const isConsistent = (
|
|
328
|
-
|
|
663
|
+
behavior: BehaviorGraph<State>,
|
|
329
664
|
node: number,
|
|
330
665
|
source: number | undefined,
|
|
331
|
-
state:
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
// TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
|
|
337
|
-
// 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
|
+
|
|
338
671
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
339
|
-
if (
|
|
672
|
+
if (!isAcceptingFound) return false;
|
|
340
673
|
const tableauNode = tableau.nodes[node];
|
|
341
674
|
return (
|
|
342
675
|
tableauNode.particle.length === 0 &&
|
|
@@ -344,22 +677,19 @@ export const createLivenessChecker = (
|
|
|
344
677
|
tableauNode.successors[0] === node
|
|
345
678
|
);
|
|
346
679
|
};
|
|
347
|
-
const hasEmptyModel = (behavior: BehaviorGraph) =>
|
|
348
|
-
behavior.solution.models.some(
|
|
349
|
-
(model) =>
|
|
350
|
-
model.eventuallyAlways.length === 0 &&
|
|
351
|
-
model.infinitelyOftenStates.length === 0 &&
|
|
352
|
-
model.infinitelyOftenActions.length === 0,
|
|
353
|
-
);
|
|
354
680
|
|
|
355
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
681
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
356
682
|
if (!behavior.solution.tableau) return state;
|
|
357
683
|
const slots = behavior.nodeIds.slots;
|
|
358
684
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
359
685
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
360
686
|
};
|
|
361
|
-
const
|
|
362
|
-
|
|
687
|
+
const linkNode = (
|
|
688
|
+
behavior: BehaviorGraph<State>,
|
|
689
|
+
state: number,
|
|
690
|
+
tableauNode: number,
|
|
691
|
+
node: number,
|
|
692
|
+
) => {
|
|
363
693
|
const table = behavior.nodeIds;
|
|
364
694
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
365
695
|
const old = table.slots;
|
|
@@ -375,24 +705,43 @@ export const createLivenessChecker = (
|
|
|
375
705
|
}
|
|
376
706
|
}
|
|
377
707
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
708
|
+
if (state < 0) return node;
|
|
378
709
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
379
710
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
380
711
|
else behavior.nextSiblings[last] = node;
|
|
381
712
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
382
713
|
return node;
|
|
383
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.
|
|
384
726
|
const writeNode = (
|
|
385
|
-
behavior: BehaviorGraph
|
|
727
|
+
behavior: BehaviorGraph<State>,
|
|
386
728
|
node: number,
|
|
387
729
|
targets: number[],
|
|
388
|
-
|
|
730
|
+
actionResults: Uint8Array,
|
|
731
|
+
actions: number[],
|
|
389
732
|
stateResults: Uint8Array,
|
|
390
733
|
) => {
|
|
391
734
|
const start = behavior.edgeTargets.length;
|
|
392
735
|
const actionCount = behavior.solution.actionChecks.length;
|
|
393
736
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
394
|
-
actions.forEach((
|
|
395
|
-
writeToPool(
|
|
737
|
+
actions.forEach((position, edge) =>
|
|
738
|
+
writeToPool(
|
|
739
|
+
behavior.edgeActions,
|
|
740
|
+
(start + edge) * actionCount,
|
|
741
|
+
actionResults,
|
|
742
|
+
position * actionCount,
|
|
743
|
+
actionCount,
|
|
744
|
+
),
|
|
396
745
|
);
|
|
397
746
|
writeToPool(
|
|
398
747
|
behavior.stateResults,
|
|
@@ -403,67 +752,73 @@ export const createLivenessChecker = (
|
|
|
403
752
|
behavior.edgeCounts[node] = targets.length;
|
|
404
753
|
};
|
|
405
754
|
|
|
406
|
-
// TLC
|
|
407
|
-
//
|
|
408
|
-
|
|
409
|
-
const getSuccessorSet = (index: number, state:
|
|
410
|
-
const
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
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];
|
|
417
768
|
for (
|
|
418
|
-
let slot = (search.getFingerprint(
|
|
769
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
419
770
|
;
|
|
420
771
|
slot = (slot + 1) % slots.length
|
|
421
772
|
) {
|
|
422
773
|
const entry = slots[slot];
|
|
423
|
-
if (entry ===
|
|
424
|
-
slots[slot] =
|
|
774
|
+
if (entry === 0) {
|
|
775
|
+
slots[slot] = position + 1;
|
|
425
776
|
return true;
|
|
426
777
|
}
|
|
427
|
-
|
|
778
|
+
const stored = candidates[entry - 1];
|
|
779
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
428
780
|
return false;
|
|
429
781
|
}
|
|
430
782
|
};
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
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);
|
|
436
789
|
}
|
|
437
|
-
if (
|
|
438
|
-
}
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
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;
|
|
443
796
|
};
|
|
444
797
|
|
|
445
|
-
// TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
|
|
446
798
|
const expandLate = (
|
|
447
|
-
behavior: BehaviorGraph
|
|
799
|
+
behavior: BehaviorGraph<State>,
|
|
448
800
|
tableau: Tableau,
|
|
449
|
-
state:
|
|
801
|
+
state: State,
|
|
450
802
|
index: number,
|
|
451
803
|
node: number,
|
|
804
|
+
row: Int8Array,
|
|
805
|
+
offset: number,
|
|
452
806
|
) => {
|
|
453
|
-
const stateResults = checkState(behavior, index, state);
|
|
807
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
454
808
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
455
|
-
const
|
|
809
|
+
const actionCount = behavior.checks.actions.length;
|
|
810
|
+
const actions: number[] = [];
|
|
456
811
|
const successors: number[] = [];
|
|
457
|
-
const
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
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
|
+
}
|
|
461
816
|
for (const next of tableauNode.successors) {
|
|
462
|
-
if (!isConsistent(
|
|
817
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
463
818
|
if (
|
|
464
819
|
isAccepting(tableau, next) &&
|
|
465
820
|
behavior.errorNode === undefined &&
|
|
466
|
-
|
|
821
|
+
behavior.solution.models.some(isEmptyModel)
|
|
467
822
|
) {
|
|
468
823
|
behavior.errorNode = node;
|
|
469
824
|
return;
|
|
@@ -472,90 +827,140 @@ export const createLivenessChecker = (
|
|
|
472
827
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
473
828
|
const target = existing ?? recordNode(behavior, index, next);
|
|
474
829
|
successors.push(target);
|
|
475
|
-
actions.push(
|
|
476
|
-
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);
|
|
477
832
|
}
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
const
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
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
|
+
}
|
|
493
874
|
}
|
|
494
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);
|
|
495
885
|
}
|
|
496
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
497
886
|
};
|
|
498
887
|
|
|
499
888
|
const addTableauState = (
|
|
500
|
-
behavior: BehaviorGraph
|
|
889
|
+
behavior: BehaviorGraph<State>,
|
|
501
890
|
tableau: Tableau,
|
|
502
|
-
set: LiveSuccessor[],
|
|
503
|
-
|
|
891
|
+
set: LiveSuccessor<State>[],
|
|
892
|
+
rows: Int8Array,
|
|
893
|
+
actionResults: Uint8Array,
|
|
504
894
|
stateResults: Uint8Array,
|
|
505
895
|
index: number,
|
|
506
896
|
) => {
|
|
507
|
-
const
|
|
508
|
-
|
|
509
|
-
);
|
|
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++;
|
|
510
910
|
behavior.isDone[index] = true;
|
|
511
911
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
512
912
|
for (const node of getStateNodes(behavior, index)) {
|
|
513
913
|
const successors: number[] = [];
|
|
514
|
-
const actions:
|
|
914
|
+
const actions: number[] = [];
|
|
515
915
|
set.forEach((successor, position) => {
|
|
516
916
|
const isDone = behavior.isDone[successor.index] === true;
|
|
517
917
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
518
|
-
if (
|
|
918
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
519
919
|
const existing = getNodeId(behavior, successor.index, next);
|
|
520
920
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
521
921
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
522
922
|
successors.push(target);
|
|
523
|
-
actions.push(
|
|
923
|
+
actions.push(position);
|
|
524
924
|
if (existing === undefined && isDone) {
|
|
525
|
-
expandLate(
|
|
925
|
+
expandLate(
|
|
926
|
+
behavior,
|
|
927
|
+
tableau,
|
|
928
|
+
successor.state,
|
|
929
|
+
successor.index,
|
|
930
|
+
target,
|
|
931
|
+
rows,
|
|
932
|
+
position * atomCount,
|
|
933
|
+
);
|
|
526
934
|
}
|
|
527
935
|
}
|
|
528
936
|
});
|
|
529
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
937
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
530
938
|
}
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
.reverse()
|
|
535
|
-
.map((node) => behavior.nodeStates[node]),
|
|
536
|
-
);
|
|
939
|
+
return behavior.errorNode === undefined
|
|
940
|
+
? undefined
|
|
941
|
+
: getStatePath(behavior, behavior.errorNode);
|
|
537
942
|
};
|
|
538
943
|
|
|
539
944
|
const addPlainState = (
|
|
540
|
-
behavior: BehaviorGraph
|
|
541
|
-
set: LiveSuccessor[],
|
|
542
|
-
actionResults: Uint8Array
|
|
945
|
+
behavior: BehaviorGraph<State>,
|
|
946
|
+
set: LiveSuccessor<State>[],
|
|
947
|
+
actionResults: Uint8Array,
|
|
543
948
|
stateResults: Uint8Array,
|
|
544
949
|
index: number,
|
|
545
950
|
) => {
|
|
546
951
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
547
952
|
const successors: number[] = [];
|
|
548
|
-
const actions:
|
|
953
|
+
const actions: number[] = [];
|
|
549
954
|
set.forEach((successor, position) => {
|
|
550
955
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
551
956
|
successors.push(successor.index);
|
|
552
|
-
actions.push(
|
|
957
|
+
actions.push(position);
|
|
553
958
|
});
|
|
554
|
-
|
|
959
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
960
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
555
961
|
};
|
|
556
962
|
|
|
557
|
-
|
|
558
|
-
const getPath = (behavior: BehaviorGraph, target: number) => {
|
|
963
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
559
964
|
if (behavior.initial.includes(target)) return [target];
|
|
560
965
|
const parents = new Map<number, number>();
|
|
561
966
|
const queue: number[] = [];
|
|
@@ -581,9 +986,15 @@ export const createLivenessChecker = (
|
|
|
581
986
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
582
987
|
};
|
|
583
988
|
|
|
584
|
-
|
|
989
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
990
|
+
removeRepeats(
|
|
991
|
+
getPath(behavior, target)
|
|
992
|
+
.reverse()
|
|
993
|
+
.map((node) => behavior.nodeStates[node]),
|
|
994
|
+
);
|
|
995
|
+
|
|
585
996
|
const findLassoInModel = (
|
|
586
|
-
behavior: BehaviorGraph
|
|
997
|
+
behavior: BehaviorGraph<State>,
|
|
587
998
|
model: Solution["models"][number],
|
|
588
999
|
): Lasso | undefined => {
|
|
589
1000
|
const solution = behavior.solution;
|
|
@@ -638,91 +1049,85 @@ export const createLivenessChecker = (
|
|
|
638
1049
|
return getLasso(root, members, membersByState);
|
|
639
1050
|
};
|
|
640
1051
|
|
|
641
|
-
// TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component
|
|
642
|
-
// until it satisfies every check, and a breadth-first path back to the root.
|
|
643
1052
|
const getLasso = (
|
|
644
1053
|
root: number,
|
|
645
1054
|
members: Set<number>,
|
|
646
1055
|
membersByState: Map<number, number[]>,
|
|
647
1056
|
) => {
|
|
648
|
-
const prefix =
|
|
649
|
-
getPath(behavior, root)
|
|
650
|
-
.reverse()
|
|
651
|
-
.map((node) => behavior.nodeStates[node]),
|
|
652
|
-
);
|
|
1057
|
+
const prefix = getStatePath(behavior, root);
|
|
653
1058
|
const cycleStack: number[] = [];
|
|
654
1059
|
const seen = new Set<number>([root]);
|
|
655
1060
|
const stateDone = model.infinitelyOftenStates.map(() => false);
|
|
656
1061
|
const actionDone = model.infinitelyOftenActions.map(() => false);
|
|
657
1062
|
const promiseDone = solution.promises.map(() => false);
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
const isMember = (node: number) => members.has(node);
|
|
1063
|
+
let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
|
|
1064
|
+
let currentNode = root;
|
|
661
1065
|
const moveTo = (next: number) => {
|
|
662
|
-
cycleStack.push(
|
|
663
|
-
|
|
1066
|
+
cycleStack.push(currentNode);
|
|
1067
|
+
currentNode = next;
|
|
664
1068
|
};
|
|
665
|
-
while (
|
|
666
|
-
const countAtStart =
|
|
1069
|
+
while (remainingCount > 0) {
|
|
1070
|
+
const countAtStart = remainingCount;
|
|
667
1071
|
while (true) {
|
|
668
1072
|
model.infinitelyOftenStates.forEach((position, slot) => {
|
|
669
|
-
if (!stateDone[slot] && getStateResult(behavior,
|
|
1073
|
+
if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
|
|
670
1074
|
stateDone[slot] = true;
|
|
671
|
-
|
|
1075
|
+
remainingCount--;
|
|
672
1076
|
}
|
|
673
1077
|
});
|
|
674
1078
|
solution.promises.forEach((promise, position) => {
|
|
675
|
-
if (!promiseDone[position] && isFulfilled(
|
|
1079
|
+
if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
|
|
676
1080
|
promiseDone[position] = true;
|
|
677
|
-
|
|
1081
|
+
remainingCount--;
|
|
678
1082
|
}
|
|
679
1083
|
});
|
|
680
|
-
if (
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
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) => {
|
|
684
1089
|
if (membersByState.has(behavior.nodeStates[next])) {
|
|
685
|
-
if (!
|
|
686
|
-
|
|
1090
|
+
if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
|
|
1091
|
+
lastNext = next;
|
|
687
1092
|
model.infinitelyOftenActions.forEach((position, slot) => {
|
|
688
|
-
if (!actionDone[slot] && getAction(
|
|
1093
|
+
if (!actionDone[slot] && getAction(currentNode, edge, position)) {
|
|
689
1094
|
actionDone[slot] = true;
|
|
690
|
-
|
|
1095
|
+
remainingCount--;
|
|
691
1096
|
}
|
|
692
1097
|
});
|
|
693
1098
|
}
|
|
694
|
-
if (
|
|
1099
|
+
if (remainingCount < countBeforeActions) {
|
|
695
1100
|
moveTo(next);
|
|
696
1101
|
seen.clear();
|
|
697
1102
|
return true;
|
|
698
1103
|
}
|
|
699
|
-
if (
|
|
1104
|
+
if (members.has(next) && !seen.has(next)) unvisitedNext = next;
|
|
700
1105
|
return false;
|
|
701
1106
|
});
|
|
702
|
-
if (
|
|
703
|
-
if (
|
|
704
|
-
moveTo(
|
|
1107
|
+
if (isTaken) break;
|
|
1108
|
+
if (remainingCount < countAtStart) {
|
|
1109
|
+
moveTo(lastNext);
|
|
705
1110
|
seen.clear();
|
|
706
1111
|
break;
|
|
707
1112
|
}
|
|
708
|
-
while (
|
|
1113
|
+
while (unvisitedNext === -1) {
|
|
709
1114
|
const previous = cycleStack.pop();
|
|
710
1115
|
if (previous === undefined) {
|
|
711
1116
|
throw new TlaEvaluationError(
|
|
712
1117
|
"TLC failed to build the counterexample of a liveness property",
|
|
713
1118
|
);
|
|
714
1119
|
}
|
|
715
|
-
|
|
716
|
-
|
|
1120
|
+
currentNode = previous;
|
|
1121
|
+
unvisitedNext =
|
|
717
1122
|
getNodeSuccessors(behavior, previous).find(
|
|
718
|
-
(next) =>
|
|
1123
|
+
(next) => members.has(next) && !seen.has(next),
|
|
719
1124
|
) ?? -1;
|
|
720
1125
|
}
|
|
721
|
-
moveTo(
|
|
722
|
-
seen.add(
|
|
1126
|
+
moveTo(unvisitedNext);
|
|
1127
|
+
seen.add(unvisitedNext);
|
|
723
1128
|
}
|
|
724
1129
|
}
|
|
725
|
-
const postfix = getClosingPath(root,
|
|
1130
|
+
const postfix = getClosingPath(root, currentNode, membersByState);
|
|
726
1131
|
for (let position = cycleStack.length - 1; position >= 0; position--) {
|
|
727
1132
|
const state = behavior.nodeStates[cycleStack[position]];
|
|
728
1133
|
if (postfix[postfix.length - 1] !== state) postfix.push(state);
|
|
@@ -736,13 +1141,7 @@ export const createLivenessChecker = (
|
|
|
736
1141
|
};
|
|
737
1142
|
};
|
|
738
1143
|
|
|
739
|
-
|
|
740
|
-
const getClosingPath = (
|
|
741
|
-
root: number,
|
|
742
|
-
end: number,
|
|
743
|
-
membersByState: Map<number, number[]>,
|
|
744
|
-
isAllowedEdge: (node: number, edge: number) => boolean,
|
|
745
|
-
) => {
|
|
1144
|
+
const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
|
|
746
1145
|
if (end === root) return [];
|
|
747
1146
|
const start = behavior.nodeStates[end];
|
|
748
1147
|
const parents = new Map<number, number>();
|
|
@@ -751,7 +1150,7 @@ export const createLivenessChecker = (
|
|
|
751
1150
|
for (let state = start, parent = -1, position = 0; ; position++) {
|
|
752
1151
|
for (const node of membersByState.get(state) ?? []) {
|
|
753
1152
|
for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
|
|
754
|
-
if (next === node || !
|
|
1153
|
+
if (next === node || !isAllowed(node, edge)) continue;
|
|
755
1154
|
if (next === root) {
|
|
756
1155
|
const path: number[] = [];
|
|
757
1156
|
for (let item = state, itemParent = parent; item !== start;) {
|
|
@@ -782,7 +1181,7 @@ export const createLivenessChecker = (
|
|
|
782
1181
|
|
|
783
1182
|
for (let position = 0; position < queue.length; position++) {
|
|
784
1183
|
const stack = [queue[position], UNVISITED, 0];
|
|
785
|
-
|
|
1184
|
+
let nextLink = 0;
|
|
786
1185
|
while (stack.length >= 3) {
|
|
787
1186
|
const lowLink = stack.pop() ?? 0;
|
|
788
1187
|
const location = stack.pop();
|
|
@@ -799,10 +1198,10 @@ export const createLivenessChecker = (
|
|
|
799
1198
|
stack.push(Math.min(lowLink, links[node]));
|
|
800
1199
|
continue;
|
|
801
1200
|
}
|
|
802
|
-
links[node] =
|
|
1201
|
+
links[node] = nextLink;
|
|
803
1202
|
stack.push(lowLink, node, SCC_MARKER);
|
|
804
1203
|
components.push(node);
|
|
805
|
-
|
|
1204
|
+
let nextLowLink = nextLink++;
|
|
806
1205
|
getNodeSuccessors(behavior, node).forEach((next, edge) => {
|
|
807
1206
|
if (!isWritten(behavior, next)) return;
|
|
808
1207
|
if (!isAllowed(node, edge)) {
|
|
@@ -810,9 +1209,9 @@ export const createLivenessChecker = (
|
|
|
810
1209
|
return;
|
|
811
1210
|
}
|
|
812
1211
|
if (links[next] === UNVISITED) stack.push(next, UNVISITED);
|
|
813
|
-
else nextLowLink
|
|
1212
|
+
else nextLowLink = Math.min(nextLowLink, links[next]);
|
|
814
1213
|
});
|
|
815
|
-
stack.push(nextLowLink
|
|
1214
|
+
stack.push(nextLowLink);
|
|
816
1215
|
}
|
|
817
1216
|
}
|
|
818
1217
|
return undefined;
|
|
@@ -820,59 +1219,89 @@ export const createLivenessChecker = (
|
|
|
820
1219
|
|
|
821
1220
|
return {
|
|
822
1221
|
branches: behaviors.length,
|
|
823
|
-
addInitialState: (index, state
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
behavior.initial.push(
|
|
837
|
-
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
838
|
-
);
|
|
839
|
-
}
|
|
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
|
+
);
|
|
840
1235
|
}
|
|
841
|
-
} finally {
|
|
842
|
-
evaluation.environment = environment;
|
|
843
1236
|
}
|
|
844
1237
|
},
|
|
845
|
-
addState: (index, state, successors,
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
const tableau = behavior.solution.tableau;
|
|
857
|
-
if (!tableau) {
|
|
858
|
-
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
859
|
-
continue;
|
|
860
|
-
}
|
|
861
|
-
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(
|
|
862
1249
|
behavior,
|
|
863
|
-
tableau,
|
|
864
|
-
set,
|
|
865
|
-
actionResults,
|
|
866
|
-
stateResults,
|
|
867
1250
|
index,
|
|
868
|
-
|
|
869
|
-
|
|
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.");
|
|
870
1271
|
}
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
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;
|
|
874
1286
|
}
|
|
1287
|
+
return undefined;
|
|
875
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),
|
|
876
1305
|
findViolation: () => {
|
|
877
1306
|
for (const behavior of behaviors) {
|
|
878
1307
|
for (const model of behavior.solution.models) {
|
|
@@ -882,16 +1311,5 @@ export const createLivenessChecker = (
|
|
|
882
1311
|
}
|
|
883
1312
|
return undefined;
|
|
884
1313
|
},
|
|
885
|
-
// TLC names every property that the counterexample violates, once each.
|
|
886
|
-
getViolatedProperties: (path, cycleStart) => [
|
|
887
|
-
...new Set(
|
|
888
|
-
properties
|
|
889
|
-
.filter(
|
|
890
|
-
(_, position) =>
|
|
891
|
-
!evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
|
|
892
|
-
)
|
|
893
|
-
.map((property) => property.name),
|
|
894
|
-
),
|
|
895
|
-
],
|
|
896
1314
|
};
|
|
897
1315
|
};
|