tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.7a3bb1545
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -1
- package/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +58 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +4 -1
- package/dist/index.d.ts +4 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2682 -426
- package/dist/prove.js +2679 -423
- package/dist/run.cjs +43 -42
- package/dist/run.js +45 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -40
- package/dist/transfer.js +43 -40
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +336 -88
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlapm.ts +424 -62
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +4 -5
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +26 -7
- package/src/dependencies.ts +23 -2
- package/src/dfid.ts +9 -2
- package/src/environment.ts +27 -5
- package/src/errors.ts +30 -3
- package/src/evaluate.ts +9 -3
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +1 -1
- package/src/levels.ts +3 -2
- package/src/lexer.ts +5 -3
- package/src/liveness-checker.ts +572 -204
- package/src/liveness.ts +47 -32
- package/src/obligations/action.ts +10 -6
- package/src/obligations/anonymize.ts +33 -14
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +18 -6
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +22 -17
- package/src/obligations/index.ts +36 -6
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +1 -3
- package/src/obligations/normalize.ts +24 -13
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +43 -13
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +17 -7
- package/src/obligations/source.ts +71 -17
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +7 -2
- package/src/parser.ts +633 -186
- package/src/pretty-print.ts +1 -1
- package/src/prover/deciders.ts +11 -8
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +71 -41
- 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 +149 -3
- package/src/prover/isabelle/isar/method.ts +506 -198
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +479 -69
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +83 -8
- package/src/prover/isabelle/provers/blast/blast.ts +0 -2
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +2 -4
- package/src/prover/isabelle/pure/bicompose.ts +0 -2
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +0 -2
- package/src/prover/isabelle/pure/drule.ts +63 -4
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +0 -2
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
- package/src/prover/isabelle/pure/rewriter.ts +1 -8
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +0 -2
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +0 -2
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +0 -2
- package/src/prover/isabelle/pure/thm.ts +0 -2
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +1 -2
- package/src/prover/isabelle/tla/context.ts +51 -9
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +40 -1
- package/src/prover/isabelle/tla/simpdata.ts +0 -2
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +19 -12
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/methods.ts +159 -50
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +343 -65
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +42 -6
- package/src/prover/smt/data.ts +191 -84
- package/src/prover/smt/encode.ts +122 -43
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +483 -116
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +613 -6
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +309 -0
- package/src/prover/smt/solver/asserted-formulas.ts +93 -15
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1448 -41
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +600 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +338 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +109 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +533 -114
- package/src/prover/smt/solver/ctx-simplify.ts +21 -12
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +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 +260 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +6 -7
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +267 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +884 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +348 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +177 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +30 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +109 -36
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +345 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +18 -3
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +66 -11
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +118 -88
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +309 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +105 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +17 -26
- package/src/prover/smt/solver/model-evaluator.ts +188 -12
- package/src/prover/smt/solver/model-finder.ts +0 -1
- package/src/prover/smt/solver/model-generator.ts +59 -30
- package/src/prover/smt/solver/model-macro-solver.ts +38 -27
- 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 +410 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +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 +305 -88
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +424 -211
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
- package/src/prover/smt/solver/nlsat/solver.ts +282 -69
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +105 -23
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +792 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +282 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +311 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
- package/src/prover/smt/solver/poly-rewriter.ts +202 -57
- package/src/prover/smt/solver/probes.ts +511 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +650 -17
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +632 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +37 -17
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +814 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
- package/src/prover/smt/solver/quantifier-manager.ts +25 -24
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
- package/src/prover/smt/solver/rewriter.ts +475 -36
- package/src/prover/smt/solver/rlimit.ts +38 -2
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2105 -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 +90 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +496 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3154 -326
- package/src/prover/smt/solver/smtlib-script.ts +1702 -0
- package/src/prover/smt/solver/solve-eqs.ts +923 -0
- package/src/prover/smt/solver/solver.ts +113 -22
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +1995 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1200 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
- package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
- package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
- package/src/prover/smt/solver/theory-lra-state.ts +6 -22
- package/src/prover/smt/solver/theory-lra.ts +188 -2
- package/src/prover/smt/solver/theory-pb.ts +933 -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.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +29 -8
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +2 -0
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +0 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +21 -2
- package/src/prover/zenon/index-table.ts +7 -4
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +2 -4
- package/src/prover/zenon/llproof.ts +0 -2
- package/src/prover/zenon/mltoll.ts +0 -2
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +6 -2
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +7 -5
- package/src/prover/zenon/tla/functions.ts +0 -2
- package/src/prover/zenon/tla/llproof.ts +0 -2
- package/src/prover/zenon/tla/records.ts +0 -2
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +7 -8
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +0 -2
- package/src/resolve.ts +72 -36
- package/src/runtime.ts +6 -0
- package/src/sany/generation.ts +1 -13
- package/src/sany/generator-definitions.ts +1 -1
- package/src/sany/generator-expressions.ts +9 -17
- package/src/sany/generator-proofs.ts +1 -1
- package/src/sany/generator.ts +1 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/linter.ts +0 -2
- package/src/search.ts +198 -45
- package/src/simulate.ts +3 -0
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +4 -2
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +12 -0
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +2 -3
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +1 -1
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/liveness-checker.ts
CHANGED
|
@@ -1,9 +1,11 @@
|
|
|
1
1
|
import { TlaEvaluationError } from "./errors";
|
|
2
|
+
import { isExpressionImpure } from "./dependencies";
|
|
2
3
|
import { hasRepeatedEffects, type Environment } from "./evaluate";
|
|
3
4
|
import {
|
|
4
|
-
evaluateLive,
|
|
5
5
|
evaluateOnLasso,
|
|
6
|
+
getInterpretedAtoms,
|
|
6
7
|
toLiveExpression,
|
|
8
|
+
type LiveAtoms,
|
|
7
9
|
type ScopedExpression,
|
|
8
10
|
type TemporalProperty,
|
|
9
11
|
} from "./liveness";
|
|
@@ -13,15 +15,18 @@ import {
|
|
|
13
15
|
getSolutions,
|
|
14
16
|
getTermKey,
|
|
15
17
|
isFulfilling,
|
|
18
|
+
type LiveAction,
|
|
19
|
+
type LiveEnabled,
|
|
16
20
|
type LiveExpression,
|
|
21
|
+
type LiveState,
|
|
17
22
|
type Solution,
|
|
18
23
|
type Tableau,
|
|
19
24
|
} from "./tableau";
|
|
20
25
|
import { isSameValue, type Value } from "./values";
|
|
21
26
|
|
|
22
|
-
export interface LiveSuccessor {
|
|
27
|
+
export interface LiveSuccessor<State = Value[]> {
|
|
23
28
|
index: number;
|
|
24
|
-
state:
|
|
29
|
+
state: State;
|
|
25
30
|
}
|
|
26
31
|
|
|
27
32
|
export interface Lasso {
|
|
@@ -32,6 +37,7 @@ export interface Lasso {
|
|
|
32
37
|
|
|
33
38
|
export interface LivenessChecker {
|
|
34
39
|
branches: number;
|
|
40
|
+
solutions: Solution[];
|
|
35
41
|
addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
|
|
36
42
|
addState: (
|
|
37
43
|
index: number,
|
|
@@ -39,13 +45,38 @@ export interface LivenessChecker {
|
|
|
39
45
|
successors: LiveSuccessor[],
|
|
40
46
|
tracing?: Environment,
|
|
41
47
|
) => number[] | undefined;
|
|
48
|
+
storeState: (pending: number, index: number) => void;
|
|
49
|
+
getStateCounts: () => number[];
|
|
42
50
|
findViolation: () => Lasso | undefined;
|
|
43
51
|
getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
|
|
44
52
|
}
|
|
45
53
|
|
|
46
|
-
interface
|
|
47
|
-
|
|
48
|
-
|
|
54
|
+
export interface LiveGraph<State> {
|
|
55
|
+
branches: number;
|
|
56
|
+
addInitialState: (index: number, state: State) => void;
|
|
57
|
+
// The path to an accepting node the state reaches, if any.
|
|
58
|
+
addState: (
|
|
59
|
+
index: number,
|
|
60
|
+
state: State,
|
|
61
|
+
successors: LiveSuccessor<State>[],
|
|
62
|
+
) => number[] | undefined;
|
|
63
|
+
storeState: (pending: number, index: number) => void;
|
|
64
|
+
getStateCounts: () => number[];
|
|
65
|
+
findViolation: () => Lasso | undefined;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
export interface SearchGraph<State> {
|
|
69
|
+
getFingerprint: (successor: LiveSuccessor<State>) => number;
|
|
70
|
+
getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
export interface LiveEvaluation<State> {
|
|
74
|
+
atoms: LiveAtoms<State>;
|
|
75
|
+
// Whether a check's result for a state holds for every step from it.
|
|
76
|
+
isShared: boolean;
|
|
77
|
+
isSame: (left: State, right: State) => boolean;
|
|
78
|
+
// Evaluates the checks of a state the search found from the state at source.
|
|
79
|
+
evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
|
|
49
80
|
}
|
|
50
81
|
|
|
51
82
|
interface Pool<Data extends Int32Array | Uint8Array> {
|
|
@@ -54,8 +85,25 @@ interface Pool<Data extends Int32Array | Uint8Array> {
|
|
|
54
85
|
create: (length: number) => Data;
|
|
55
86
|
}
|
|
56
87
|
|
|
57
|
-
|
|
88
|
+
// A check reads and fills the state atoms of a state in its row, which starts at offset.
|
|
89
|
+
type Check<State> = (
|
|
90
|
+
state: State,
|
|
91
|
+
row: Int8Array,
|
|
92
|
+
offset: number,
|
|
93
|
+
next: State | undefined,
|
|
94
|
+
) => boolean;
|
|
95
|
+
|
|
96
|
+
interface BehaviorChecks<State> {
|
|
97
|
+
states: Check<State>[];
|
|
98
|
+
actions: Check<State>[];
|
|
99
|
+
// The state predicates of each tableau node, or, where its checks share results and it has only
|
|
100
|
+
// state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
|
|
101
|
+
nodes: (Check<State>[] | Int32Array)[];
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
interface BehaviorGraph<State> {
|
|
58
105
|
solution: Solution;
|
|
106
|
+
checks: BehaviorChecks<State>;
|
|
59
107
|
actionIds: Int32Array;
|
|
60
108
|
nodeStates: number[];
|
|
61
109
|
nodeTableaux: number[];
|
|
@@ -70,6 +118,7 @@ interface BehaviorGraph {
|
|
|
70
118
|
nextSiblings: number[];
|
|
71
119
|
nodeIds: NodeTable;
|
|
72
120
|
isDone: boolean[];
|
|
121
|
+
stateCount: number;
|
|
73
122
|
errorNode: number | undefined;
|
|
74
123
|
}
|
|
75
124
|
|
|
@@ -112,14 +161,18 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
|
|
|
112
161
|
pool: Pool<Data>,
|
|
113
162
|
offset: number,
|
|
114
163
|
values: ArrayLike<number>,
|
|
164
|
+
start = 0,
|
|
165
|
+
length = values.length - start,
|
|
115
166
|
) => {
|
|
116
|
-
const end = offset +
|
|
167
|
+
const end = offset + length;
|
|
117
168
|
if (end > pool.data.length) {
|
|
118
169
|
const data = pool.create(Math.max(2 * pool.data.length, end));
|
|
119
170
|
data.set(pool.data);
|
|
120
171
|
pool.data = data;
|
|
121
172
|
}
|
|
122
|
-
|
|
173
|
+
for (let position = 0; position < length; position++) {
|
|
174
|
+
pool.data[offset + position] = values[start + position];
|
|
175
|
+
}
|
|
123
176
|
pool.length = Math.max(pool.length, end);
|
|
124
177
|
};
|
|
125
178
|
|
|
@@ -148,20 +201,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
|
|
|
148
201
|
|
|
149
202
|
const UNWRITTEN = -1;
|
|
150
203
|
|
|
151
|
-
const isWritten = (behavior: BehaviorGraph
|
|
204
|
+
const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
|
|
152
205
|
(behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
|
|
153
206
|
|
|
154
|
-
const getNodeSuccessors = (behavior: BehaviorGraph
|
|
207
|
+
const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
|
|
155
208
|
const start = behavior.edgeStarts[node];
|
|
156
209
|
return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
|
|
157
210
|
};
|
|
158
211
|
|
|
159
|
-
const getStateResult = (behavior: BehaviorGraph
|
|
212
|
+
const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
|
|
160
213
|
behavior.stateResults.data[
|
|
161
214
|
behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
|
|
162
215
|
] === 1;
|
|
163
216
|
|
|
164
|
-
const pushNode = (behavior: BehaviorGraph
|
|
217
|
+
const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
165
218
|
behavior.nodeStates.push(state);
|
|
166
219
|
behavior.nodeTableaux.push(tableauNode);
|
|
167
220
|
behavior.edgeStarts.push(UNWRITTEN);
|
|
@@ -170,7 +223,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
|
|
|
170
223
|
return behavior.nodeStates.length - 1;
|
|
171
224
|
};
|
|
172
225
|
|
|
173
|
-
const getStateNodes = (behavior: BehaviorGraph
|
|
226
|
+
const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
|
|
174
227
|
const nodes: number[] = [];
|
|
175
228
|
for (
|
|
176
229
|
let node = behavior.firstNodes.data[state] ?? NO_NODE;
|
|
@@ -190,13 +243,11 @@ const UNVISITED = -1;
|
|
|
190
243
|
|
|
191
244
|
const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
|
|
192
245
|
|
|
193
|
-
|
|
246
|
+
const getLiveFormula = (
|
|
194
247
|
properties: TemporalProperty[],
|
|
195
248
|
temporals: ScopedExpression[],
|
|
196
249
|
environment: Environment,
|
|
197
|
-
|
|
198
|
-
): LivenessChecker | undefined => {
|
|
199
|
-
if (properties.length === 0) return undefined;
|
|
250
|
+
) => {
|
|
200
251
|
const fairness = temporals.map((item) =>
|
|
201
252
|
toLiveExpression(item.expression, item.scope, environment),
|
|
202
253
|
);
|
|
@@ -206,10 +257,242 @@ export const createLivenessChecker = (
|
|
|
206
257
|
const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
|
|
207
258
|
const formula =
|
|
208
259
|
fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
|
|
209
|
-
|
|
260
|
+
return { formula, negations };
|
|
261
|
+
};
|
|
262
|
+
|
|
263
|
+
export type LiveAtom = LiveState | LiveEnabled | LiveAction;
|
|
264
|
+
|
|
265
|
+
const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
|
|
266
|
+
switch (atom.kind) {
|
|
267
|
+
case "State":
|
|
268
|
+
return [atom];
|
|
269
|
+
case "Enabled":
|
|
270
|
+
return [{ expression: atom.step, scope: atom.scope }];
|
|
271
|
+
case "Action":
|
|
272
|
+
return [atom.expression, atom.subscript].flatMap((inner) =>
|
|
273
|
+
inner ? [{ expression: inner, scope: atom.scope }] : [],
|
|
274
|
+
);
|
|
275
|
+
}
|
|
276
|
+
};
|
|
277
|
+
|
|
278
|
+
const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
|
|
279
|
+
switch (expression.kind) {
|
|
280
|
+
case "Boolean":
|
|
281
|
+
return;
|
|
282
|
+
case "State":
|
|
283
|
+
case "Enabled":
|
|
284
|
+
case "Action":
|
|
285
|
+
atoms.add(expression);
|
|
286
|
+
return;
|
|
287
|
+
case "And":
|
|
288
|
+
case "Or":
|
|
289
|
+
expression.operands.forEach((operand) => collectAtoms(operand, atoms));
|
|
290
|
+
return;
|
|
291
|
+
default:
|
|
292
|
+
collectAtoms(expression.body, atoms);
|
|
293
|
+
}
|
|
294
|
+
};
|
|
295
|
+
|
|
296
|
+
// The atoms the checks of the solutions evaluate.
|
|
297
|
+
export const getLiveAtoms = (solutions: Solution[]) => {
|
|
298
|
+
const atoms = new Set<LiveAtom>();
|
|
299
|
+
for (const solution of solutions) {
|
|
300
|
+
[
|
|
301
|
+
...solution.stateChecks,
|
|
302
|
+
...solution.actionChecks,
|
|
303
|
+
...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
|
|
304
|
+
].forEach((check) => collectAtoms(check, atoms));
|
|
305
|
+
}
|
|
306
|
+
return [...atoms];
|
|
307
|
+
};
|
|
308
|
+
|
|
309
|
+
// The expressions the checks of the solutions evaluate.
|
|
310
|
+
export const getLiveExpressions = (solutions: Solution[]) =>
|
|
311
|
+
getLiveAtoms(solutions).flatMap((atom) =>
|
|
312
|
+
getAtomExpressions(atom).map((item) => item.expression),
|
|
313
|
+
);
|
|
314
|
+
|
|
315
|
+
export const createLivenessChecker = (
|
|
316
|
+
properties: TemporalProperty[],
|
|
317
|
+
temporals: ScopedExpression[],
|
|
318
|
+
environment: Environment,
|
|
319
|
+
search: SearchGraph<Value[]>,
|
|
320
|
+
): LivenessChecker | undefined => {
|
|
321
|
+
if (properties.length === 0) return undefined;
|
|
322
|
+
const live = getLiveFormula(properties, temporals, environment);
|
|
323
|
+
// A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
|
|
324
|
+
// definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
|
|
325
|
+
const formulaAtoms = new Set<LiveAtom>();
|
|
326
|
+
collectAtoms(live.formula, formulaAtoms);
|
|
327
|
+
const checked = [...formulaAtoms].flatMap(getAtomExpressions);
|
|
328
|
+
const isShared = checked.every((item) => item.scope === undefined)
|
|
329
|
+
? !isExpressionImpure(
|
|
330
|
+
checked.map((item) => item.expression),
|
|
331
|
+
environment,
|
|
332
|
+
"repeated",
|
|
333
|
+
)
|
|
334
|
+
: !hasRepeatedEffects(environment);
|
|
335
|
+
const tracing = { environment, atoms: getInterpretedAtoms(environment) };
|
|
336
|
+
const solutions = getSolutions(live.formula);
|
|
337
|
+
const graph = createLiveGraph(
|
|
338
|
+
solutions,
|
|
339
|
+
{
|
|
340
|
+
atoms: {
|
|
341
|
+
holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
|
|
342
|
+
holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
|
|
343
|
+
},
|
|
344
|
+
isShared,
|
|
345
|
+
isSame: isSameState,
|
|
346
|
+
evaluateFrom: (source, evaluate) => {
|
|
347
|
+
environment.runtime.setLivenessSource(source);
|
|
348
|
+
try {
|
|
349
|
+
return evaluate();
|
|
350
|
+
} finally {
|
|
351
|
+
environment.runtime.setLivenessSource(undefined);
|
|
352
|
+
}
|
|
353
|
+
},
|
|
354
|
+
},
|
|
355
|
+
search,
|
|
356
|
+
environment.runtime.version !== "1.7.4",
|
|
357
|
+
);
|
|
358
|
+
const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
|
|
359
|
+
if (replay === undefined) return run();
|
|
360
|
+
tracing.atoms = getInterpretedAtoms(replay);
|
|
361
|
+
try {
|
|
362
|
+
return run();
|
|
363
|
+
} finally {
|
|
364
|
+
tracing.atoms = getInterpretedAtoms(environment);
|
|
365
|
+
}
|
|
366
|
+
};
|
|
367
|
+
return {
|
|
368
|
+
branches: graph.branches,
|
|
369
|
+
solutions,
|
|
370
|
+
addInitialState: (index, state, replay) =>
|
|
371
|
+
traceWith(replay, () => graph.addInitialState(index, state)),
|
|
372
|
+
addState: (index, state, successors, replay) =>
|
|
373
|
+
traceWith(replay, () => graph.addState(index, state, successors)),
|
|
374
|
+
storeState: graph.storeState,
|
|
375
|
+
getStateCounts: graph.getStateCounts,
|
|
376
|
+
findViolation: graph.findViolation,
|
|
377
|
+
getViolatedProperties: (path, cycleStart) => [
|
|
378
|
+
...new Set(
|
|
379
|
+
properties
|
|
380
|
+
.filter(
|
|
381
|
+
(_property, position) =>
|
|
382
|
+
!evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
|
|
383
|
+
)
|
|
384
|
+
.map((property) => property.name),
|
|
385
|
+
),
|
|
386
|
+
],
|
|
387
|
+
};
|
|
388
|
+
};
|
|
389
|
+
|
|
390
|
+
export const createLiveGraph = <State>(
|
|
391
|
+
solutions: Solution[],
|
|
392
|
+
evaluation: LiveEvaluation<State>,
|
|
393
|
+
search: SearchGraph<State>,
|
|
394
|
+
isAcceptingFound: boolean,
|
|
395
|
+
): LiveGraph<State> => {
|
|
210
396
|
const actionIds = new Map<string, number>();
|
|
211
|
-
|
|
397
|
+
let capacityMultiplier = 1;
|
|
398
|
+
const isShared = evaluation.isShared;
|
|
399
|
+
const atoms = evaluation.atoms;
|
|
400
|
+
const evaluateFrom = evaluation.evaluateFrom;
|
|
401
|
+
const stateAtoms = new Map<LiveState | LiveEnabled, number>();
|
|
402
|
+
const atomsById: (LiveState | LiveEnabled)[] = [];
|
|
403
|
+
const getAtomId = (atom: LiveState | LiveEnabled) => {
|
|
404
|
+
const id = stateAtoms.get(atom) ?? stateAtoms.size;
|
|
405
|
+
stateAtoms.set(atom, id);
|
|
406
|
+
atomsById[id] = atom;
|
|
407
|
+
return id;
|
|
408
|
+
};
|
|
409
|
+
const getLiterals = (expression: LiveExpression): number[] | undefined => {
|
|
410
|
+
if (expression.kind === "State" || expression.kind === "Enabled") {
|
|
411
|
+
return [getAtomId(expression) * 2 + 1];
|
|
412
|
+
}
|
|
413
|
+
if (expression.kind === "Not") {
|
|
414
|
+
const body = expression.body;
|
|
415
|
+
return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
|
|
416
|
+
}
|
|
417
|
+
if (expression.kind !== "And") return undefined;
|
|
418
|
+
const operands = expression.operands.map(getLiterals);
|
|
419
|
+
return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
|
|
420
|
+
};
|
|
421
|
+
// The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
|
|
422
|
+
// or -1 before it is evaluated.
|
|
423
|
+
const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
|
|
424
|
+
// The edge rows of steps hold the result of each action check, shared by the behaviors that
|
|
425
|
+
// check it.
|
|
426
|
+
const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
|
|
427
|
+
// Unless the checks share results, each check evaluates its atoms afresh.
|
|
428
|
+
const runCheck = (
|
|
429
|
+
check: Check<State>,
|
|
430
|
+
state: State,
|
|
431
|
+
row: Int8Array,
|
|
432
|
+
offset: number,
|
|
433
|
+
next?: State,
|
|
434
|
+
) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
|
|
435
|
+
const compileCheck = (expression: LiveExpression): Check<State> => {
|
|
436
|
+
switch (expression.kind) {
|
|
437
|
+
case "Boolean": {
|
|
438
|
+
const value = expression.value;
|
|
439
|
+
return () => value;
|
|
440
|
+
}
|
|
441
|
+
case "State":
|
|
442
|
+
case "Enabled": {
|
|
443
|
+
const id = getAtomId(expression);
|
|
444
|
+
return (state, row, offset) => {
|
|
445
|
+
if (row[offset + id] === -1) {
|
|
446
|
+
row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
|
|
447
|
+
}
|
|
448
|
+
return row[offset + id] === 1;
|
|
449
|
+
};
|
|
450
|
+
}
|
|
451
|
+
case "Action": {
|
|
452
|
+
const enabled = expression.enabled && getAtomId(expression.enabled);
|
|
453
|
+
return (state, row, offset, next) =>
|
|
454
|
+
!(enabled !== undefined && row[offset + enabled] === 0) &&
|
|
455
|
+
next !== undefined &&
|
|
456
|
+
atoms.holdsAction(expression, state, next);
|
|
457
|
+
}
|
|
458
|
+
case "Not": {
|
|
459
|
+
const body = compileCheck(expression.body);
|
|
460
|
+
return (state, row, offset, next) => !body(state, row, offset, next);
|
|
461
|
+
}
|
|
462
|
+
case "And": {
|
|
463
|
+
const operands = expression.operands.map(compileCheck);
|
|
464
|
+
return (state, row, offset, next) =>
|
|
465
|
+
operands.every((operand) => operand(state, row, offset, next));
|
|
466
|
+
}
|
|
467
|
+
case "Or": {
|
|
468
|
+
const operands = expression.operands.map(compileCheck);
|
|
469
|
+
return (state, row, offset, next) =>
|
|
470
|
+
operands.some((operand) => operand(state, row, offset, next));
|
|
471
|
+
}
|
|
472
|
+
case "Next": {
|
|
473
|
+
const body = compileCheck(expression.body);
|
|
474
|
+
return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
|
|
475
|
+
}
|
|
476
|
+
case "Always":
|
|
477
|
+
case "Eventually":
|
|
478
|
+
return () => {
|
|
479
|
+
throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
|
|
480
|
+
};
|
|
481
|
+
}
|
|
482
|
+
};
|
|
483
|
+
const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
|
|
212
484
|
solution,
|
|
485
|
+
checks: {
|
|
486
|
+
states: solution.stateChecks.map(compileCheck),
|
|
487
|
+
actions: solution.actionChecks.map(compileCheck),
|
|
488
|
+
nodes:
|
|
489
|
+
solution.tableau?.nodes.map((node) => {
|
|
490
|
+
const literals = isShared
|
|
491
|
+
? getLiterals({ kind: "And", operands: node.statePredicates })
|
|
492
|
+
: undefined;
|
|
493
|
+
return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
|
|
494
|
+
}) ?? [],
|
|
495
|
+
},
|
|
213
496
|
actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
|
|
214
497
|
const key = getTermKey(predicate);
|
|
215
498
|
const actionId = actionIds.get(key) ?? actionIds.size;
|
|
@@ -229,85 +512,88 @@ export const createLivenessChecker = (
|
|
|
229
512
|
nextSiblings: [],
|
|
230
513
|
nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
|
|
231
514
|
isDone: [],
|
|
515
|
+
stateCount: 0,
|
|
232
516
|
errorNode: undefined,
|
|
233
517
|
}));
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
environment.runtime.setLivenessSource(undefined);
|
|
251
|
-
}
|
|
252
|
-
};
|
|
253
|
-
const evaluateState = (predicate: LiveExpression, state: Value[]) =>
|
|
254
|
-
evaluateLive(
|
|
255
|
-
predicate,
|
|
256
|
-
state,
|
|
257
|
-
undefined,
|
|
258
|
-
evaluationEnvironment,
|
|
259
|
-
isShared ? getStateCache(state) : new Map(),
|
|
260
|
-
);
|
|
261
|
-
const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
|
|
262
|
-
evaluateFrom(source, () =>
|
|
263
|
-
Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
|
|
264
|
-
evaluateState(predicate, state) ? 1 : 0,
|
|
265
|
-
),
|
|
266
|
-
);
|
|
518
|
+
const checkState = (
|
|
519
|
+
behavior: BehaviorGraph<State>,
|
|
520
|
+
source: number,
|
|
521
|
+
state: State,
|
|
522
|
+
row: Int8Array,
|
|
523
|
+
offset: number,
|
|
524
|
+
) =>
|
|
525
|
+
evaluateFrom(source, () => {
|
|
526
|
+
const checks = behavior.checks.states;
|
|
527
|
+
const results = new Uint8Array(checks.length);
|
|
528
|
+
checks.forEach((check, position) => {
|
|
529
|
+
results[position] = runCheck(check, state, row, offset) ? 1 : 0;
|
|
530
|
+
});
|
|
531
|
+
return results;
|
|
532
|
+
});
|
|
533
|
+
// Writes the result of each action check of the step to successor at resultOffset in results.
|
|
267
534
|
const checkAction = (
|
|
268
|
-
behavior: BehaviorGraph
|
|
535
|
+
behavior: BehaviorGraph<State>,
|
|
269
536
|
source: number,
|
|
270
|
-
state:
|
|
271
|
-
|
|
537
|
+
state: State,
|
|
538
|
+
row: Int8Array,
|
|
539
|
+
offset: number,
|
|
540
|
+
successor: State,
|
|
541
|
+
edges: Int8Array,
|
|
542
|
+
edgeOffset: number,
|
|
543
|
+
results: Uint8Array,
|
|
544
|
+
resultOffset: number,
|
|
272
545
|
) =>
|
|
273
546
|
evaluateFrom(source, () => {
|
|
274
|
-
const
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
}
|
|
280
|
-
const stateCache = getStateCache(state);
|
|
281
|
-
const results = sharedActions.get(state) ?? new Map<Value[], Int8Array>();
|
|
282
|
-
sharedActions.set(state, results);
|
|
283
|
-
const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
|
|
284
|
-
results.set(successor, known);
|
|
285
|
-
return Uint8Array.from(behavior.actionIds, (actionId, position) => {
|
|
286
|
-
if (known[actionId] === -1) {
|
|
287
|
-
known[actionId] = evaluateLive(
|
|
288
|
-
predicates[position],
|
|
547
|
+
const actions = behavior.checks.actions;
|
|
548
|
+
for (let position = 0; position < actions.length; position++) {
|
|
549
|
+
if (!isShared) {
|
|
550
|
+
results[resultOffset + position] = runCheck(
|
|
551
|
+
actions[position],
|
|
289
552
|
state,
|
|
553
|
+
row,
|
|
554
|
+
offset,
|
|
290
555
|
successor,
|
|
291
|
-
evaluationEnvironment,
|
|
292
|
-
stateCache,
|
|
293
556
|
)
|
|
294
557
|
? 1
|
|
295
558
|
: 0;
|
|
559
|
+
continue;
|
|
296
560
|
}
|
|
297
|
-
|
|
298
|
-
|
|
561
|
+
const edge = edgeOffset + behavior.actionIds[position];
|
|
562
|
+
if (edges[edge] === -1)
|
|
563
|
+
edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
|
|
564
|
+
results[resultOffset + position] = edges[edge];
|
|
565
|
+
}
|
|
299
566
|
});
|
|
567
|
+
const holdsNode = (
|
|
568
|
+
behavior: BehaviorGraph<State>,
|
|
569
|
+
node: number,
|
|
570
|
+
state: State,
|
|
571
|
+
row: Int8Array,
|
|
572
|
+
offset: number,
|
|
573
|
+
) => {
|
|
574
|
+
const checks = behavior.checks.nodes[node];
|
|
575
|
+
if (!(checks instanceof Int32Array)) {
|
|
576
|
+
return checks.every((check) => runCheck(check, state, row, offset));
|
|
577
|
+
}
|
|
578
|
+
for (let position = 0; position < checks.length; position++) {
|
|
579
|
+
const literal: number = checks[position];
|
|
580
|
+
const cell = offset + (literal >> 1);
|
|
581
|
+
if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
|
|
582
|
+
if (row[cell] !== (literal & 1)) return false;
|
|
583
|
+
}
|
|
584
|
+
return true;
|
|
585
|
+
};
|
|
300
586
|
const isConsistent = (
|
|
301
|
-
|
|
587
|
+
behavior: BehaviorGraph<State>,
|
|
302
588
|
node: number,
|
|
303
589
|
source: number | undefined,
|
|
304
|
-
state:
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
590
|
+
state: State,
|
|
591
|
+
row: Int8Array,
|
|
592
|
+
offset: number,
|
|
593
|
+
) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
|
|
594
|
+
|
|
309
595
|
const isAccepting = (tableau: Tableau, node: number) => {
|
|
310
|
-
if (
|
|
596
|
+
if (!isAcceptingFound) return false;
|
|
311
597
|
const tableauNode = tableau.nodes[node];
|
|
312
598
|
return (
|
|
313
599
|
tableauNode.particle.length === 0 &&
|
|
@@ -316,14 +602,18 @@ export const createLivenessChecker = (
|
|
|
316
602
|
);
|
|
317
603
|
};
|
|
318
604
|
|
|
319
|
-
const getNodeId = (behavior: BehaviorGraph
|
|
605
|
+
const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
320
606
|
if (!behavior.solution.tableau) return state;
|
|
321
607
|
const slots = behavior.nodeIds.slots;
|
|
322
608
|
const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
|
|
323
609
|
return slots[slot] === 0 ? undefined : slots[slot + 2];
|
|
324
610
|
};
|
|
325
|
-
const
|
|
326
|
-
|
|
611
|
+
const linkNode = (
|
|
612
|
+
behavior: BehaviorGraph<State>,
|
|
613
|
+
state: number,
|
|
614
|
+
tableauNode: number,
|
|
615
|
+
node: number,
|
|
616
|
+
) => {
|
|
327
617
|
const table = behavior.nodeIds;
|
|
328
618
|
if (++table.size * 2 > table.slots.length / 3) {
|
|
329
619
|
const old = table.slots;
|
|
@@ -339,24 +629,43 @@ export const createLivenessChecker = (
|
|
|
339
629
|
}
|
|
340
630
|
}
|
|
341
631
|
table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
|
|
632
|
+
if (state < 0) return node;
|
|
342
633
|
const last = behavior.lastNodes.data[state] ?? NO_NODE;
|
|
343
634
|
if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
|
|
344
635
|
else behavior.nextSiblings[last] = node;
|
|
345
636
|
writeToPool(behavior.lastNodes, state, [node]);
|
|
346
637
|
return node;
|
|
347
638
|
};
|
|
639
|
+
const hasState = (behavior: BehaviorGraph<State>, state: number) =>
|
|
640
|
+
state < 0
|
|
641
|
+
? behavior.checks.nodes.some(
|
|
642
|
+
(_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
|
|
643
|
+
)
|
|
644
|
+
: behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
|
|
645
|
+
const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
|
|
646
|
+
if (!hasState(behavior, state)) behavior.stateCount++;
|
|
647
|
+
return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
|
|
648
|
+
};
|
|
649
|
+
// The action results of the edge to each target are at its position in actions.
|
|
348
650
|
const writeNode = (
|
|
349
|
-
behavior: BehaviorGraph
|
|
651
|
+
behavior: BehaviorGraph<State>,
|
|
350
652
|
node: number,
|
|
351
653
|
targets: number[],
|
|
352
|
-
|
|
654
|
+
actionResults: Uint8Array,
|
|
655
|
+
actions: number[],
|
|
353
656
|
stateResults: Uint8Array,
|
|
354
657
|
) => {
|
|
355
658
|
const start = behavior.edgeTargets.length;
|
|
356
659
|
const actionCount = behavior.solution.actionChecks.length;
|
|
357
660
|
writeToPool(behavior.edgeTargets, start, targets);
|
|
358
|
-
actions.forEach((
|
|
359
|
-
writeToPool(
|
|
661
|
+
actions.forEach((position, edge) =>
|
|
662
|
+
writeToPool(
|
|
663
|
+
behavior.edgeActions,
|
|
664
|
+
(start + edge) * actionCount,
|
|
665
|
+
actionResults,
|
|
666
|
+
position * actionCount,
|
|
667
|
+
actionCount,
|
|
668
|
+
),
|
|
360
669
|
);
|
|
361
670
|
writeToPool(
|
|
362
671
|
behavior.stateResults,
|
|
@@ -368,57 +677,68 @@ export const createLivenessChecker = (
|
|
|
368
677
|
};
|
|
369
678
|
|
|
370
679
|
// 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.
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
}
|
|
375
|
-
|
|
376
|
-
|
|
680
|
+
// Each slot holds a candidate's position plus one, or 0 when it is empty.
|
|
681
|
+
const successorSet = { slots: new Int32Array(0) };
|
|
682
|
+
const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
|
|
683
|
+
const candidates = [...successors, { index, state }];
|
|
684
|
+
const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
|
|
685
|
+
successorSet.slots =
|
|
686
|
+
successorSet.slots.length === capacity
|
|
687
|
+
? successorSet.slots.fill(0)
|
|
688
|
+
: new Int32Array(capacity);
|
|
689
|
+
const insert = (position: number) => {
|
|
690
|
+
const slots = successorSet.slots;
|
|
691
|
+
const candidate = candidates[position];
|
|
377
692
|
for (
|
|
378
|
-
let slot = (search.getFingerprint(
|
|
693
|
+
let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
|
|
379
694
|
;
|
|
380
695
|
slot = (slot + 1) % slots.length
|
|
381
696
|
) {
|
|
382
697
|
const entry = slots[slot];
|
|
383
|
-
if (entry ===
|
|
384
|
-
slots[slot] =
|
|
698
|
+
if (entry === 0) {
|
|
699
|
+
slots[slot] = position + 1;
|
|
385
700
|
return true;
|
|
386
701
|
}
|
|
387
|
-
|
|
702
|
+
const stored = candidates[entry - 1];
|
|
703
|
+
if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
|
|
388
704
|
return false;
|
|
389
705
|
}
|
|
390
706
|
};
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
707
|
+
let count = 0;
|
|
708
|
+
for (let position = 0; position < candidates.length; position++) {
|
|
709
|
+
if (count >= successorSet.slots.length >> 1) {
|
|
710
|
+
const old = successorSet.slots;
|
|
711
|
+
successorSet.slots = new Int32Array(2 * old.length + 1);
|
|
712
|
+
for (const entry of old) if (entry !== 0) insert(entry - 1);
|
|
396
713
|
}
|
|
397
|
-
if (
|
|
398
|
-
}
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
return
|
|
714
|
+
if (insert(position)) count++;
|
|
715
|
+
}
|
|
716
|
+
if (successorSet.slots.length > capacity) capacityMultiplier++;
|
|
717
|
+
const set: LiveSuccessor<State>[] = [];
|
|
718
|
+
for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
|
|
719
|
+
return set;
|
|
403
720
|
};
|
|
404
721
|
|
|
405
722
|
const expandLate = (
|
|
406
|
-
behavior: BehaviorGraph
|
|
723
|
+
behavior: BehaviorGraph<State>,
|
|
407
724
|
tableau: Tableau,
|
|
408
|
-
state:
|
|
725
|
+
state: State,
|
|
409
726
|
index: number,
|
|
410
727
|
node: number,
|
|
728
|
+
row: Int8Array,
|
|
729
|
+
offset: number,
|
|
411
730
|
) => {
|
|
412
|
-
const stateResults = checkState(behavior, index, state);
|
|
731
|
+
const stateResults = checkState(behavior, index, state, row, offset);
|
|
413
732
|
const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
|
|
414
|
-
const
|
|
733
|
+
const actionCount = behavior.checks.actions.length;
|
|
734
|
+
const actions: number[] = [];
|
|
415
735
|
const successors: number[] = [];
|
|
416
|
-
const
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
736
|
+
const selfResults = new Uint8Array(actionCount);
|
|
737
|
+
if (tableauNode.successors.length > 0) {
|
|
738
|
+
checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
|
|
739
|
+
}
|
|
420
740
|
for (const next of tableauNode.successors) {
|
|
421
|
-
if (!isConsistent(
|
|
741
|
+
if (!isConsistent(behavior, next, index, state, row, offset)) continue;
|
|
422
742
|
if (
|
|
423
743
|
isAccepting(tableau, next) &&
|
|
424
744
|
behavior.errorNode === undefined &&
|
|
@@ -431,60 +751,96 @@ export const createLivenessChecker = (
|
|
|
431
751
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
432
752
|
const target = existing ?? recordNode(behavior, index, next);
|
|
433
753
|
successors.push(target);
|
|
434
|
-
actions.push(
|
|
435
|
-
if (existing === undefined) expandLate(behavior, tableau, state, index, target);
|
|
754
|
+
actions.push(0);
|
|
755
|
+
if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
|
|
436
756
|
}
|
|
437
|
-
|
|
438
|
-
|
|
757
|
+
const nextStates = search.getSuccessors(index, state);
|
|
758
|
+
// The results of the step to the state itself come first, then those of each successor.
|
|
759
|
+
const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
|
|
760
|
+
actionResults.set(selfResults);
|
|
761
|
+
const edges = createEdgeRows(nextStates.length);
|
|
762
|
+
nextStates.forEach((successor, position) => {
|
|
763
|
+
const successorRow = createRows(1);
|
|
764
|
+
checkAction(
|
|
765
|
+
behavior,
|
|
766
|
+
index,
|
|
767
|
+
state,
|
|
768
|
+
row,
|
|
769
|
+
offset,
|
|
770
|
+
successor.state,
|
|
771
|
+
edges,
|
|
772
|
+
position * actionIds.size,
|
|
773
|
+
actionResults,
|
|
774
|
+
(position + 1) * actionCount,
|
|
775
|
+
);
|
|
439
776
|
const isDone = behavior.isDone[successor.index] === true;
|
|
440
777
|
for (const next of tableauNode.successors) {
|
|
441
|
-
if (!isConsistent(
|
|
442
|
-
// Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
|
|
443
|
-
if (successor.index === -1) continue;
|
|
778
|
+
if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
|
|
444
779
|
const existing = getNodeId(behavior, successor.index, next);
|
|
445
780
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
446
781
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
447
782
|
successors.push(target);
|
|
448
|
-
actions.push(
|
|
783
|
+
actions.push(position + 1);
|
|
449
784
|
if (existing === undefined && isDone) {
|
|
450
|
-
expandLate(behavior, tableau, successor.state, successor.index, target);
|
|
785
|
+
expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
|
|
451
786
|
}
|
|
452
787
|
}
|
|
788
|
+
});
|
|
789
|
+
if (successors.length > 0) {
|
|
790
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
453
791
|
}
|
|
454
|
-
if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
|
|
455
792
|
};
|
|
456
793
|
|
|
457
794
|
const addTableauState = (
|
|
458
|
-
behavior: BehaviorGraph
|
|
795
|
+
behavior: BehaviorGraph<State>,
|
|
459
796
|
tableau: Tableau,
|
|
460
|
-
set: LiveSuccessor[],
|
|
461
|
-
|
|
797
|
+
set: LiveSuccessor<State>[],
|
|
798
|
+
rows: Int8Array,
|
|
799
|
+
actionResults: Uint8Array,
|
|
462
800
|
stateResults: Uint8Array,
|
|
463
801
|
index: number,
|
|
464
802
|
) => {
|
|
465
|
-
const
|
|
466
|
-
|
|
467
|
-
);
|
|
803
|
+
const atomCount = stateAtoms.size;
|
|
804
|
+
// Whether each successor is consistent with each tableau node, node by node.
|
|
805
|
+
const consistency = new Uint8Array(tableau.nodes.length * set.length);
|
|
806
|
+
evaluateFrom(index, () => {
|
|
807
|
+
for (let node = 0; node < tableau.nodes.length; node++) {
|
|
808
|
+
for (let position = 0; position < set.length; position++) {
|
|
809
|
+
if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
|
|
810
|
+
consistency[node * set.length + position] = 1;
|
|
811
|
+
}
|
|
812
|
+
}
|
|
813
|
+
}
|
|
814
|
+
});
|
|
815
|
+
if (!hasState(behavior, index)) behavior.stateCount++;
|
|
468
816
|
behavior.isDone[index] = true;
|
|
469
817
|
// TLC expands the nodes recorded before the loop, not the ones the loop records.
|
|
470
818
|
for (const node of getStateNodes(behavior, index)) {
|
|
471
819
|
const successors: number[] = [];
|
|
472
|
-
const actions:
|
|
820
|
+
const actions: number[] = [];
|
|
473
821
|
set.forEach((successor, position) => {
|
|
474
822
|
const isDone = behavior.isDone[successor.index] === true;
|
|
475
823
|
for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
|
|
476
|
-
if (
|
|
824
|
+
if (consistency[next * set.length + position] === 0) continue;
|
|
477
825
|
const existing = getNodeId(behavior, successor.index, next);
|
|
478
826
|
if (existing !== undefined && successors.includes(existing)) continue;
|
|
479
827
|
const target = existing ?? recordNode(behavior, successor.index, next);
|
|
480
828
|
successors.push(target);
|
|
481
|
-
actions.push(
|
|
829
|
+
actions.push(position);
|
|
482
830
|
if (existing === undefined && isDone) {
|
|
483
|
-
expandLate(
|
|
831
|
+
expandLate(
|
|
832
|
+
behavior,
|
|
833
|
+
tableau,
|
|
834
|
+
successor.state,
|
|
835
|
+
successor.index,
|
|
836
|
+
target,
|
|
837
|
+
rows,
|
|
838
|
+
position * atomCount,
|
|
839
|
+
);
|
|
484
840
|
}
|
|
485
841
|
}
|
|
486
842
|
});
|
|
487
|
-
writeNode(behavior, node, successors, actions, stateResults);
|
|
843
|
+
writeNode(behavior, node, successors, actionResults, actions, stateResults);
|
|
488
844
|
}
|
|
489
845
|
return behavior.errorNode === undefined
|
|
490
846
|
? undefined
|
|
@@ -492,24 +848,25 @@ export const createLivenessChecker = (
|
|
|
492
848
|
};
|
|
493
849
|
|
|
494
850
|
const addPlainState = (
|
|
495
|
-
behavior: BehaviorGraph
|
|
496
|
-
set: LiveSuccessor[],
|
|
497
|
-
actionResults: Uint8Array
|
|
851
|
+
behavior: BehaviorGraph<State>,
|
|
852
|
+
set: LiveSuccessor<State>[],
|
|
853
|
+
actionResults: Uint8Array,
|
|
498
854
|
stateResults: Uint8Array,
|
|
499
855
|
index: number,
|
|
500
856
|
) => {
|
|
501
857
|
while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
|
|
502
858
|
const successors: number[] = [];
|
|
503
|
-
const actions:
|
|
859
|
+
const actions: number[] = [];
|
|
504
860
|
set.forEach((successor, position) => {
|
|
505
861
|
if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
|
|
506
862
|
successors.push(successor.index);
|
|
507
|
-
actions.push(
|
|
863
|
+
actions.push(position);
|
|
508
864
|
});
|
|
509
|
-
|
|
865
|
+
if (!isWritten(behavior, index)) behavior.stateCount++;
|
|
866
|
+
writeNode(behavior, index, successors, actionResults, actions, stateResults);
|
|
510
867
|
};
|
|
511
868
|
|
|
512
|
-
const getPath = (behavior: BehaviorGraph
|
|
869
|
+
const getPath = (behavior: BehaviorGraph<State>, target: number) => {
|
|
513
870
|
if (behavior.initial.includes(target)) return [target];
|
|
514
871
|
const parents = new Map<number, number>();
|
|
515
872
|
const queue: number[] = [];
|
|
@@ -535,7 +892,7 @@ export const createLivenessChecker = (
|
|
|
535
892
|
throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
|
|
536
893
|
};
|
|
537
894
|
|
|
538
|
-
const getStatePath = (behavior: BehaviorGraph
|
|
895
|
+
const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
|
|
539
896
|
removeRepeats(
|
|
540
897
|
getPath(behavior, target)
|
|
541
898
|
.reverse()
|
|
@@ -543,7 +900,7 @@ export const createLivenessChecker = (
|
|
|
543
900
|
);
|
|
544
901
|
|
|
545
902
|
const findLassoInModel = (
|
|
546
|
-
behavior: BehaviorGraph
|
|
903
|
+
behavior: BehaviorGraph<State>,
|
|
547
904
|
model: Solution["models"][number],
|
|
548
905
|
): Lasso | undefined => {
|
|
549
906
|
const solution = behavior.solution;
|
|
@@ -768,59 +1125,80 @@ export const createLivenessChecker = (
|
|
|
768
1125
|
|
|
769
1126
|
return {
|
|
770
1127
|
branches: behaviors.length,
|
|
771
|
-
addInitialState: (index, state
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
behavior.initial.push(
|
|
785
|
-
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
786
|
-
);
|
|
787
|
-
}
|
|
1128
|
+
addInitialState: (index, state) => {
|
|
1129
|
+
const row = createRows(1);
|
|
1130
|
+
for (const behavior of behaviors) {
|
|
1131
|
+
const tableau = behavior.solution.tableau;
|
|
1132
|
+
if (!tableau) {
|
|
1133
|
+
behavior.initial.push(index);
|
|
1134
|
+
continue;
|
|
1135
|
+
}
|
|
1136
|
+
for (let node = 0; node < tableau.initialCount; node++) {
|
|
1137
|
+
if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
|
|
1138
|
+
behavior.initial.push(
|
|
1139
|
+
getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
|
|
1140
|
+
);
|
|
788
1141
|
}
|
|
789
|
-
} finally {
|
|
790
|
-
evaluationEnvironment = environment;
|
|
791
1142
|
}
|
|
792
1143
|
},
|
|
793
|
-
addState: (index, state, successors
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
const tableau = behavior.solution.tableau;
|
|
805
|
-
if (!tableau) {
|
|
806
|
-
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
807
|
-
continue;
|
|
808
|
-
}
|
|
809
|
-
const accepted = addTableauState(
|
|
1144
|
+
addState: (index, state, successors) => {
|
|
1145
|
+
const set = getSuccessorSet(index, state, successors);
|
|
1146
|
+
const rows = createRows(set.length);
|
|
1147
|
+
// The set holds the state itself, as a successor of the same index.
|
|
1148
|
+
const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
|
|
1149
|
+
const edges = createEdgeRows(set.length);
|
|
1150
|
+
for (const behavior of behaviors) {
|
|
1151
|
+
const actionCount = behavior.checks.actions.length;
|
|
1152
|
+
const actionResults = new Uint8Array(set.length * actionCount);
|
|
1153
|
+
set.forEach((successor, position) =>
|
|
1154
|
+
checkAction(
|
|
810
1155
|
behavior,
|
|
811
|
-
tableau,
|
|
812
|
-
set,
|
|
813
|
-
actionResults,
|
|
814
|
-
stateResults,
|
|
815
1156
|
index,
|
|
816
|
-
|
|
817
|
-
|
|
1157
|
+
state,
|
|
1158
|
+
rows,
|
|
1159
|
+
offset,
|
|
1160
|
+
successor.state,
|
|
1161
|
+
edges,
|
|
1162
|
+
position * actionIds.size,
|
|
1163
|
+
actionResults,
|
|
1164
|
+
position * actionCount,
|
|
1165
|
+
),
|
|
1166
|
+
);
|
|
1167
|
+
const stateResults = checkState(behavior, index, state, rows, offset);
|
|
1168
|
+
const tableau = behavior.solution.tableau;
|
|
1169
|
+
if (!tableau) {
|
|
1170
|
+
addPlainState(behavior, set, actionResults, stateResults, index);
|
|
1171
|
+
continue;
|
|
1172
|
+
}
|
|
1173
|
+
const accepted = addTableauState(
|
|
1174
|
+
behavior,
|
|
1175
|
+
tableau,
|
|
1176
|
+
set,
|
|
1177
|
+
rows,
|
|
1178
|
+
actionResults,
|
|
1179
|
+
stateResults,
|
|
1180
|
+
index,
|
|
1181
|
+
);
|
|
1182
|
+
if (accepted) return accepted;
|
|
1183
|
+
}
|
|
1184
|
+
return undefined;
|
|
1185
|
+
},
|
|
1186
|
+
storeState: (pending, index) => {
|
|
1187
|
+
for (const behavior of behaviors) {
|
|
1188
|
+
const tableau = behavior.solution.tableau;
|
|
1189
|
+
if (!tableau) continue;
|
|
1190
|
+
const nodes: number[] = [];
|
|
1191
|
+
for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
|
|
1192
|
+
const node = getNodeId(behavior, pending, tableauNode);
|
|
1193
|
+
if (node !== undefined) nodes.push(node);
|
|
1194
|
+
}
|
|
1195
|
+
for (const node of nodes.sort((left, right) => left - right)) {
|
|
1196
|
+
behavior.nodeStates[node] = index;
|
|
1197
|
+
linkNode(behavior, index, behavior.nodeTableaux[node], node);
|
|
818
1198
|
}
|
|
819
|
-
return undefined;
|
|
820
|
-
} finally {
|
|
821
|
-
evaluationEnvironment = environment;
|
|
822
1199
|
}
|
|
823
1200
|
},
|
|
1201
|
+
getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
|
|
824
1202
|
findViolation: () => {
|
|
825
1203
|
for (const behavior of behaviors) {
|
|
826
1204
|
for (const model of behavior.solution.models) {
|
|
@@ -830,15 +1208,5 @@ export const createLivenessChecker = (
|
|
|
830
1208
|
}
|
|
831
1209
|
return undefined;
|
|
832
1210
|
},
|
|
833
|
-
getViolatedProperties: (path, cycleStart) => [
|
|
834
|
-
...new Set(
|
|
835
|
-
properties
|
|
836
|
-
.filter(
|
|
837
|
-
(_property, position) =>
|
|
838
|
-
!evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
|
|
839
|
-
)
|
|
840
|
-
.map((property) => property.name),
|
|
841
|
-
),
|
|
842
|
-
],
|
|
843
1211
|
};
|
|
844
1212
|
};
|