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