tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -1
- package/dist/compile.cjs +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +41 -37
- package/dist/deciders.js +41 -37
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +21 -4
- package/dist/index.d.ts +21 -4
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2681 -425
- package/dist/prove.js +2681 -425
- package/dist/run.cjs +41 -42
- package/dist/run.js +41 -42
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -89
- package/dist/transfer.js +97 -89
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +72 -39
- package/src/bags.ts +50 -29
- package/src/builtins.ts +8 -16
- package/src/check-failure.ts +118 -0
- package/src/check-trace.ts +321 -0
- package/src/check.ts +828 -770
- package/src/cli/options.ts +6 -31
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +433 -70
- package/src/cli/tlc-arguments.ts +224 -212
- package/src/cli/tlc-output.ts +701 -0
- package/src/cli/tlc-usage.ts +1 -2
- package/src/cli/tlc.ts +65 -712
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +28 -20
- package/src/coverage.ts +255 -20
- package/src/dependencies.ts +96 -27
- package/src/dfid.ts +115 -50
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +175 -373
- package/src/errors.ts +40 -5
- package/src/evaluate.ts +429 -139
- package/src/exit-codes.ts +28 -12
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +178 -17
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/json.ts +4 -7
- package/src/levels.ts +708 -272
- package/src/lexer.ts +17 -5
- package/src/liveness-checker.ts +707 -249
- package/src/liveness.ts +148 -95
- package/src/obligations/action.ts +14 -17
- package/src/obligations/anonymize.ts +37 -16
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +1 -3
- package/src/obligations/expression.ts +36 -8
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +66 -54
- package/src/obligations/index.ts +39 -9
- package/src/obligations/levels.ts +24 -11
- package/src/obligations/module.ts +28 -41
- package/src/obligations/normalize.ts +27 -18
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +53 -16
- package/src/obligations/printer.ts +48 -18
- package/src/obligations/proof.ts +3 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +55 -50
- package/src/obligations/source.ts +120 -74
- package/src/obligations/subexpression.ts +45 -18
- package/src/obligations/substitution.ts +1 -3
- package/src/obligations/temporal.ts +5 -7
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +17 -31
- package/src/parallel.ts +29 -47
- package/src/parser.ts +757 -326
- package/src/pretty-print.ts +1 -1
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +12 -9
- package/src/prover/isabelle/decide.ts +3 -25
- package/src/prover/isabelle/encode.ts +72 -42
- package/src/prover/isabelle/isar/attrib.ts +250 -0
- package/src/prover/isabelle/isar/context.ts +335 -0
- package/src/prover/isabelle/isar/induct.ts +382 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
- package/src/prover/isabelle/isar/method.ts +509 -212
- package/src/prover/isabelle/isar/proof.ts +570 -14
- package/src/prover/isabelle/isar/rule-cases.ts +226 -0
- package/src/prover/isabelle/isar/theory.ts +487 -76
- package/src/prover/isabelle/isar/toplevel.ts +331 -0
- package/src/prover/isabelle/isar/type-check.ts +89 -14
- package/src/prover/isabelle/provers/blast/blast.ts +7 -65
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +45 -20
- package/src/prover/isabelle/provers/hypsubst.ts +19 -30
- package/src/prover/isabelle/pure/bicompose.ts +9 -27
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +2 -10
- package/src/prover/isabelle/pure/drule.ts +72 -6
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +1 -3
- package/src/prover/isabelle/pure/logic.ts +1 -3
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +13 -7
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
- package/src/prover/isabelle/pure/rewriter.ts +9 -20
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +26 -7
- package/src/prover/isabelle/pure/table.ts +2 -3
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +42 -37
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +3 -5
- package/src/prover/isabelle/pure/thm.ts +14 -13
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +18 -16
- package/src/prover/isabelle/tla/context.ts +58 -11
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +49 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -12
- package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +30 -31
- package/src/prover/prep/enabled-axioms.ts +11 -2
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/prep/methods.ts +181 -51
- package/src/prover/prep/normalize.ts +38 -9
- package/src/prover/prove.ts +395 -94
- package/src/prover/ptl/decide.ts +95 -50
- package/src/prover/ptl/encode.ts +2 -3
- package/src/prover/ptl/tableau.ts +28 -2
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -8
- package/src/prover/smt/context.ts +43 -8
- package/src/prover/smt/data.ts +498 -379
- package/src/prover/smt/encode.ts +148 -57
- package/src/prover/smt/extensionality.ts +5 -3
- package/src/prover/smt/flatten.ts +4 -6
- package/src/prover/smt/format.ts +28 -4
- package/src/prover/smt/instances.ts +7 -1
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1016 -618
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
- package/src/prover/smt/solver/ackr-helper.ts +179 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
- package/src/prover/smt/solver/aig-tactic.ts +52 -0
- package/src/prover/smt/solver/aig.ts +889 -0
- package/src/prover/smt/solver/arith-rewriter.ts +624 -9
- package/src/prover/smt/solver/arith-terms.ts +121 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
- package/src/prover/smt/solver/array-rewriter.ts +319 -0
- package/src/prover/smt/solver/asserted-formulas.ts +240 -56
- package/src/prover/smt/solver/ast-lt.ts +165 -11
- package/src/prover/smt/solver/ast-util.ts +160 -2
- package/src/prover/smt/solver/ast.ts +1483 -45
- package/src/prover/smt/solver/auf-solver.ts +25 -18
- package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
- package/src/prover/smt/solver/bit-blaster.ts +871 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-manager.ts +196 -0
- package/src/prover/smt/solver/bound-simplifier.ts +598 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
- package/src/prover/smt/solver/bv1-blast.ts +214 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
- package/src/prover/smt/solver/card2bv.ts +127 -0
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +39 -25
- package/src/prover/smt/solver/check-logic.ts +330 -0
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
- package/src/prover/smt/solver/conflict-resolution.ts +78 -2
- package/src/prover/smt/solver/context.ts +598 -128
- package/src/prover/smt/solver/ctx-simplify.ts +29 -14
- package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
- package/src/prover/smt/solver/demodulator.ts +786 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
- package/src/prover/smt/solver/der.ts +38 -10
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +57 -0
- package/src/prover/smt/solver/dom-simplify.ts +511 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +7 -8
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
- package/src/prover/smt/solver/enode.ts +100 -3
- package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
- package/src/prover/smt/solver/euf/array-solver.ts +306 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
- package/src/prover/smt/solver/euf/egraph.ts +901 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
- package/src/prover/smt/solver/euf/mam.ts +1046 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +328 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
- package/src/prover/smt/solver/expr2polynomial.ts +271 -0
- package/src/prover/smt/solver/factor.ts +163 -0
- package/src/prover/smt/solver/fd-solver.ts +734 -0
- package/src/prover/smt/solver/fingerprints.ts +15 -15
- package/src/prover/smt/solver/fix-dl-var.ts +147 -0
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +886 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
- package/src/prover/smt/solver/goal.ts +178 -15
- package/src/prover/smt/solver/goal2nlsat.ts +216 -0
- package/src/prover/smt/solver/guard-set.ts +219 -0
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +34 -16
- package/src/prover/smt/solver/inf-eps.ts +63 -0
- package/src/prover/smt/solver/inj-axiom.ts +101 -0
- package/src/prover/smt/solver/internalizer.ts +111 -39
- package/src/prover/smt/solver/lackr.ts +381 -0
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +268 -0
- package/src/prover/smt/solver/lia2pb.ts +154 -0
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +355 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +30 -11
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +3 -4
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
- package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +68 -17
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +7 -2
- package/src/prover/smt/solver/macro-finder.ts +530 -0
- package/src/prover/smt/solver/mam-compiler.ts +122 -90
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
- package/src/prover/smt/solver/max-cliques.ts +105 -0
- package/src/prover/smt/solver/maxcore.ts +310 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
- package/src/prover/smt/solver/maxlex.ts +115 -0
- package/src/prover/smt/solver/maxsmt-base.ts +106 -0
- package/src/prover/smt/solver/maxsmt.ts +92 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
- package/src/prover/smt/solver/model-based-opt.ts +844 -0
- package/src/prover/smt/solver/model-checker.ts +19 -28
- package/src/prover/smt/solver/model-evaluator.ts +190 -12
- package/src/prover/smt/solver/model-finder.ts +12 -18
- package/src/prover/smt/solver/model-generator.ts +104 -35
- package/src/prover/smt/solver/model-macro-solver.ts +49 -46
- package/src/prover/smt/solver/model-printer.ts +214 -0
- package/src/prover/smt/solver/mpf.ts +709 -0
- package/src/prover/smt/solver/mus.ts +50 -0
- package/src/prover/smt/solver/muz/dl-context.ts +382 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
- package/src/prover/smt/solver/muz/substitution.ts +203 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
- package/src/prover/smt/solver/nlqsat.ts +485 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
- package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +427 -229
- package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
- package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
- package/src/prover/smt/solver/nlsat/solver.ts +293 -92
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
- package/src/prover/smt/solver/nnf.ts +110 -24
- package/src/prover/smt/solver/normalize-bounds.ts +53 -0
- package/src/prover/smt/solver/occf.ts +97 -0
- package/src/prover/smt/solver/opt-context.ts +801 -0
- package/src/prover/smt/solver/opt-nlsat.ts +386 -0
- package/src/prover/smt/solver/opt-pareto.ts +301 -0
- package/src/prover/smt/solver/opt-preprocess.ts +101 -0
- package/src/prover/smt/solver/opt-solver.ts +312 -0
- package/src/prover/smt/solver/opt-value.ts +55 -0
- package/src/prover/smt/solver/optsmt.ts +692 -0
- package/src/prover/smt/solver/parallel-tactic.ts +299 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -11
- package/src/prover/smt/solver/pb-rewriter.ts +281 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
- package/src/prover/smt/solver/poly-rewriter.ts +259 -57
- package/src/prover/smt/solver/probes.ts +577 -0
- package/src/prover/smt/solver/propagate-values.ts +37 -21
- package/src/prover/smt/solver/proto-model.ts +648 -19
- package/src/prover/smt/solver/pull-quant.ts +28 -12
- package/src/prover/smt/solver/purify-arith.ts +634 -0
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
- package/src/prover/smt/solver/qe-lite-der.ts +2 -3
- package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
- package/src/prover/smt/solver/qe-lite.ts +39 -19
- package/src/prover/smt/solver/qe-mbp.ts +270 -0
- package/src/prover/smt/solver/qe.ts +1499 -0
- package/src/prover/smt/solver/qel.ts +25 -0
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +829 -0
- package/src/prover/smt/solver/quant-hoist.ts +196 -0
- package/src/prover/smt/solver/quant-tactics.ts +16 -56
- package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
- package/src/prover/smt/solver/quantifier-manager.ts +22 -25
- package/src/prover/smt/solver/quasi-macros.ts +243 -0
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +45 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
- package/src/prover/smt/solver/reduce-args.ts +225 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +1 -2
- package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
- package/src/prover/smt/solver/rewriter.ts +505 -60
- package/src/prover/smt/solver/rlimit.ts +45 -5
- package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
- package/src/prover/smt/solver/sat/big.ts +177 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
- package/src/prover/smt/solver/sat/clause.ts +203 -0
- package/src/prover/smt/solver/sat/cleaner.ts +94 -0
- package/src/prover/smt/solver/sat/config.ts +122 -0
- package/src/prover/smt/solver/sat/consequences.ts +203 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
- package/src/prover/smt/solver/sat/model-converter.ts +136 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
- package/src/prover/smt/solver/sat/probing.ts +170 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
- package/src/prover/smt/solver/sat/scc.ts +142 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
- package/src/prover/smt/solver/sat/solver.ts +2107 -0
- package/src/prover/smt/solver/sat/var-queue.ts +117 -0
- package/src/prover/smt/solver/sat/watch-list.ts +140 -0
- package/src/prover/smt/solver/search-tree.ts +284 -0
- package/src/prover/smt/solver/seq-axioms.ts +995 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
- package/src/prover/smt/solver/seq-derive.ts +1298 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
- package/src/prover/smt/solver/seq-factory.ts +89 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
- package/src/prover/smt/solver/seq-re-util.ts +758 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
- package/src/prover/smt/solver/seq-regex-live.ts +200 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
- package/src/prover/smt/solver/seq-skolem.ts +294 -0
- package/src/prover/smt/solver/seq-subset.ts +165 -0
- package/src/prover/smt/solver/seq-view-witness.ts +353 -0
- package/src/prover/smt/solver/smt-consequences.ts +297 -0
- package/src/prover/smt/solver/smt-kernel.ts +124 -0
- package/src/prover/smt/solver/smt-logics.ts +66 -0
- package/src/prover/smt/solver/smt-setup.ts +589 -0
- package/src/prover/smt/solver/smt2-printer.ts +765 -0
- package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
- package/src/prover/smt/solver/smtlib-script.ts +2136 -0
- package/src/prover/smt/solver/solve-eqs.ts +928 -0
- package/src/prover/smt/solver/solver.ts +128 -23
- package/src/prover/smt/solver/static-features.ts +314 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +2176 -0
- package/src/prover/smt/solver/term-enumeration.ts +205 -0
- package/src/prover/smt/solver/theory-array.ts +1240 -0
- package/src/prover/smt/solver/theory-bv.ts +1210 -0
- package/src/prover/smt/solver/theory-char.ts +355 -0
- package/src/prover/smt/solver/theory-datatype.ts +598 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +389 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
- package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
- package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
- package/src/prover/smt/solver/theory-lra-model.ts +20 -35
- package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
- package/src/prover/smt/solver/theory-lra-state.ts +7 -23
- package/src/prover/smt/solver/theory-lra.ts +189 -2
- package/src/prover/smt/solver/theory-pb.ts +951 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
- package/src/prover/smt/solver/theory-recfun.ts +307 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
- package/src/prover/smt/solver/theory-seq-state.ts +852 -0
- package/src/prover/smt/solver/theory-seq.ts +961 -0
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/theory.ts +189 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
- package/src/prover/smt/solver/var-subst.ts +36 -14
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +57 -26
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/decide.ts +10 -7
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +2 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +28 -2
- package/src/prover/zenon/index-table.ts +16 -23
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +37 -39
- package/src/prover/zenon/llproof.ts +2 -13
- package/src/prover/zenon/mltoll.ts +12 -30
- package/src/prover/zenon/node.ts +20 -5
- package/src/prover/zenon/parse.ts +9 -8
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +11 -19
- package/src/prover/zenon/tla/functions.ts +2 -4
- package/src/prover/zenon/tla/llproof.ts +9 -13
- package/src/prover/zenon/tla/records.ts +1 -8
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +22 -22
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +7 -8
- package/src/resolve.ts +1327 -328
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +384 -0
- package/src/sany/generator-def-entries.ts +297 -0
- package/src/sany/generator-definitions.ts +688 -0
- package/src/sany/generator-expressions.ts +1123 -0
- package/src/sany/generator-proofs.ts +668 -0
- package/src/sany/generator.ts +161 -2625
- package/src/sany/levels.ts +0 -2
- package/src/sany/lexer.ts +32 -23
- package/src/sany/linter.ts +0 -2
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +3 -4
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +46 -44
- package/src/sany/xml.ts +25 -58
- package/src/search.ts +513 -165
- package/src/simulate.ts +340 -251
- package/src/spec-description.ts +48 -55
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +72 -54
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +564 -138
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +56 -28
- package/src/symmetry.ts +4 -3
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +23 -18
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +6 -5
- package/src/tlc/replay.ts +152 -58
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlc-operators.ts +12 -11
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +27 -60
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +6556 -0
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +208 -227
- package/src/prover/isabelle/isar/statement.ts +0 -52
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/tlaps-module.ts +0 -510
- package/src/prover/zenon/LICENSE +0 -32
package/src/levels.ts
CHANGED
|
@@ -1,27 +1,30 @@
|
|
|
1
1
|
import {
|
|
2
2
|
getChildren,
|
|
3
3
|
type AssumeProve,
|
|
4
|
+
type Bound,
|
|
4
5
|
type Definition,
|
|
5
6
|
type Expression,
|
|
7
|
+
type Fact,
|
|
8
|
+
type LetExpression,
|
|
6
9
|
type Module,
|
|
10
|
+
type ModuleUnit,
|
|
11
|
+
type NewSymbol,
|
|
7
12
|
type OperatorParam,
|
|
8
13
|
type Proof,
|
|
9
14
|
type ProofStep,
|
|
10
15
|
type SourceLocation,
|
|
16
|
+
type SourceRange,
|
|
11
17
|
} from "./ast";
|
|
12
|
-
import {
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
type SanyError,
|
|
18
|
-
} from "./errors";
|
|
19
|
-
import { mapChildren } from "./instances";
|
|
20
|
-
import { collectSemanticErrors, getBoundNames, getPatternNames } from "./resolve";
|
|
18
|
+
import { formatRange, type SanyError } from "./errors";
|
|
19
|
+
import { forEachChild } from "./instances";
|
|
20
|
+
import { parenthesizedRanges } from "./parser";
|
|
21
|
+
import { collectSemanticErrors, getBoundNames, getPatternNames, isBefore } from "./resolve";
|
|
22
|
+
import { resolveSynonym } from "./tlc/jar-data";
|
|
21
23
|
import { STANDARD_LEVELS } from "./standard-definitions";
|
|
22
24
|
|
|
23
25
|
interface LevelData {
|
|
24
26
|
level: number;
|
|
27
|
+
isCorrect: boolean;
|
|
25
28
|
params: Set<string>;
|
|
26
29
|
constraints: Map<string, number>;
|
|
27
30
|
argConstraints: Map<string, number>;
|
|
@@ -46,7 +49,7 @@ interface LevelContext {
|
|
|
46
49
|
}
|
|
47
50
|
|
|
48
51
|
type ScopeEntry =
|
|
49
|
-
| { kind: "Formal"; arity: number }
|
|
52
|
+
| { kind: "Formal"; arity: number; level: number }
|
|
50
53
|
| { kind: "Let"; definition: Definition; scope: Scope };
|
|
51
54
|
|
|
52
55
|
export type Scope = Map<string, ScopeEntry>;
|
|
@@ -55,17 +58,37 @@ type Resolved =
|
|
|
55
58
|
| { kind: "Declared"; name: string; level: number; arity: number }
|
|
56
59
|
| { kind: "Defined"; levels: OperatorLevels };
|
|
57
60
|
|
|
58
|
-
interface
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
61
|
+
interface SectionMember {
|
|
62
|
+
definition: Definition;
|
|
63
|
+
scope: Scope;
|
|
64
|
+
isRechecked: boolean;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
interface RecursiveSection {
|
|
68
|
+
location: SourceLocation;
|
|
69
|
+
members: SectionMember[];
|
|
62
70
|
}
|
|
63
71
|
|
|
72
|
+
type ScopeFrame = Definition | LetExpression | string[];
|
|
73
|
+
|
|
74
|
+
type Operand =
|
|
75
|
+
| { kind: "Value"; data: LevelData }
|
|
76
|
+
| { kind: "Operator"; data: OperatorLevels }
|
|
77
|
+
| { kind: "Declared"; data: LevelData; declared: OperatorParam };
|
|
78
|
+
|
|
64
79
|
export const CONSTANT_LEVEL = 0;
|
|
65
80
|
export const VARIABLE_LEVEL = 1;
|
|
66
81
|
export const ACTION_LEVEL = 2;
|
|
67
82
|
export const TEMPORAL_LEVEL = 3;
|
|
68
83
|
|
|
84
|
+
const NEW_SYMBOL_LEVELS = {
|
|
85
|
+
Constant: CONSTANT_LEVEL,
|
|
86
|
+
Variable: VARIABLE_LEVEL,
|
|
87
|
+
State: VARIABLE_LEVEL,
|
|
88
|
+
Action: ACTION_LEVEL,
|
|
89
|
+
Temporal: TEMPORAL_LEVEL,
|
|
90
|
+
} satisfies Record<NewSymbol["level"], number>;
|
|
91
|
+
|
|
69
92
|
const SEPARATOR = "\u0000";
|
|
70
93
|
|
|
71
94
|
export const getArgumentKey = (operator: string, index: number) =>
|
|
@@ -84,6 +107,7 @@ const getConditionKey = (operator: number, operand: number, argument: number) =>
|
|
|
84
107
|
|
|
85
108
|
const createData = (level = 0): LevelData => ({
|
|
86
109
|
level,
|
|
110
|
+
isCorrect: true,
|
|
87
111
|
params: new Set(),
|
|
88
112
|
constraints: new Map(),
|
|
89
113
|
argConstraints: new Map(),
|
|
@@ -96,6 +120,12 @@ export const putConstraint = (constraints: Map<string, number>, name: string, le
|
|
|
96
120
|
export const putArgConstraint = (constraints: Map<string, number>, key: string, level: number) =>
|
|
97
121
|
constraints.set(key, Math.max(level, constraints.get(key) ?? 0));
|
|
98
122
|
|
|
123
|
+
const mergeConstraints = (data: LevelData, part: LevelData) => {
|
|
124
|
+
part.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
|
|
125
|
+
part.argConstraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value));
|
|
126
|
+
part.argParams.forEach((key) => data.argParams.add(key));
|
|
127
|
+
};
|
|
128
|
+
|
|
99
129
|
const createSignature = (
|
|
100
130
|
name: string,
|
|
101
131
|
level: number,
|
|
@@ -149,27 +179,50 @@ const CORE_SIGNATURES = new Map(
|
|
|
149
179
|
["BOOLEAN", 0, [], []],
|
|
150
180
|
["STRING", 0, [], []],
|
|
151
181
|
] as const
|
|
152
|
-
).map((
|
|
153
|
-
|
|
182
|
+
).map((signature): [string, OperatorLevels] => [
|
|
183
|
+
signature[0],
|
|
154
184
|
{
|
|
155
|
-
...createSignature(
|
|
156
|
-
nonLeibniz: new Set(
|
|
185
|
+
...createSignature(signature[0], signature[1], [...signature[2]], [...signature[3]]),
|
|
186
|
+
nonLeibniz: new Set(signature[1] > 1 ? [0, 1] : []),
|
|
157
187
|
},
|
|
158
188
|
]),
|
|
159
189
|
);
|
|
160
190
|
|
|
161
|
-
const SET_LEVELS = createSignature("$Set", 0, [2], [1]);
|
|
162
|
-
const JUNCTION_LEVELS = createSignature("$Junction", 0, [3], [1]);
|
|
163
|
-
const CHOOSE_LEVELS = createSignature("$Choose", 0, [2], [1]);
|
|
164
|
-
const FUNCTION_LEVELS = createSignature("$Function", 0, [3], [1]);
|
|
165
|
-
const APPLY_LEVELS = createSignature("$FcnApply", 0, [2, 2], [1, 1]);
|
|
166
|
-
const SELECT_LEVELS = createSignature("$RcdSelect", 0, [2, 0], [1, 1]);
|
|
167
191
|
const PRIME_LEVELS = createSignature("'", 2, [1], [0]);
|
|
192
|
+
const UNCHANGED_LEVELS = createSignature("UNCHANGED", 2, [1], [0]);
|
|
168
193
|
const ENABLED_LEVELS = createSignature("ENABLED", 1, [2], [0]);
|
|
169
|
-
const
|
|
170
|
-
const
|
|
171
|
-
const
|
|
172
|
-
const
|
|
194
|
+
const ALWAYS_LEVELS = createSignature("[]", 3, [3], [0]);
|
|
195
|
+
const EVENTUALLY_LEVELS = createSignature("<>", 3, [3], [0]);
|
|
196
|
+
const AND_LEVELS = createSignature("$ConjList", 0, [3], [1]);
|
|
197
|
+
const OR_LEVELS = createSignature("$DisjList", 0, [3], [1]);
|
|
198
|
+
const IF_LEVELS = createSignature("$IfThenElse", 0, [3], [1]);
|
|
199
|
+
const CASE_LEVELS = createSignature("$Case", 0, [3], [1]);
|
|
200
|
+
const FORALL_LEVELS = createSignature("$BoundedForall", 0, [3], [1]);
|
|
201
|
+
const EXISTS_LEVELS = createSignature("$BoundedExists", 0, [3], [1]);
|
|
202
|
+
const UNBOUNDED_FORALL_LEVELS = createSignature("$UnboundedForall", 0, [3], [1]);
|
|
203
|
+
const UNBOUNDED_EXISTS_LEVELS = createSignature("$UnboundedExists", 0, [3], [1]);
|
|
204
|
+
const TEMPORAL_FORALL_LEVELS = createSignature("$TemporalForall", 3, [3], [0]);
|
|
205
|
+
const TEMPORAL_EXISTS_LEVELS = createSignature("$TemporalExists", 3, [3], [0]);
|
|
206
|
+
const BOUNDED_CHOOSE_LEVELS = createSignature("$BoundedChoose", 0, [2], [1]);
|
|
207
|
+
const UNBOUNDED_CHOOSE_LEVELS = createSignature("$UnboundedChoose", 0, [2], [1]);
|
|
208
|
+
const SET_ENUMERATE_LEVELS = createSignature("$SetEnumerate", 0, [2], [1]);
|
|
209
|
+
const TUPLE_LEVELS = createSignature("$Tuple", 0, [2], [1]);
|
|
210
|
+
const SET_OF_FCNS_LEVELS = createSignature("$SetOfFcns", 0, [2], [1]);
|
|
211
|
+
const CARTESIAN_PROD_LEVELS = createSignature("$CartesianProd", 0, [2], [1]);
|
|
212
|
+
const SUBSET_OF_LEVELS = createSignature("$SubsetOf", 0, [2], [1]);
|
|
213
|
+
const SET_OF_ALL_LEVELS = createSignature("$SetOfAll", 0, [2], [1]);
|
|
214
|
+
const FCN_CONSTRUCTOR_LEVELS = createSignature("$FcnConstructor", 0, [3], [1]);
|
|
215
|
+
const RCD_CONSTRUCTOR_LEVELS = createSignature("$RcdConstructor", 0, [3], [1]);
|
|
216
|
+
const SET_OF_RCDS_LEVELS = createSignature("$SetOfRcds", 0, [2], [1]);
|
|
217
|
+
const EXCEPT_LEVELS = createSignature("$Except", 0, [2], [1]);
|
|
218
|
+
const PAIR_LEVELS = createSignature("$Pair", 0, [3], [1]);
|
|
219
|
+
const SEQ_LEVELS = createSignature("$Seq", 0, [2], [1]);
|
|
220
|
+
const APPLY_LEVELS = createSignature("$FcnApply", 0, [2, 2], [1, 1]);
|
|
221
|
+
const SELECT_LEVELS = createSignature("$RcdSelect", 0, [2, 0], [1, 1]);
|
|
222
|
+
const SQUARE_ACT_LEVELS = createSignature("$SquareAct", 2, [2, 1], [0, 0]);
|
|
223
|
+
const ANGLE_ACT_LEVELS = createSignature("$AngleAct", 2, [2, 1], [0, 0]);
|
|
224
|
+
const WF_LEVELS = createSignature("$WF", 3, [1, 2], [0, 0]);
|
|
225
|
+
const SF_LEVELS = createSignature("$SF", 3, [1, 2], [0, 0]);
|
|
173
226
|
|
|
174
227
|
const bindFormals = (scope: Scope, formals: OperatorParam[]) =>
|
|
175
228
|
formals.length === 0
|
|
@@ -178,31 +231,204 @@ const bindFormals = (scope: Scope, formals: OperatorParam[]) =>
|
|
|
178
231
|
...scope,
|
|
179
232
|
...formals.map((formal): [string, ScopeEntry] => [
|
|
180
233
|
formal.name,
|
|
181
|
-
{ kind: "Formal", arity: formal.arity },
|
|
234
|
+
{ kind: "Formal", arity: formal.arity, level: CONSTANT_LEVEL },
|
|
182
235
|
]),
|
|
183
236
|
]);
|
|
184
237
|
|
|
185
238
|
const toFormals = (names: string[]) => names.map((name) => ({ name, arity: 0 }));
|
|
186
239
|
|
|
187
|
-
const
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
240
|
+
const getFormals = (definition: Definition) =>
|
|
241
|
+
definition.kind === "Operator" ? definition.params : [];
|
|
242
|
+
|
|
243
|
+
const getDefinitionBody = (definition: Definition): Expression =>
|
|
244
|
+
definition.kind === "Function"
|
|
245
|
+
? {
|
|
246
|
+
kind: "FunctionConstruction",
|
|
247
|
+
bounds: definition.bounds,
|
|
248
|
+
body: definition.body,
|
|
249
|
+
location: definition.location,
|
|
250
|
+
}
|
|
251
|
+
: definition.body;
|
|
252
|
+
|
|
253
|
+
const createLetScope = (expression: LetExpression, scope: Scope) => {
|
|
254
|
+
const inner: Scope = new Map(scope);
|
|
255
|
+
expression.definitions.forEach((definition) =>
|
|
256
|
+
inner.set(definition.name, { kind: "Let", definition, scope: inner }),
|
|
257
|
+
);
|
|
258
|
+
return inner;
|
|
259
|
+
};
|
|
260
|
+
|
|
261
|
+
const createPlaceholder = (definition: Definition, maxLevel: number, weight: number) => {
|
|
262
|
+
const formals = getFormals(definition);
|
|
263
|
+
return {
|
|
264
|
+
...createData(),
|
|
265
|
+
name: definition.name,
|
|
266
|
+
formals,
|
|
267
|
+
maxLevels: formals.map(() => maxLevel),
|
|
268
|
+
weights: formals.map(() => weight),
|
|
269
|
+
minMaxLevels: formals.map(() => []),
|
|
270
|
+
conditions: new Set<string>(),
|
|
271
|
+
nonLeibniz: new Set<number>(),
|
|
272
|
+
};
|
|
273
|
+
};
|
|
274
|
+
|
|
275
|
+
const getRecursiveSections = (
|
|
276
|
+
base: Scope,
|
|
277
|
+
root: ModuleUnit[] | LetExpression,
|
|
278
|
+
hasRecursiveLet = true,
|
|
279
|
+
) => {
|
|
280
|
+
const sections: RecursiveSection[] = [];
|
|
281
|
+
const pending: Set<string>[] = [];
|
|
282
|
+
const frames: ScopeFrame[] = [];
|
|
283
|
+
const scopes: (Scope | undefined)[] = [];
|
|
284
|
+
let pendingCount = 0;
|
|
285
|
+
let depth = 0;
|
|
286
|
+
|
|
287
|
+
const getScope = () => {
|
|
288
|
+
let start = frames.length;
|
|
289
|
+
while (start > 0 && scopes[start - 1] === undefined) start--;
|
|
290
|
+
let scope = scopes[start - 1] ?? base;
|
|
291
|
+
for (let index = start; index < frames.length; index++) {
|
|
292
|
+
const frame = frames[index];
|
|
293
|
+
scope = Array.isArray(frame)
|
|
294
|
+
? bindFormals(scope, toFormals(frame))
|
|
295
|
+
: frame.kind === "Let"
|
|
296
|
+
? createLetScope(frame, scope)
|
|
297
|
+
: frame.kind === "Function"
|
|
298
|
+
? bindFormals(scope, toFormals(getBoundNames(frame.bounds)))
|
|
299
|
+
: bindFormals(scope, frame.params);
|
|
300
|
+
scopes[index] = scope;
|
|
301
|
+
}
|
|
302
|
+
return scope;
|
|
303
|
+
};
|
|
304
|
+
|
|
305
|
+
const walkInFrame = (frame: ScopeFrame, expression: Expression) => {
|
|
306
|
+
frames.push(frame);
|
|
307
|
+
scopes.push(undefined);
|
|
308
|
+
walkExpression(expression);
|
|
309
|
+
frames.pop();
|
|
310
|
+
scopes.pop();
|
|
311
|
+
};
|
|
312
|
+
|
|
313
|
+
const visitChild = (child: Expression, bound: string[]) =>
|
|
314
|
+
bound.length === 0 ? walkExpression(child) : walkInFrame(bound, child);
|
|
315
|
+
|
|
316
|
+
const walkExpression = (expression: Expression): void => {
|
|
317
|
+
if (expression.kind !== "Let") return forEachChild(expression, visitChild);
|
|
318
|
+
frames.push(expression);
|
|
319
|
+
scopes.push(undefined);
|
|
320
|
+
depth++;
|
|
321
|
+
if (expression.recursive) walkUnits(getLetUnits(expression));
|
|
322
|
+
else {
|
|
323
|
+
for (let index = 0; index < expression.definitions.length; index++) {
|
|
324
|
+
walkDefinition(expression.definitions[index]);
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
depth--;
|
|
328
|
+
walkExpression(expression.body);
|
|
329
|
+
frames.pop();
|
|
330
|
+
scopes.pop();
|
|
331
|
+
};
|
|
332
|
+
|
|
333
|
+
const walkDefinition = (definition: Definition) => {
|
|
334
|
+
if (definition.kind === "Function") {
|
|
335
|
+
for (let index = 0; index < definition.bounds.length; index++) {
|
|
336
|
+
walkExpression(definition.bounds[index].set);
|
|
337
|
+
}
|
|
338
|
+
}
|
|
339
|
+
walkInFrame(definition, definition.body);
|
|
340
|
+
if (pendingCount === 0) return;
|
|
341
|
+
const names = (pending[depth] ??= new Set());
|
|
342
|
+
if (definition.isRecursive && names.delete(definition.name)) {
|
|
343
|
+
pendingCount--;
|
|
344
|
+
return;
|
|
345
|
+
}
|
|
346
|
+
sections.at(-1)?.members.push({ definition, scope: getScope(), isRechecked: names.size > 0 });
|
|
347
|
+
};
|
|
348
|
+
|
|
349
|
+
const declareRecursive = (definitions: Definition[], location: SourceLocation) => {
|
|
350
|
+
if (pendingCount === 0) sections.push({ location, members: [] });
|
|
351
|
+
const names = (pending[depth] ??= new Set());
|
|
352
|
+
definitions.forEach((definition) => {
|
|
353
|
+
if (names.has(definition.name)) return;
|
|
354
|
+
names.add(definition.name);
|
|
355
|
+
pendingCount++;
|
|
356
|
+
});
|
|
357
|
+
definitions.forEach((definition) =>
|
|
358
|
+
sections.at(-1)?.members.push({ definition, scope: getScope(), isRechecked: true }),
|
|
359
|
+
);
|
|
360
|
+
};
|
|
361
|
+
|
|
362
|
+
const walkUnits = (units: ModuleUnit[]) => {
|
|
363
|
+
const recursiveDefinitions = new Map<string, Definition[]>();
|
|
364
|
+
units.forEach((unit) => {
|
|
365
|
+
if (unit.kind !== "Definition" || !unit.definition.isRecursive) return;
|
|
366
|
+
const named = recursiveDefinitions.get(unit.definition.name);
|
|
367
|
+
if (named) named.push(unit.definition);
|
|
368
|
+
else recursiveDefinitions.set(unit.definition.name, [unit.definition]);
|
|
369
|
+
});
|
|
370
|
+
units.forEach((unit) => {
|
|
371
|
+
if (unit.kind === "Recursive") {
|
|
372
|
+
declareRecursive(
|
|
373
|
+
unit.declarations.flatMap(
|
|
374
|
+
(declaration) => recursiveDefinitions.get(declaration.name) ?? [],
|
|
375
|
+
),
|
|
376
|
+
unit.location,
|
|
377
|
+
);
|
|
378
|
+
return;
|
|
379
|
+
}
|
|
380
|
+
if (pendingCount === 0 && !hasRecursiveLet) return;
|
|
381
|
+
if (unit.kind === "Assumption") walkExpression(unit.assumption.expression);
|
|
382
|
+
else if (unit.kind === "Theorem" && unit.theorem.statement.kind !== "AssumeProve") {
|
|
383
|
+
walkExpression(unit.theorem.statement);
|
|
384
|
+
} else if (unit.kind === "Definition") walkDefinition(unit.definition);
|
|
385
|
+
});
|
|
386
|
+
};
|
|
387
|
+
|
|
388
|
+
if (Array.isArray(root)) walkUnits(root);
|
|
389
|
+
else walkExpression(root);
|
|
390
|
+
return sections;
|
|
391
|
+
};
|
|
392
|
+
|
|
393
|
+
const getLetUnits = (expression: LetExpression) =>
|
|
394
|
+
[
|
|
395
|
+
...(expression.recursive ?? []).map((declaration) => ({
|
|
396
|
+
location: declaration.location,
|
|
397
|
+
unit: {
|
|
398
|
+
kind: "Recursive",
|
|
399
|
+
declarations: [declaration],
|
|
400
|
+
location: declaration.location,
|
|
401
|
+
} satisfies ModuleUnit,
|
|
402
|
+
})),
|
|
403
|
+
...expression.definitions.map((definition) => ({
|
|
404
|
+
location: definition.location,
|
|
405
|
+
unit: { kind: "Definition", definition } satisfies ModuleUnit,
|
|
406
|
+
})),
|
|
407
|
+
]
|
|
408
|
+
.toSorted((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
409
|
+
.map((entry) => entry.unit);
|
|
193
410
|
|
|
194
411
|
const LOGICAL_OPERATORS = new Set(["/\\", "\\/", "=>", "<=>"]);
|
|
195
412
|
|
|
413
|
+
const isMixed = (levels: number[]) =>
|
|
414
|
+
levels.includes(ACTION_LEVEL) && levels.includes(TEMPORAL_LEVEL);
|
|
415
|
+
|
|
416
|
+
const getWrittenRange = (expression: Expression) =>
|
|
417
|
+
parenthesizedRanges.get(expression) ?? expression.location.range;
|
|
418
|
+
|
|
196
419
|
const isOperatorApplication = (expression: Expression) =>
|
|
197
420
|
expression.kind !== "Let" && expression.kind !== "Label";
|
|
198
421
|
|
|
199
422
|
export const createLevelAnalyzer = (context: LevelContext) => {
|
|
200
423
|
const definitionLevels = new Map<Definition, OperatorLevels>();
|
|
424
|
+
const selectionLevels = new Map<Expression, LevelData>();
|
|
425
|
+
const errors: SanyError[] = [];
|
|
426
|
+
const messages: string[] = [];
|
|
201
427
|
|
|
202
428
|
const resolve = (name: string, scope: Scope): Resolved => {
|
|
203
429
|
const entry = scope.get(name);
|
|
204
430
|
if (entry?.kind === "Formal") {
|
|
205
|
-
return { kind: "Declared", name, level:
|
|
431
|
+
return { kind: "Declared", name, level: entry.level, arity: entry.arity };
|
|
206
432
|
}
|
|
207
433
|
if (entry?.kind === "Let") {
|
|
208
434
|
return { kind: "Defined", levels: analyzeDefinition(entry.definition, entry.scope) };
|
|
@@ -225,18 +451,15 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
225
451
|
|
|
226
452
|
const applyDeclared = (name: string, level: number, operands: Operand[]) => {
|
|
227
453
|
const data = createData(Math.max(level, ...operands.map((operand) => operand.data.level)));
|
|
454
|
+
data.isCorrect = operands.every((operand) => operand.data.isCorrect);
|
|
228
455
|
data.params.add(name);
|
|
229
456
|
operands.forEach((operand, index) => {
|
|
230
457
|
operand.data.params.forEach((param) => {
|
|
231
458
|
data.params.add(param);
|
|
232
459
|
data.argParams.add(getArgumentParamKey(name, index, param));
|
|
233
460
|
});
|
|
234
|
-
operand.data.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
|
|
235
461
|
putArgConstraint(data.argConstraints, getArgumentKey(name, index), operand.data.level);
|
|
236
|
-
operand.data
|
|
237
|
-
putArgConstraint(data.argConstraints, key, value),
|
|
238
|
-
);
|
|
239
|
-
operand.data.argParams.forEach((key) => data.argParams.add(key));
|
|
462
|
+
mergeConstraints(data, operand.data);
|
|
240
463
|
});
|
|
241
464
|
return data;
|
|
242
465
|
};
|
|
@@ -248,19 +471,18 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
248
471
|
bound: string[] = [],
|
|
249
472
|
) => {
|
|
250
473
|
const isBound = (name: string) => bound.includes(name);
|
|
251
|
-
operands.
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
474
|
+
const exceeding = operands.flatMap((operand, index) =>
|
|
475
|
+
operand.kind === "Value" && operand.data.level > getMaxLevel(operator, index)
|
|
476
|
+
? [{ operand, index }]
|
|
477
|
+
: [],
|
|
478
|
+
);
|
|
479
|
+
exceeding
|
|
480
|
+
.filter((entry) => operator.isCorrect && entry.operand.data.isCorrect)
|
|
481
|
+
.forEach((entry) =>
|
|
482
|
+
messages.push(
|
|
483
|
+
`Level error in applying operator ${resolveSynonym(operator.name)}:\nThe level of argument ${entry.index + 1} exceeds the maximum level allowed by the operator`,
|
|
484
|
+
),
|
|
262
485
|
);
|
|
263
|
-
}
|
|
264
486
|
const getOperand = (formal: string) => {
|
|
265
487
|
const index = operator.formals.findIndex((param) => param.name === formal);
|
|
266
488
|
return index === -1 ? undefined : operands[index];
|
|
@@ -276,6 +498,10 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
276
498
|
...ranges.map((range) => range.level),
|
|
277
499
|
),
|
|
278
500
|
);
|
|
501
|
+
data.isCorrect =
|
|
502
|
+
exceeding.length === 0 &&
|
|
503
|
+
operands.every((operand) => operand.data.isCorrect) &&
|
|
504
|
+
ranges.every((range) => range.isCorrect);
|
|
279
505
|
operator.params.forEach((param) => data.params.add(param));
|
|
280
506
|
operands.forEach((operand, index) => {
|
|
281
507
|
if (getWeight(operator, index) === 1) {
|
|
@@ -300,8 +526,8 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
300
526
|
}),
|
|
301
527
|
);
|
|
302
528
|
operands.forEach((operand, operandIndex) => {
|
|
303
|
-
|
|
304
|
-
|
|
529
|
+
if (operand.kind !== "Operator") return;
|
|
530
|
+
const argument = operand.data;
|
|
305
531
|
operands.forEach((other, otherIndex) =>
|
|
306
532
|
argument.formals.forEach((_formal, argumentIndex) => {
|
|
307
533
|
if (!hasCondition(operandIndex, otherIndex, argumentIndex)) return;
|
|
@@ -313,9 +539,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
313
539
|
});
|
|
314
540
|
operator.argParams.forEach((key) => {
|
|
315
541
|
const parameter = parseArgumentParamKey(key);
|
|
316
|
-
const argument = getOperand(parameter.operator)
|
|
317
|
-
if (argument) {
|
|
318
|
-
putConstraint(
|
|
542
|
+
const argument = getOperand(parameter.operator);
|
|
543
|
+
if (argument?.kind === "Operator") {
|
|
544
|
+
putConstraint(
|
|
545
|
+
data.constraints,
|
|
546
|
+
parameter.param,
|
|
547
|
+
getMaxLevel(argument.data, parameter.index),
|
|
548
|
+
);
|
|
319
549
|
}
|
|
320
550
|
});
|
|
321
551
|
|
|
@@ -328,8 +558,8 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
328
558
|
constraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value)),
|
|
329
559
|
);
|
|
330
560
|
operands.forEach((operand, operandIndex) => {
|
|
561
|
+
if (operand.kind !== "Declared") return;
|
|
331
562
|
const declared = operand.declared;
|
|
332
|
-
if (!declared) return;
|
|
333
563
|
Array.from({ length: declared.arity }, (_value, argumentIndex) =>
|
|
334
564
|
putArgConstraint(
|
|
335
565
|
data.argConstraints,
|
|
@@ -381,15 +611,15 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
381
611
|
);
|
|
382
612
|
return;
|
|
383
613
|
}
|
|
384
|
-
if (argument.
|
|
614
|
+
if (argument.kind === "Declared") {
|
|
385
615
|
data.argParams.add(
|
|
386
616
|
getArgumentParamKey(argument.declared.name, parameter.index, parameter.param),
|
|
387
617
|
);
|
|
388
618
|
}
|
|
389
619
|
});
|
|
390
620
|
operands.forEach((operand, operandIndex) => {
|
|
621
|
+
if (operand.kind !== "Declared") return;
|
|
391
622
|
const declared = operand.declared;
|
|
392
|
-
if (!declared) return;
|
|
393
623
|
operands.forEach((other, otherIndex) =>
|
|
394
624
|
Array.from({ length: declared.arity }, (_value, argumentIndex) => {
|
|
395
625
|
if (!hasCondition(operandIndex, otherIndex, argumentIndex)) return;
|
|
@@ -410,7 +640,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
410
640
|
expression.body,
|
|
411
641
|
scope,
|
|
412
642
|
);
|
|
413
|
-
return {
|
|
643
|
+
return { kind: "Operator", data: operator };
|
|
414
644
|
}
|
|
415
645
|
const name =
|
|
416
646
|
expression.kind === "OperatorReference"
|
|
@@ -424,16 +654,16 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
424
654
|
resolved.kind === "Defined" &&
|
|
425
655
|
(resolved.levels.formals.length > 0 || expression.kind === "OperatorReference")
|
|
426
656
|
) {
|
|
427
|
-
return {
|
|
657
|
+
return { kind: "Operator", data: resolved.levels };
|
|
428
658
|
}
|
|
429
659
|
if (resolved.kind === "Declared" && resolved.arity > 0) {
|
|
430
660
|
const data = createData();
|
|
431
661
|
data.params.add(name);
|
|
432
|
-
return { data, declared: { name, arity: resolved.arity } };
|
|
662
|
+
return { kind: "Declared", data, declared: { name, arity: resolved.arity } };
|
|
433
663
|
}
|
|
434
|
-
if (expression.kind === "OperatorReference") return { data: createData() };
|
|
664
|
+
if (expression.kind === "OperatorReference") return { kind: "Value", data: createData() };
|
|
435
665
|
}
|
|
436
|
-
return { data: analyze(expression, scope) };
|
|
666
|
+
return { kind: "Value", data: analyze(expression, scope) };
|
|
437
667
|
};
|
|
438
668
|
|
|
439
669
|
const toOperands = (expressions: Expression[], scope: Scope) =>
|
|
@@ -443,16 +673,23 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
443
673
|
operator: OperatorLevels,
|
|
444
674
|
expressions: Expression[],
|
|
445
675
|
scope: Scope,
|
|
446
|
-
|
|
447
|
-
bound
|
|
676
|
+
bounds: Bound[] = [],
|
|
677
|
+
bound = getBoundNames(bounds),
|
|
448
678
|
) => {
|
|
449
|
-
const
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
679
|
+
const operands = toOperands(expressions, bindFormals(scope, toFormals(bound)));
|
|
680
|
+
const ranges = bounds.map((range) => analyze(range.set, scope));
|
|
681
|
+
const data = applyDefined(operator, operands, ranges, bound);
|
|
682
|
+
ranges.forEach((range, index) => {
|
|
683
|
+
if (range.level <= ACTION_LEVEL) return;
|
|
684
|
+
data.isCorrect = false;
|
|
685
|
+
if (!range.isCorrect) return;
|
|
686
|
+
const pattern = bounds[index].pattern;
|
|
687
|
+
const symbol = pattern.ranges?.[0];
|
|
688
|
+
messages.push(
|
|
689
|
+
`Level error in applying operator ${operator.name}:\nThe level of the range for the bounded variable ${symbol ? formatRange(symbol) : getPatternNames(pattern)[0]} \nexceeds the maximum level allowed by the operator`,
|
|
690
|
+
);
|
|
691
|
+
});
|
|
692
|
+
return data;
|
|
456
693
|
};
|
|
457
694
|
|
|
458
695
|
const applyResolved = (resolved: Resolved, operands: Operand[]) =>
|
|
@@ -460,25 +697,21 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
460
697
|
? applyDeclared(resolved.name, resolved.level, operands)
|
|
461
698
|
: applyDefined(resolved.levels, operands);
|
|
462
699
|
|
|
463
|
-
const checkJunction = (
|
|
464
|
-
|
|
465
|
-
if (levels.includes(ACTION_LEVEL) && levels.includes(TEMPORAL_LEVEL)) {
|
|
466
|
-
throw createLevelError(
|
|
467
|
-
"Formula has both temporal formula and action as arguments",
|
|
468
|
-
expression,
|
|
469
|
-
);
|
|
470
|
-
}
|
|
700
|
+
const checkJunction = (levels: number[], name: string) => {
|
|
701
|
+
if (isMixed(levels)) messages.push(`${name} has both temporal formula and action as arguments`);
|
|
471
702
|
};
|
|
472
703
|
|
|
473
704
|
const checkApply = (expression: Expression & { kind: "Apply" }, operands: Operand[]) => {
|
|
474
705
|
const isLeadsTo = expression.operator === "~>" || expression.operator === "-+->";
|
|
475
706
|
if (isLeadsTo && operands.some((operand) => operand.data.level === ACTION_LEVEL)) {
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
707
|
+
messages.push("Action used where only temporal formula or state predicate allowed");
|
|
708
|
+
}
|
|
709
|
+
if (LOGICAL_OPERATORS.has(expression.operator)) {
|
|
710
|
+
checkJunction(
|
|
711
|
+
operands.map((operand) => operand.data.level),
|
|
712
|
+
resolveSynonym(expression.operator),
|
|
479
713
|
);
|
|
480
714
|
}
|
|
481
|
-
if (LOGICAL_OPERATORS.has(expression.operator)) checkJunction(operands, expression);
|
|
482
715
|
};
|
|
483
716
|
|
|
484
717
|
const checkTemporal = (
|
|
@@ -488,45 +721,56 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
488
721
|
const operand = expression.expression;
|
|
489
722
|
const form = expression.kind === "Always" ? "BoxAction" : "AngleAction";
|
|
490
723
|
if (level !== ACTION_LEVEL || !isOperatorApplication(operand) || operand.kind === form) return;
|
|
491
|
-
|
|
724
|
+
messages.push(
|
|
492
725
|
expression.kind === "Always"
|
|
493
726
|
? "[] followed by action not of form [A]_v"
|
|
494
727
|
: "<> followed by action not of form <<A>>_v",
|
|
495
|
-
expression,
|
|
496
728
|
);
|
|
497
729
|
};
|
|
498
730
|
|
|
499
|
-
const analyzeLet = (expression:
|
|
500
|
-
const inner =
|
|
501
|
-
expression.
|
|
502
|
-
|
|
731
|
+
const analyzeLet = (expression: LetExpression, scope: Scope) => {
|
|
732
|
+
const inner = createLetScope(expression, scope);
|
|
733
|
+
if (expression.recursive) {
|
|
734
|
+
getRecursiveSections(scope, expression).forEach((section) =>
|
|
735
|
+
checkRecursiveSection(section.members),
|
|
736
|
+
);
|
|
737
|
+
}
|
|
738
|
+
const definitions = expression.definitions.map((definition) =>
|
|
739
|
+
analyzeDefinition(definition, inner),
|
|
503
740
|
);
|
|
504
741
|
const body = analyze(expression.body, inner);
|
|
505
742
|
const data = {
|
|
506
743
|
level: body.level,
|
|
744
|
+
isCorrect: body.isCorrect && definitions.every((levels) => levels.isCorrect),
|
|
507
745
|
params: new Set(body.params),
|
|
508
746
|
constraints: new Map(body.constraints),
|
|
509
747
|
argConstraints: new Map(body.argConstraints),
|
|
510
748
|
argParams: new Set(body.argParams),
|
|
511
749
|
};
|
|
512
|
-
|
|
513
|
-
const levels = analyzeDefinition(definition, inner);
|
|
514
|
-
levels.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
|
|
515
|
-
levels.argConstraints.forEach((value, key) =>
|
|
516
|
-
putArgConstraint(data.argConstraints, key, value),
|
|
517
|
-
);
|
|
518
|
-
levels.argParams.forEach((key) => data.argParams.add(key));
|
|
519
|
-
});
|
|
750
|
+
definitions.forEach((levels) => mergeConstraints(data, levels));
|
|
520
751
|
return data;
|
|
521
752
|
};
|
|
522
753
|
|
|
523
|
-
const
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
754
|
+
const reportSince = (start: number, range: SourceRange | undefined, data: LevelData) => {
|
|
755
|
+
if (messages.length === start) return data;
|
|
756
|
+
if (range) {
|
|
757
|
+
messages
|
|
758
|
+
.splice(start)
|
|
759
|
+
.forEach((message) =>
|
|
760
|
+
errors.push({ location: formatRange(range), message: `${message}.` }),
|
|
761
|
+
);
|
|
529
762
|
}
|
|
763
|
+
return { ...data, isCorrect: false };
|
|
764
|
+
};
|
|
765
|
+
|
|
766
|
+
const reportAt = (range: SourceRange | undefined, getData: () => LevelData) => {
|
|
767
|
+
const start = messages.length;
|
|
768
|
+
return reportSince(start, range, getData());
|
|
769
|
+
};
|
|
770
|
+
|
|
771
|
+
const analyze = (expression: Expression, scope: Scope) => {
|
|
772
|
+
const start = messages.length;
|
|
773
|
+
return reportSince(start, expression.location.range, analyzeNode(expression, scope));
|
|
530
774
|
};
|
|
531
775
|
|
|
532
776
|
const analyzeNode = (expression: Expression, scope: Scope): LevelData => {
|
|
@@ -548,30 +792,65 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
548
792
|
return toOperand(expression, scope).data;
|
|
549
793
|
case "And":
|
|
550
794
|
case "Or": {
|
|
551
|
-
const
|
|
552
|
-
|
|
553
|
-
|
|
795
|
+
const isAnd = expression.kind === "And";
|
|
796
|
+
if (expression.isBulleted) {
|
|
797
|
+
const operands = toOperands(expression.operands, scope);
|
|
798
|
+
checkJunction(
|
|
799
|
+
operands.map((operand) => operand.data.level),
|
|
800
|
+
`${isAnd ? "Conjunction" : "Disjunction"} list`,
|
|
801
|
+
);
|
|
802
|
+
return applyDefined(isAnd ? AND_LEVELS : OR_LEVELS, operands);
|
|
803
|
+
}
|
|
804
|
+
// SANY nests a chain of infix /\ or \/ to the left, so it checks each prefix of the chain.
|
|
805
|
+
const name = isAnd ? "\\land" : "\\lor";
|
|
806
|
+
const start = getWrittenRange(expression.operands[0]);
|
|
807
|
+
const operands: Operand[] = [];
|
|
808
|
+
let prefixLevel = CONSTANT_LEVEL;
|
|
809
|
+
let isPrefixMixed = false;
|
|
810
|
+
expression.operands.forEach((operand, index) => {
|
|
811
|
+
const analyzed = toOperand(operand, scope);
|
|
812
|
+
operands.push(analyzed);
|
|
813
|
+
const levels = [prefixLevel, analyzed.data.level];
|
|
814
|
+
prefixLevel = Math.max(prefixLevel, analyzed.data.level);
|
|
815
|
+
if (index === 0) return;
|
|
816
|
+
const end = getWrittenRange(operand);
|
|
817
|
+
if (index === expression.operands.length - 1 || !start || !end) {
|
|
818
|
+
checkJunction(levels, name);
|
|
819
|
+
return;
|
|
820
|
+
}
|
|
821
|
+
if (!isMixed(levels)) return;
|
|
822
|
+
errors.push({
|
|
823
|
+
location: formatRange({ ...start, end: end.end }),
|
|
824
|
+
message: `${name} has both temporal formula and action as arguments.`,
|
|
825
|
+
});
|
|
826
|
+
isPrefixMixed = true;
|
|
827
|
+
});
|
|
828
|
+
const data = applyDefined(isAnd ? AND_LEVELS : OR_LEVELS, operands);
|
|
829
|
+
return isPrefixMixed ? { ...data, isCorrect: false } : data;
|
|
554
830
|
}
|
|
555
831
|
case "Prime":
|
|
556
|
-
case "Unchanged":
|
|
557
832
|
return applyBuiltin(PRIME_LEVELS, [expression.expression], scope);
|
|
833
|
+
case "Unchanged":
|
|
834
|
+
return applyBuiltin(UNCHANGED_LEVELS, [expression.expression], scope);
|
|
558
835
|
case "Enabled":
|
|
559
836
|
return applyBuiltin(ENABLED_LEVELS, [expression.expression], scope);
|
|
560
837
|
case "Always":
|
|
561
838
|
case "Eventually": {
|
|
562
839
|
const operand = toOperand(expression.expression, scope);
|
|
563
840
|
checkTemporal(expression, operand.data.level);
|
|
564
|
-
return applyDefined(
|
|
841
|
+
return applyDefined(expression.kind === "Always" ? ALWAYS_LEVELS : EVENTUALLY_LEVELS, [
|
|
842
|
+
operand,
|
|
843
|
+
]);
|
|
565
844
|
}
|
|
566
845
|
case "If":
|
|
567
846
|
return applyBuiltin(
|
|
568
|
-
|
|
847
|
+
IF_LEVELS,
|
|
569
848
|
[expression.condition, expression.consequent, expression.alternative],
|
|
570
849
|
scope,
|
|
571
850
|
);
|
|
572
851
|
case "Case":
|
|
573
852
|
return applyBuiltin(
|
|
574
|
-
|
|
853
|
+
CASE_LEVELS,
|
|
575
854
|
[
|
|
576
855
|
...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
|
|
577
856
|
...(expression.other ? [expression.other] : []),
|
|
@@ -583,27 +862,33 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
583
862
|
case "Forall":
|
|
584
863
|
case "Exists": {
|
|
585
864
|
const data = applyBuiltin(
|
|
586
|
-
|
|
865
|
+
expression.kind === "Forall" ? FORALL_LEVELS : EXISTS_LEVELS,
|
|
587
866
|
[expression.body],
|
|
588
867
|
scope,
|
|
589
|
-
expression.bounds
|
|
590
|
-
getBoundNames(expression.bounds),
|
|
868
|
+
expression.bounds,
|
|
591
869
|
);
|
|
592
870
|
const actionBound =
|
|
593
871
|
data.level === TEMPORAL_LEVEL
|
|
594
872
|
? expression.bounds.find((bound) => analyze(bound.set, scope).level === ACTION_LEVEL)
|
|
595
873
|
: undefined;
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
874
|
+
const range = actionBound?.set.location.range;
|
|
875
|
+
if (range) {
|
|
876
|
+
errors.push({
|
|
877
|
+
location: formatRange(range),
|
|
878
|
+
message: "Action-level bound of quantified temporal formula.",
|
|
879
|
+
});
|
|
601
880
|
}
|
|
602
|
-
return data;
|
|
881
|
+
return actionBound ? { ...data, isCorrect: false } : data;
|
|
603
882
|
}
|
|
604
883
|
case "UnboundedQuantifier":
|
|
605
884
|
return applyBuiltin(
|
|
606
|
-
expression.isTemporal
|
|
885
|
+
expression.isTemporal
|
|
886
|
+
? expression.quantifier === "Forall"
|
|
887
|
+
? TEMPORAL_FORALL_LEVELS
|
|
888
|
+
: TEMPORAL_EXISTS_LEVELS
|
|
889
|
+
: expression.quantifier === "Forall"
|
|
890
|
+
? UNBOUNDED_FORALL_LEVELS
|
|
891
|
+
: UNBOUNDED_EXISTS_LEVELS,
|
|
607
892
|
[expression.body],
|
|
608
893
|
scope,
|
|
609
894
|
[],
|
|
@@ -611,95 +896,106 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
611
896
|
);
|
|
612
897
|
case "Choose":
|
|
613
898
|
return applyBuiltin(
|
|
614
|
-
|
|
899
|
+
expression.set ? BOUNDED_CHOOSE_LEVELS : UNBOUNDED_CHOOSE_LEVELS,
|
|
615
900
|
[expression.body],
|
|
616
901
|
scope,
|
|
617
|
-
expression.set ? [expression.set] : [],
|
|
902
|
+
expression.set ? [{ pattern: expression.pattern, set: expression.set }] : [],
|
|
618
903
|
getPatternNames(expression.pattern),
|
|
619
904
|
);
|
|
620
905
|
case "SetEnumeration":
|
|
906
|
+
return applyBuiltin(SET_ENUMERATE_LEVELS, expression.elements, scope);
|
|
621
907
|
case "Tuple":
|
|
908
|
+
return applyBuiltin(TUPLE_LEVELS, expression.elements, scope);
|
|
622
909
|
case "FunctionSet":
|
|
910
|
+
return applyBuiltin(SET_OF_FCNS_LEVELS, [expression.domain, expression.range], scope);
|
|
623
911
|
case "Product":
|
|
624
|
-
return applyBuiltin(
|
|
625
|
-
SET_LEVELS,
|
|
626
|
-
expression.kind === "FunctionSet"
|
|
627
|
-
? [expression.domain, expression.range]
|
|
628
|
-
: expression.kind === "Product"
|
|
629
|
-
? expression.factors
|
|
630
|
-
: expression.elements,
|
|
631
|
-
scope,
|
|
632
|
-
);
|
|
912
|
+
return applyBuiltin(CARTESIAN_PROD_LEVELS, expression.factors, scope);
|
|
633
913
|
case "SetFilter":
|
|
634
|
-
return applyBuiltin(
|
|
635
|
-
SET_LEVELS,
|
|
636
|
-
[expression.predicate],
|
|
637
|
-
scope,
|
|
638
|
-
[expression.bound.set],
|
|
639
|
-
getPatternNames(expression.bound.pattern),
|
|
640
|
-
);
|
|
914
|
+
return applyBuiltin(SUBSET_OF_LEVELS, [expression.predicate], scope, [expression.bound]);
|
|
641
915
|
case "SetMap":
|
|
642
|
-
return applyBuiltin(
|
|
643
|
-
SET_LEVELS,
|
|
644
|
-
[expression.expression],
|
|
645
|
-
scope,
|
|
646
|
-
expression.bounds.map((bound) => bound.set),
|
|
647
|
-
getBoundNames(expression.bounds),
|
|
648
|
-
);
|
|
916
|
+
return applyBuiltin(SET_OF_ALL_LEVELS, [expression.expression], scope, expression.bounds);
|
|
649
917
|
case "FunctionConstruction":
|
|
650
|
-
return applyBuiltin(
|
|
651
|
-
FUNCTION_LEVELS,
|
|
652
|
-
[expression.body],
|
|
653
|
-
scope,
|
|
654
|
-
expression.bounds.map((bound) => bound.set),
|
|
655
|
-
getBoundNames(expression.bounds),
|
|
656
|
-
);
|
|
918
|
+
return applyBuiltin(FCN_CONSTRUCTOR_LEVELS, [expression.body], scope, expression.bounds);
|
|
657
919
|
case "Record":
|
|
658
920
|
return applyBuiltin(
|
|
659
|
-
|
|
921
|
+
RCD_CONSTRUCTOR_LEVELS,
|
|
660
922
|
expression.fields.map((field) => field.value),
|
|
661
923
|
scope,
|
|
662
924
|
);
|
|
663
925
|
case "RecordSet":
|
|
664
926
|
return applyBuiltin(
|
|
665
|
-
|
|
927
|
+
SET_OF_RCDS_LEVELS,
|
|
666
928
|
expression.fields.map((field) => field.value),
|
|
667
929
|
scope,
|
|
668
930
|
);
|
|
669
931
|
case "Except":
|
|
670
|
-
return
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
932
|
+
return applyDefined(EXCEPT_LEVELS, [
|
|
933
|
+
toOperand(expression.function, scope),
|
|
934
|
+
...expression.updates.map((update): Operand => ({
|
|
935
|
+
kind: "Value",
|
|
936
|
+
data: applyDefined(PAIR_LEVELS, [
|
|
937
|
+
{
|
|
938
|
+
kind: "Value",
|
|
939
|
+
data: reportAt(update.range, () =>
|
|
940
|
+
applyDefined(
|
|
941
|
+
SEQ_LEVELS,
|
|
942
|
+
update.path.map((step): Operand =>
|
|
943
|
+
step.kind === "Field"
|
|
944
|
+
? { kind: "Value", data: createData() }
|
|
945
|
+
: step.args.length === 1
|
|
946
|
+
? toOperand(step.args[0], scope)
|
|
947
|
+
: {
|
|
948
|
+
kind: "Value",
|
|
949
|
+
data: reportAt(step.tupleRange, () =>
|
|
950
|
+
applyBuiltin(TUPLE_LEVELS, step.args, scope),
|
|
951
|
+
),
|
|
952
|
+
},
|
|
953
|
+
),
|
|
954
|
+
),
|
|
955
|
+
),
|
|
956
|
+
},
|
|
957
|
+
toOperand(update.value, scope),
|
|
677
958
|
]),
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
);
|
|
959
|
+
})),
|
|
960
|
+
]);
|
|
681
961
|
case "FunctionApplication":
|
|
682
962
|
return applyDefined(APPLY_LEVELS, [
|
|
683
963
|
toOperand(expression.function, scope),
|
|
684
964
|
expression.args.length === 1
|
|
685
965
|
? toOperand(expression.args[0], scope)
|
|
686
|
-
: { data: applyBuiltin(
|
|
966
|
+
: { kind: "Value", data: applyBuiltin(TUPLE_LEVELS, expression.args, scope) },
|
|
687
967
|
]);
|
|
688
968
|
case "Bracket":
|
|
689
969
|
return createData();
|
|
690
970
|
case "FieldAccess":
|
|
691
971
|
return applyDefined(SELECT_LEVELS, [
|
|
692
972
|
toOperand(expression.record, scope),
|
|
693
|
-
{ data: createData() },
|
|
973
|
+
{ kind: "Value", data: createData() },
|
|
694
974
|
]);
|
|
695
975
|
case "BoxAction":
|
|
696
976
|
case "AngleAction":
|
|
697
|
-
return applyBuiltin(
|
|
977
|
+
return applyBuiltin(
|
|
978
|
+
expression.kind === "BoxAction" ? SQUARE_ACT_LEVELS : ANGLE_ACT_LEVELS,
|
|
979
|
+
[expression.action, expression.subscript],
|
|
980
|
+
scope,
|
|
981
|
+
);
|
|
698
982
|
case "WeakFairness":
|
|
699
983
|
case "StrongFairness":
|
|
700
|
-
return applyBuiltin(
|
|
984
|
+
return applyBuiltin(
|
|
985
|
+
expression.kind === "WeakFairness" ? WF_LEVELS : SF_LEVELS,
|
|
986
|
+
[expression.subscript, expression.action],
|
|
987
|
+
scope,
|
|
988
|
+
);
|
|
701
989
|
case "Label":
|
|
702
990
|
return analyze(expression.body, scope);
|
|
991
|
+
case "Selection": {
|
|
992
|
+
const selected = expression.expression;
|
|
993
|
+
const known = selectionLevels.get(selected);
|
|
994
|
+
if (known) return known;
|
|
995
|
+
const data = analyze(selected, scope);
|
|
996
|
+
selectionLevels.set(selected, data);
|
|
997
|
+
return data;
|
|
998
|
+
}
|
|
703
999
|
case "Subexpression":
|
|
704
1000
|
return createData();
|
|
705
1001
|
}
|
|
@@ -733,6 +1029,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
733
1029
|
return names;
|
|
734
1030
|
case "Lambda":
|
|
735
1031
|
case "Let":
|
|
1032
|
+
case "Selection":
|
|
736
1033
|
return names;
|
|
737
1034
|
case "Prime":
|
|
738
1035
|
case "Unchanged":
|
|
@@ -753,10 +1050,9 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
753
1050
|
);
|
|
754
1051
|
return names;
|
|
755
1052
|
default:
|
|
756
|
-
|
|
757
|
-
visit(child, isNonLeibniz, bindFormals(scope, toFormals(bound)))
|
|
758
|
-
|
|
759
|
-
});
|
|
1053
|
+
forEachChild(expression, (child, bound) =>
|
|
1054
|
+
visit(child, isNonLeibniz, bindFormals(scope, toFormals(bound))),
|
|
1055
|
+
);
|
|
760
1056
|
return names;
|
|
761
1057
|
}
|
|
762
1058
|
};
|
|
@@ -770,9 +1066,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
770
1066
|
const inner = bindFormals(scope, formals);
|
|
771
1067
|
const data = analyze(body, inner);
|
|
772
1068
|
const isFormal = (param: string) => formals.some((formal) => formal.name === param);
|
|
773
|
-
const nonLeibnizNames = getNonLeibnizNames(
|
|
1069
|
+
const nonLeibnizNames = getNonLeibnizNames(
|
|
1070
|
+
body.kind === "Selection" ? body.expression : body,
|
|
1071
|
+
inner,
|
|
1072
|
+
);
|
|
774
1073
|
const levels: OperatorLevels = {
|
|
775
1074
|
...createData(data.level),
|
|
1075
|
+
isCorrect: data.isCorrect,
|
|
776
1076
|
name,
|
|
777
1077
|
formals,
|
|
778
1078
|
nonLeibniz: new Set(
|
|
@@ -816,35 +1116,87 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
816
1116
|
return levels;
|
|
817
1117
|
};
|
|
818
1118
|
|
|
1119
|
+
const staleDefinitions = new Set<Definition>();
|
|
1120
|
+
|
|
819
1121
|
const analyzeDefinition = (definition: Definition, scope: Scope): OperatorLevels => {
|
|
820
1122
|
const cached = definitionLevels.get(definition);
|
|
821
|
-
if (cached) return cached;
|
|
822
|
-
const
|
|
823
|
-
definitionLevels.set(definition,
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
1123
|
+
if (cached && !staleDefinitions.delete(definition)) return cached;
|
|
1124
|
+
const prior = cached ?? createPlaceholder(definition, TEMPORAL_LEVEL, 0);
|
|
1125
|
+
definitionLevels.set(definition, prior);
|
|
1126
|
+
const levels = analyzeOperator(
|
|
1127
|
+
definition.name,
|
|
1128
|
+
getFormals(definition),
|
|
1129
|
+
getDefinitionBody(definition),
|
|
1130
|
+
scope,
|
|
1131
|
+
);
|
|
1132
|
+
const merged = {
|
|
1133
|
+
...levels,
|
|
1134
|
+
level: Math.max(prior.level, levels.level),
|
|
1135
|
+
params: new Set([...prior.params, ...levels.params]),
|
|
1136
|
+
argParams: new Set([...prior.argParams, ...levels.argParams]),
|
|
1137
|
+
maxLevels: levels.maxLevels.map((level, index) => Math.min(level, prior.maxLevels[index])),
|
|
1138
|
+
weights: levels.weights.map((weight, index) => Math.max(weight, prior.weights[index])),
|
|
1139
|
+
nonLeibniz: new Set([...prior.nonLeibniz, ...levels.nonLeibniz]),
|
|
1140
|
+
};
|
|
1141
|
+
definitionLevels.set(definition, merged);
|
|
1142
|
+
return merged;
|
|
1143
|
+
};
|
|
1144
|
+
|
|
1145
|
+
const checkPrimedArguments = (members: SectionMember[]) =>
|
|
1146
|
+
members.forEach((member) => {
|
|
1147
|
+
const range = member.definition.location.range;
|
|
1148
|
+
if (!member.definition.isRecursive || !range) return;
|
|
1149
|
+
analyzeDefinition(member.definition, member.scope).maxLevels.forEach((level, index) => {
|
|
1150
|
+
if (level >= ACTION_LEVEL) return;
|
|
1151
|
+
errors.push({
|
|
1152
|
+
location: formatRange(range),
|
|
1153
|
+
message: `Argument ${index + 1} of recursive operator ${resolveSynonym(member.definition.name)} is primed`,
|
|
1154
|
+
});
|
|
1155
|
+
});
|
|
832
1156
|
});
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
1157
|
+
|
|
1158
|
+
const checkRecursiveSection = (members: SectionMember[]) => {
|
|
1159
|
+
if (members.length === 0 || definitionLevels.has(members[0].definition)) return;
|
|
1160
|
+
const recursive = members.filter((member) => member.definition.isRecursive);
|
|
1161
|
+
recursive.forEach((member) =>
|
|
1162
|
+
definitionLevels.set(
|
|
1163
|
+
member.definition,
|
|
1164
|
+
createPlaceholder(member.definition, ACTION_LEVEL, 1),
|
|
1165
|
+
),
|
|
1166
|
+
);
|
|
1167
|
+
const recheck = (member: SectionMember) => {
|
|
1168
|
+
if (member.definition.isRecursive) staleDefinitions.add(member.definition);
|
|
1169
|
+
return analyzeDefinition(member.definition, member.scope);
|
|
1170
|
+
};
|
|
1171
|
+
members.forEach((member) => {
|
|
1172
|
+
recheck(member);
|
|
1173
|
+
checkPrimedArguments([member]);
|
|
1174
|
+
});
|
|
1175
|
+
const firstPass = recursive.map((member) => analyzeDefinition(member.definition, member.scope));
|
|
1176
|
+
const level = Math.max(CONSTANT_LEVEL, ...firstPass.map((levels) => levels.level));
|
|
1177
|
+
const params = firstPass.flatMap((levels) => [...levels.params]);
|
|
1178
|
+
members.forEach((member) => {
|
|
1179
|
+
const levels = analyzeDefinition(member.definition, member.scope);
|
|
1180
|
+
definitionLevels.set(member.definition, {
|
|
1181
|
+
...levels,
|
|
1182
|
+
level: Math.max(levels.level, level),
|
|
1183
|
+
params: new Set([...levels.params, ...params]),
|
|
1184
|
+
});
|
|
1185
|
+
if (member.isRechecked && !member.definition.isRecursive) {
|
|
1186
|
+
staleDefinitions.add(member.definition);
|
|
1187
|
+
}
|
|
1188
|
+
});
|
|
1189
|
+
members.forEach(recheck);
|
|
845
1190
|
};
|
|
846
1191
|
|
|
847
|
-
return {
|
|
1192
|
+
return {
|
|
1193
|
+
analyze,
|
|
1194
|
+
analyzeDefinition,
|
|
1195
|
+
checkPrimedArguments,
|
|
1196
|
+
checkRecursiveSection,
|
|
1197
|
+
toOperand,
|
|
1198
|
+
errors,
|
|
1199
|
+
};
|
|
848
1200
|
};
|
|
849
1201
|
|
|
850
1202
|
export const analyzeAssumeProve = (
|
|
@@ -856,7 +1208,18 @@ export const analyzeAssumeProve = (
|
|
|
856
1208
|
const parts = assumeProve.assumptions.flatMap((assumption) => {
|
|
857
1209
|
if (assumption.kind === "NewSymbol") {
|
|
858
1210
|
const set = assumption.set && analyzer.analyze(assumption.set, inner);
|
|
859
|
-
|
|
1211
|
+
const range = assumption.location.range;
|
|
1212
|
+
if (set?.level === TEMPORAL_LEVEL && range) {
|
|
1213
|
+
analyzer.errors.push({
|
|
1214
|
+
location: formatRange(range),
|
|
1215
|
+
message: "Level error:\nTemporal formula used as set.",
|
|
1216
|
+
});
|
|
1217
|
+
}
|
|
1218
|
+
inner.set(assumption.name, {
|
|
1219
|
+
kind: "Formal",
|
|
1220
|
+
arity: assumption.arity,
|
|
1221
|
+
level: NEW_SYMBOL_LEVELS[assumption.level],
|
|
1222
|
+
});
|
|
860
1223
|
return set ? [set] : [];
|
|
861
1224
|
}
|
|
862
1225
|
return [
|
|
@@ -869,9 +1232,7 @@ export const analyzeAssumeProve = (
|
|
|
869
1232
|
const data = createData(Math.max(...parts.map((part) => part.level)));
|
|
870
1233
|
parts.forEach((part) => {
|
|
871
1234
|
part.params.forEach((param) => data.params.add(param));
|
|
872
|
-
|
|
873
|
-
part.argConstraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value));
|
|
874
|
-
part.argParams.forEach((key) => data.argParams.add(key));
|
|
1235
|
+
mergeConstraints(data, part);
|
|
875
1236
|
});
|
|
876
1237
|
return data;
|
|
877
1238
|
};
|
|
@@ -883,27 +1244,35 @@ export const checkModuleLevels = (
|
|
|
883
1244
|
warnings: SanyError[],
|
|
884
1245
|
) => {
|
|
885
1246
|
const analyzer = createLevelAnalyzer(context);
|
|
886
|
-
const getLevel = (expressions: Expression[]) =>
|
|
887
|
-
Math.max(0, ...expressions.map((expression) => analyzer.analyze(expression,
|
|
888
|
-
const getStepLevel = (step: ProofStep) => {
|
|
1247
|
+
const getLevel = (expressions: Expression[], scope: Scope) =>
|
|
1248
|
+
Math.max(0, ...expressions.map((expression) => analyzer.analyze(expression, scope).level));
|
|
1249
|
+
const getStepLevel = (step: ProofStep, scope: Scope) => {
|
|
889
1250
|
const body = step.body;
|
|
890
|
-
if (body.kind === "Have" || body.kind === "Case") return getLevel([body.expression]);
|
|
891
|
-
if (body.kind === "Witness") return getLevel(body.expressions);
|
|
892
|
-
if (body.kind === "Take")
|
|
1251
|
+
if (body.kind === "Have" || body.kind === "Case") return getLevel([body.expression], scope);
|
|
1252
|
+
if (body.kind === "Witness") return getLevel(body.expressions, scope);
|
|
1253
|
+
if (body.kind === "Take")
|
|
1254
|
+
return getLevel(
|
|
1255
|
+
body.bounds.map((bound) => bound.set),
|
|
1256
|
+
scope,
|
|
1257
|
+
);
|
|
893
1258
|
if (body.kind === "Pick") {
|
|
894
|
-
return getLevel([body.body, ...body.bounds.map((bound) => bound.set)]);
|
|
1259
|
+
return getLevel([body.body, ...body.bounds.map((bound) => bound.set)], scope);
|
|
895
1260
|
}
|
|
896
1261
|
if (body.kind !== "Assert") return 0;
|
|
897
1262
|
return body.statement.kind === "AssumeProve"
|
|
898
|
-
? analyzeAssumeProve(body.statement,
|
|
899
|
-
: getLevel([body.statement]);
|
|
1263
|
+
? analyzeAssumeProve(body.statement, scope, analyzer).level
|
|
1264
|
+
: getLevel([body.statement], scope);
|
|
900
1265
|
};
|
|
1266
|
+
const checkFacts = (facts: Fact[], scope: Scope) =>
|
|
1267
|
+
facts.forEach((fact) => {
|
|
1268
|
+
if (fact.kind !== "ModuleFact") analyzer.analyze(fact, scope);
|
|
1269
|
+
});
|
|
901
1270
|
const checkTemporalGoal = (proof: Proof | undefined): SanyError[] =>
|
|
902
1271
|
proof?.kind !== "Steps"
|
|
903
1272
|
? []
|
|
904
1273
|
: proof.steps.flatMap((step) => {
|
|
905
1274
|
const location = formatRange(step.statement);
|
|
906
|
-
const isConstant = () => getStepLevel(step) === 0;
|
|
1275
|
+
const isConstant = () => getStepLevel(step, new Map()) === 0;
|
|
907
1276
|
if (
|
|
908
1277
|
step.body.kind === "Have" ||
|
|
909
1278
|
step.body.kind === "Take" ||
|
|
@@ -923,62 +1292,129 @@ export const checkModuleLevels = (
|
|
|
923
1292
|
}
|
|
924
1293
|
return step.body.kind === "Qed" ? checkTemporalGoal(step.proof) : [];
|
|
925
1294
|
});
|
|
926
|
-
const checkProof = (proof: Proof | undefined): SanyError[] =>
|
|
927
|
-
proof?.kind
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
message: "Non-constant bound of temporal PICK.",
|
|
942
|
-
},
|
|
943
|
-
]
|
|
944
|
-
: [],
|
|
945
|
-
)
|
|
946
|
-
: [];
|
|
947
|
-
return [
|
|
948
|
-
...checkProof(step.proof),
|
|
949
|
-
...pickErrors,
|
|
950
|
-
...(step.proof?.kind === "Steps" && isTemporal() ? checkTemporalGoal(step.proof) : []),
|
|
951
|
-
];
|
|
1295
|
+
const checkProof = (proof: Proof | undefined, scope: Scope): SanyError[] => {
|
|
1296
|
+
if (proof?.kind === "By") {
|
|
1297
|
+
checkFacts(proof.facts, scope);
|
|
1298
|
+
return analyzer.errors.splice(0);
|
|
1299
|
+
}
|
|
1300
|
+
if (proof?.kind !== "Steps") return [];
|
|
1301
|
+
const inner = new Map(scope);
|
|
1302
|
+
return proof.steps.flatMap((step) => {
|
|
1303
|
+
const body = step.body;
|
|
1304
|
+
if (body.kind === "Use" || body.kind === "Hide") checkFacts(body.facts, inner);
|
|
1305
|
+
if (body.kind === "Define") {
|
|
1306
|
+
body.definitions.forEach((definition) => {
|
|
1307
|
+
if (definition.kind === "Instance") return;
|
|
1308
|
+
inner.set(definition.name, { kind: "Let", definition, scope: inner });
|
|
1309
|
+
analyzer.analyzeDefinition(definition, inner);
|
|
952
1310
|
});
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
.
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
1311
|
+
}
|
|
1312
|
+
const isTemporal = getStepLevel(step, inner) === TEMPORAL_LEVEL;
|
|
1313
|
+
const pickErrors =
|
|
1314
|
+
body.kind === "Pick" && body.bounds.length > 0 && isTemporal
|
|
1315
|
+
? body.bounds
|
|
1316
|
+
.filter((bound) => getLevel([bound.set], inner) !== 0)
|
|
1317
|
+
.flatMap((bound) =>
|
|
1318
|
+
bound.set.location.range
|
|
1319
|
+
? [
|
|
1320
|
+
{
|
|
1321
|
+
location: formatRange(bound.set.location.range),
|
|
1322
|
+
message: "Non-constant bound of temporal PICK.",
|
|
1323
|
+
},
|
|
1324
|
+
]
|
|
1325
|
+
: [],
|
|
1326
|
+
)
|
|
1327
|
+
: [];
|
|
1328
|
+
return [
|
|
1329
|
+
...analyzer.errors.splice(0),
|
|
1330
|
+
...checkProof(step.proof, inner),
|
|
1331
|
+
...pickErrors,
|
|
1332
|
+
...(step.proof?.kind === "Steps" && isTemporal ? checkTemporalGoal(step.proof) : []),
|
|
1333
|
+
];
|
|
1334
|
+
});
|
|
1335
|
+
};
|
|
1336
|
+
const statementLevels = new Map<Expression | AssumeProve, number>();
|
|
1337
|
+
const getStatementLevel = (statement: Expression | AssumeProve) => {
|
|
1338
|
+
const cached = statementLevels.get(statement);
|
|
1339
|
+
if (cached !== undefined) return cached;
|
|
1340
|
+
const level =
|
|
1341
|
+
statement.kind === "AssumeProve"
|
|
1342
|
+
? analyzeAssumeProve(statement, new Map(), analyzer).level
|
|
1343
|
+
: analyzer.analyze(statement, new Map()).level;
|
|
1344
|
+
statementLevels.set(statement, level);
|
|
1345
|
+
return level;
|
|
1346
|
+
};
|
|
1347
|
+
const statements = [
|
|
1348
|
+
...module.theorems,
|
|
1349
|
+
...module.assumptions.map((assumption) => ({
|
|
1350
|
+
...assumption,
|
|
1351
|
+
statement: assumption.expression,
|
|
1352
|
+
})),
|
|
1353
|
+
];
|
|
1354
|
+
const statementBodies = new Set(statements.map((statement) => statement.statement));
|
|
1355
|
+
const sections = getRecursiveSections(new Map(), module.units, module.hasRecursiveLet);
|
|
1356
|
+
const createCheck = (location: SourceLocation, run: () => void) => ({
|
|
1357
|
+
location,
|
|
1358
|
+
check: (reported: SanyError[]) => {
|
|
1359
|
+
run();
|
|
1360
|
+
reported.push(...analyzer.errors.splice(0));
|
|
1361
|
+
},
|
|
1362
|
+
});
|
|
1363
|
+
return {
|
|
1364
|
+
sections: sections.map((section) =>
|
|
1365
|
+
createCheck(section.location, () => analyzer.checkRecursiveSection(section.members)),
|
|
1366
|
+
),
|
|
1367
|
+
check: (isInner: boolean) =>
|
|
1368
|
+
[
|
|
1369
|
+
(isInner ? sections : []).map((section) =>
|
|
1370
|
+
createCheck(section.location, () => analyzer.checkPrimedArguments(section.members)),
|
|
1371
|
+
),
|
|
1372
|
+
module.definitions
|
|
1373
|
+
.filter(
|
|
1374
|
+
(definition) => !definition.name.includes("!") && !statementBodies.has(definition.body),
|
|
1375
|
+
)
|
|
1376
|
+
.map((definition) =>
|
|
1377
|
+
createCheck(definition.location, () =>
|
|
1378
|
+
analyzer.analyzeDefinition(definition, new Map()),
|
|
1379
|
+
),
|
|
1380
|
+
),
|
|
1381
|
+
statements
|
|
1382
|
+
.filter((statement) => statement.name !== undefined)
|
|
1383
|
+
.map((statement) =>
|
|
1384
|
+
createCheck(statement.location, () => getStatementLevel(statement.statement)),
|
|
1385
|
+
),
|
|
1386
|
+
[
|
|
1387
|
+
...module.assumptions.map((assumption) => ({
|
|
1388
|
+
location: assumption.location,
|
|
1389
|
+
check: (reported: SanyError[]) => {
|
|
1390
|
+
const level = getStatementLevel(assumption.expression);
|
|
1391
|
+
reported.push(...analyzer.errors.splice(0));
|
|
1392
|
+
const range = assumption.location.range;
|
|
1393
|
+
if (level !== CONSTANT_LEVEL && range) {
|
|
1394
|
+
reported.push({
|
|
1395
|
+
location: formatRange(range),
|
|
1396
|
+
message: `Level error: assumptions must be level 0 (Constant), \nbut this one has level ${level}.`,
|
|
1397
|
+
});
|
|
1398
|
+
}
|
|
1399
|
+
},
|
|
1400
|
+
})),
|
|
1401
|
+
...module.theorems.map((theorem) => ({
|
|
1402
|
+
location: theorem.location,
|
|
1403
|
+
check: (reported: SanyError[]) => {
|
|
1404
|
+
const level = getStatementLevel(theorem.statement);
|
|
1405
|
+
reported.push(
|
|
1406
|
+
...analyzer.errors.splice(0),
|
|
1407
|
+
...checkProof(theorem.proof, new Map()),
|
|
1408
|
+
...(level === TEMPORAL_LEVEL ? checkTemporalGoal(theorem.proof) : []),
|
|
1409
|
+
...analyzer.errors.splice(0),
|
|
1410
|
+
);
|
|
1411
|
+
},
|
|
1412
|
+
})),
|
|
1413
|
+
...module.uses.map((use) =>
|
|
1414
|
+
createCheck(use.location, () => checkFacts(use.facts, new Map())),
|
|
1415
|
+
),
|
|
1416
|
+
...instances,
|
|
1417
|
+
],
|
|
1418
|
+
].flatMap((units) => collectSemanticErrors(units, warnings)),
|
|
1419
|
+
};
|
|
984
1420
|
};
|