tla-ts 0.0.4-dev.fa107ef → 0.0.5-dev.cc59f31
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 +37 -126
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +44 -12
- package/dist/index.d.ts +44 -12
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +1006 -0
- package/dist/prove.js +1006 -0
- package/dist/run.cjs +45 -0
- package/dist/run.js +45 -0
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +76 -92
- package/dist/transfer.js +76 -92
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/ast.ts +2 -2
- package/src/bags.ts +22 -23
- package/src/builtins.ts +16 -8
- package/src/check.ts +131 -1153
- package/src/{cli-options.ts → cli/options.ts} +54 -9
- package/src/cli/run.ts +63 -0
- package/src/cli/shared.ts +106 -0
- package/src/cli/tlapm.ts +374 -0
- package/src/{run-cli.ts → cli/tlc.ts} +115 -721
- package/src/cli/xml-exporter.ts +221 -0
- package/src/cli.ts +1 -1
- package/src/codegen.ts +43 -22
- package/src/config.ts +5 -5
- package/src/dependencies.ts +4 -6
- package/src/environment.ts +55 -60
- package/src/errors.ts +97 -35
- package/src/evaluate.ts +135 -120
- package/src/exit-codes.ts +1 -1
- package/src/fingerprints.ts +3 -3
- package/src/index.ts +10 -0
- package/src/instances.ts +56 -46
- package/src/java-overrides.ts +79 -41
- package/src/json.ts +31 -36
- package/src/levels.ts +10 -13
- package/src/{live-check.ts → liveness-checker.ts} +169 -142
- package/src/liveness.ts +38 -34
- package/src/{obligation-action.ts → obligations/action.ts} +248 -74
- package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
- package/src/obligations/equality.ts +260 -0
- package/src/obligations/expression.ts +618 -0
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/obligations/generate.ts +457 -0
- package/src/{obligations.ts → obligations/index.ts} +46 -32
- package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
- package/src/obligations/module.ts +445 -0
- package/src/obligations/normalize.ts +554 -0
- package/src/obligations/operators.ts +176 -0
- package/src/obligations/pragma.ts +195 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/obligations/regroup.ts +100 -0
- package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
- package/src/{obligation-source.ts → obligations/source.ts} +172 -216
- package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
- package/src/obligations/substitution.ts +261 -0
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/parallel-worker.ts +39 -51
- package/src/parallel.ts +39 -66
- package/src/parser.ts +67 -74
- package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
- package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
- package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
- package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
- package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
- package/src/prover/decide-pool.ts +95 -0
- package/src/prover/deciders.ts +33 -0
- package/src/prover/first-order.ts +175 -0
- package/src/prover/isabelle/LICENSE +36 -0
- package/src/prover/isabelle/LICENSE-tlapm +26 -0
- package/src/prover/isabelle/decide.ts +44 -0
- package/src/prover/isabelle/encode.ts +445 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prover/isabelle/isar/method.ts +367 -0
- package/src/prover/isabelle/isar/proof.ts +28 -0
- package/src/prover/isabelle/isar/statement.ts +57 -0
- package/src/prover/isabelle/isar/theory.ts +192 -0
- package/src/prover/isabelle/isar/type-check.ts +278 -0
- package/src/prover/isabelle/provers/blast/blast.ts +258 -0
- package/src/prover/isabelle/provers/blast/branch.ts +322 -0
- package/src/prover/isabelle/provers/blast/prove.ts +347 -0
- package/src/prover/isabelle/provers/blast/rules.ts +330 -0
- package/src/prover/isabelle/provers/blast/state.ts +180 -0
- package/src/prover/isabelle/provers/blast/term.ts +546 -0
- package/src/prover/isabelle/provers/clasimp.ts +150 -0
- package/src/prover/isabelle/provers/classical.ts +389 -0
- package/src/prover/isabelle/provers/hypsubst.ts +433 -0
- package/src/prover/isabelle/pure/bicompose.ts +174 -0
- package/src/prover/isabelle/pure/consts.ts +32 -0
- package/src/prover/isabelle/pure/conv.ts +79 -0
- package/src/prover/isabelle/pure/drule.ts +264 -0
- package/src/prover/isabelle/pure/envir.ts +331 -0
- package/src/prover/isabelle/pure/goal.ts +53 -0
- package/src/prover/isabelle/pure/interrupt.ts +16 -0
- package/src/prover/isabelle/pure/list.ts +12 -0
- package/src/prover/isabelle/pure/logic.ts +330 -0
- package/src/prover/isabelle/pure/name.ts +98 -0
- package/src/prover/isabelle/pure/net.ts +215 -0
- package/src/prover/isabelle/pure/object-logic.ts +41 -0
- package/src/prover/isabelle/pure/pattern.ts +631 -0
- package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
- package/src/prover/isabelle/pure/rewriter.ts +602 -0
- package/src/prover/isabelle/pure/search.ts +68 -0
- package/src/prover/isabelle/pure/seq.ts +133 -0
- package/src/prover/isabelle/pure/simplifier.ts +106 -0
- package/src/prover/isabelle/pure/table.ts +201 -0
- package/src/prover/isabelle/pure/tactic.ts +168 -0
- package/src/prover/isabelle/pure/tactical.ts +264 -0
- package/src/prover/isabelle/pure/term-ord.ts +105 -0
- package/src/prover/isabelle/pure/term.ts +688 -0
- package/src/prover/isabelle/pure/thm.ts +783 -0
- package/src/prover/isabelle/pure/type.ts +121 -0
- package/src/prover/isabelle/pure/unify.ts +753 -0
- package/src/prover/isabelle/pure/variable.ts +25 -0
- package/src/prover/isabelle/tla/classical-setup.ts +101 -0
- package/src/prover/isabelle/tla/context.ts +74 -0
- package/src/prover/isabelle/tla/logic-data.ts +5 -0
- package/src/prover/isabelle/tla/logic.ts +215 -0
- package/src/prover/isabelle/tla/simpdata.ts +241 -0
- package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prover/ocaml.ts +22 -0
- package/src/prover/prep/action.ts +508 -0
- package/src/prover/prep/enabled-axioms.ts +189 -0
- package/src/prover/prep/fingerprint.ts +388 -0
- package/src/prover/prep/level-comparison.ts +529 -0
- package/src/prover/prep/md5.ts +60 -0
- package/src/prover/prep/methods.ts +221 -0
- package/src/prover/prep/normalize.ts +309 -0
- package/src/prover/prove-worker.ts +22 -0
- package/src/prover/prove.ts +492 -0
- package/src/prover/ptl/decide.ts +68 -0
- package/src/prover/ptl/encode.ts +244 -0
- package/src/prover/ptl/sat.ts +151 -0
- package/src/prover/ptl/tableau.ts +276 -0
- package/src/prover/smt/axioms.ts +209 -0
- package/src/prover/smt/context.ts +108 -0
- package/src/prover/smt/data.ts +636 -0
- package/src/prover/smt/encode.ts +275 -0
- package/src/prover/smt/extensionality.ts +65 -0
- package/src/prover/smt/flatten.ts +112 -0
- package/src/prover/smt/format.ts +154 -0
- package/src/prover/smt/instances.ts +181 -0
- package/src/prover/smt/rewrite.ts +766 -0
- package/src/prover/smt/solver/act-cache.ts +265 -0
- package/src/prover/smt/solver/arith-rewriter.ts +962 -0
- package/src/prover/smt/solver/array.ts +22 -0
- package/src/prover/smt/solver/asserted-formulas.ts +469 -0
- package/src/prover/smt/solver/ast-lt.ts +157 -0
- package/src/prover/smt/solver/ast-util.ts +91 -0
- package/src/prover/smt/solver/ast.ts +1315 -0
- package/src/prover/smt/solver/auf-solver.ts +572 -0
- package/src/prover/smt/solver/case-split-queue.ts +178 -0
- package/src/prover/smt/solver/cg-table.ts +175 -0
- package/src/prover/smt/solver/clause.ts +276 -0
- package/src/prover/smt/solver/conflict-resolution.ts +343 -0
- package/src/prover/smt/solver/context.ts +1292 -0
- package/src/prover/smt/solver/ctx-simplify.ts +334 -0
- package/src/prover/smt/solver/der.ts +224 -0
- package/src/prover/smt/solver/dyn-ack.ts +141 -0
- package/src/prover/smt/solver/e-matching.ts +659 -0
- package/src/prover/smt/solver/enode.ts +259 -0
- package/src/prover/smt/solver/expr-ref.ts +21 -0
- package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prover/smt/solver/fingerprints.ts +92 -0
- package/src/prover/smt/solver/flat-literals.ts +51 -0
- package/src/prover/smt/solver/goal.ts +138 -0
- package/src/prover/smt/solver/hash.ts +173 -0
- package/src/prover/smt/solver/hashtable.ts +166 -0
- package/src/prover/smt/solver/internalizer.ts +1381 -0
- package/src/prover/smt/solver/lbool.ts +5 -0
- package/src/prover/smt/solver/literal.ts +24 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prover/smt/solver/lp/constraints.ts +78 -0
- package/src/prover/smt/solver/lp/containers.ts +296 -0
- package/src/prover/smt/solver/lp/core-solver.ts +504 -0
- package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
- package/src/prover/smt/solver/lp/dependency.ts +51 -0
- package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prover/smt/solver/lp/explanation.ts +46 -0
- package/src/prover/smt/solver/lp/gomory.ts +255 -0
- package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prover/smt/solver/lp/hnf.ts +281 -0
- package/src/prover/smt/solver/lp/int-cube.ts +295 -0
- package/src/prover/smt/solver/lp/int-solver.ts +514 -0
- package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prover/smt/solver/lp/lar-term.ts +62 -0
- package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prover/smt/solver/lp/nex.ts +120 -0
- package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prover/smt/solver/lp/nla-core.ts +968 -0
- package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prover/smt/solver/lp/nla-order.ts +307 -0
- package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prover/smt/solver/lp/nla-types.ts +124 -0
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prover/smt/solver/lp/pdd.ts +971 -0
- package/src/prover/smt/solver/lp/random-updater.ts +138 -0
- package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prover/smt/solver/lp/union-find.ts +96 -0
- package/src/prover/smt/solver/mam-compiler.ts +847 -0
- package/src/prover/smt/solver/mam-interpreter.ts +400 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prover/smt/solver/model-checker.ts +347 -0
- package/src/prover/smt/solver/model-evaluator.ts +262 -0
- package/src/prover/smt/solver/model-finder.ts +155 -0
- package/src/prover/smt/solver/model-generator.ts +97 -0
- package/src/prover/smt/solver/model-macro-solver.ts +728 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prover/smt/solver/nlsat/explain.ts +607 -0
- package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
- package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prover/smt/solver/nlsat/solver.ts +911 -0
- package/src/prover/smt/solver/nlsat/types.ts +43 -0
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prover/smt/solver/nnf.ts +469 -0
- package/src/prover/smt/solver/pattern-inference.ts +351 -0
- package/src/prover/smt/solver/poly-rewriter.ts +477 -0
- package/src/prover/smt/solver/propagate-values.ts +83 -0
- package/src/prover/smt/solver/proto-model.ts +551 -0
- package/src/prover/smt/solver/pull-quant.ts +139 -0
- package/src/prover/smt/solver/qe-lite-der.ts +526 -0
- package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prover/smt/solver/qe-lite.ts +381 -0
- package/src/prover/smt/solver/qi-queue.ts +362 -0
- package/src/prover/smt/solver/quant-tactics.ts +117 -0
- package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prover/smt/solver/quantifier-manager.ts +186 -0
- package/src/prover/smt/solver/random-gen.ts +10 -0
- package/src/prover/smt/solver/rational.ts +165 -0
- package/src/prover/smt/solver/ref-vector.ts +62 -0
- package/src/prover/smt/solver/relevancy.ts +247 -0
- package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prover/smt/solver/rewriter.ts +843 -0
- package/src/prover/smt/solver/rlimit.ts +79 -0
- package/src/prover/smt/solver/smtlib-parser.ts +526 -0
- package/src/prover/smt/solver/solver.ts +71 -0
- package/src/prover/smt/solver/sort.ts +35 -0
- package/src/prover/smt/solver/sticky-generations.ts +69 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prover/smt/solver/theory-lra-model.ts +243 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prover/smt/solver/theory-lra-state.ts +43 -0
- package/src/prover/smt/solver/theory-lra.ts +56 -0
- package/src/prover/smt/solver/var-subst.ts +258 -0
- package/src/prover/smt/solver/z3-license.txt +10 -0
- package/src/prover/smt/table.ts +170 -0
- package/src/prover/tlapm/cache.ts +236 -0
- package/src/prover/tlapm/ocaml-marshal.ts +166 -0
- package/src/prover/tlapm/tlapm.ts +96 -0
- package/src/prover/tlaps-module.ts +510 -0
- package/src/prover/verdict.ts +13 -0
- package/src/prover/zenon/LICENSE +32 -0
- package/src/prover/zenon/check/check.ts +105 -0
- package/src/prover/zenon/check/definitions.ts +144 -0
- package/src/prover/zenon/check/equality.ts +182 -0
- package/src/prover/zenon/check/functions.ts +62 -0
- package/src/prover/zenon/check/keys.ts +125 -0
- package/src/prover/zenon/check/propositional.ts +104 -0
- package/src/prover/zenon/check/records.ts +188 -0
- package/src/prover/zenon/check/relations.ts +121 -0
- package/src/prover/zenon/check/rewrites.ts +224 -0
- package/src/prover/zenon/check/sets.ts +302 -0
- package/src/prover/zenon/check/terms.ts +127 -0
- package/src/prover/zenon/check/tla.ts +126 -0
- package/src/prover/zenon/decide.ts +107 -0
- package/src/prover/zenon/encode.ts +378 -0
- package/src/prover/zenon/eqrel.ts +300 -0
- package/src/prover/zenon/equality-rules.ts +435 -0
- package/src/prover/zenon/expr.ts +551 -0
- package/src/prover/zenon/index-table.ts +350 -0
- package/src/prover/zenon/isar-case.ts +513 -0
- package/src/prover/zenon/isar.ts +1249 -0
- package/src/prover/zenon/limits.ts +15 -0
- package/src/prover/zenon/llproof.ts +173 -0
- package/src/prover/zenon/mltoll.ts +1566 -0
- package/src/prover/zenon/node.ts +297 -0
- package/src/prover/zenon/ocaml.ts +169 -0
- package/src/prover/zenon/parse.ts +247 -0
- package/src/prover/zenon/phrase.ts +191 -0
- package/src/prover/zenon/proof.ts +198 -0
- package/src/prover/zenon/propositional-rules.ts +387 -0
- package/src/prover/zenon/rules.ts +94 -0
- package/src/prover/zenon/search.ts +288 -0
- package/src/prover/zenon/tla/functions.ts +151 -0
- package/src/prover/zenon/tla/llproof.ts +480 -0
- package/src/prover/zenon/tla/records.ts +225 -0
- package/src/prover/zenon/tla/rewrites.ts +447 -0
- package/src/prover/zenon/tla/sets.ts +304 -0
- package/src/prover/zenon/tla/terms.ts +162 -0
- package/src/prover/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +19 -24
- package/src/resolve.ts +15 -22
- package/src/runtime.ts +8 -8
- package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
- package/src/{sany-generator.ts → sany/generator.ts} +38 -55
- package/src/{sany-levels.ts → sany/levels.ts} +45 -48
- package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
- package/src/{sany-linter.ts → sany/linter.ts} +1 -1
- package/src/{sany-modules.ts → sany/modules.ts} +2 -2
- package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
- package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
- package/src/{sany-report.ts → sany/report.ts} +16 -17
- package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
- package/src/{sany-source.ts → sany/source.ts} +6 -7
- package/src/{sany-xml.ts → sany/xml.ts} +5 -6
- package/src/search.ts +969 -0
- package/src/spec-description.ts +26 -20
- package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
- package/src/standard-modules.ts +21 -22
- package/src/state-graph.ts +9 -8
- package/src/substitution-levels.ts +2 -2
- package/src/successors.ts +38 -22
- package/src/symmetry.ts +1 -1
- package/src/tableau.ts +6 -7
- package/src/tlc/fingerprint.ts +214 -0
- package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
- package/src/{tlc-order.ts → tlc/order.ts} +7 -7
- package/src/{tlc-random.ts → tlc/random.ts} +3 -190
- package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
- package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
- package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
- package/src/{tlc-version.ts → tlc/version.ts} +8 -7
- package/src/transfer.ts +32 -32
- package/src/values.ts +154 -105
- package/src/worker.ts +62 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
- package/dist/run-cli.cjs +0 -55
- package/dist/run-cli.js +0 -55
- package/src/canonical.ts +0 -40
- package/src/obligation-expression.ts +0 -1060
- package/src/obligation-module.ts +0 -1042
- package/src/standard-ranges.ts +0 -116
- package/src/value-sources.ts +0 -29
- /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
- /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
|
@@ -0,0 +1,330 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Provers/blast.ML. Copyright (c) 1986-2025 University of Cambridge,
|
|
2
|
+
// Technische Universitaet Muenchen, and contributors, see LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// Conversion of the classical rules to tableau operations, each with the Isabelle tactic that
|
|
5
|
+
// replays it during proof reconstruction.
|
|
6
|
+
|
|
7
|
+
import { TlaIsabelleError } from "../../../../errors";
|
|
8
|
+
import { revcutRl, zeroVarIndexes } from "../../pure/drule";
|
|
9
|
+
import { unifyTermNet } from "../../pure/net";
|
|
10
|
+
import { seqHead, singleSeq } from "../../pure/seq";
|
|
11
|
+
import { thenGoal, thenTac, type GoalTactic, type Tactic } from "../../pure/tactical";
|
|
12
|
+
import {
|
|
13
|
+
ematchTac,
|
|
14
|
+
eresolveTac,
|
|
15
|
+
matchTac,
|
|
16
|
+
orderList,
|
|
17
|
+
resolveTac,
|
|
18
|
+
rotateTac,
|
|
19
|
+
type NetPair,
|
|
20
|
+
type TaggedRule,
|
|
21
|
+
} from "../../pure/tactic";
|
|
22
|
+
import { dummyT, mkApp, mkConst } from "../../pure/term";
|
|
23
|
+
import { assumption, rotateRule, rs, rsn, type Thm } from "../../pure/thm";
|
|
24
|
+
import { gensym, type BlastState } from "./state";
|
|
25
|
+
import {
|
|
26
|
+
FALSE_NAME,
|
|
27
|
+
GOAL_NAME,
|
|
28
|
+
blastSubstBound,
|
|
29
|
+
destConstApp,
|
|
30
|
+
fromTerm,
|
|
31
|
+
instantiateTemplate,
|
|
32
|
+
mkBlastConst,
|
|
33
|
+
mkBlastSkolem,
|
|
34
|
+
mkBlastVar,
|
|
35
|
+
mkGoal,
|
|
36
|
+
stripBlastImpConcl,
|
|
37
|
+
stripBlastImpPrems,
|
|
38
|
+
toTemplate,
|
|
39
|
+
toTerm,
|
|
40
|
+
type BlastTerm,
|
|
41
|
+
type Template,
|
|
42
|
+
type VarRef,
|
|
43
|
+
} from "./term";
|
|
44
|
+
|
|
45
|
+
// A tableau rule: the formula it applies to, the formulae of each new branch, and the tactic
|
|
46
|
+
// for the flags upd (the inference updated the branch), dup (duplicate the formula) and rot
|
|
47
|
+
// (rotate the new hypotheses).
|
|
48
|
+
export interface TableauRule {
|
|
49
|
+
readonly major: BlastTerm;
|
|
50
|
+
readonly prems: readonly (readonly BlastTerm[])[];
|
|
51
|
+
readonly tactic: (isUpdated: boolean, isDup: boolean, isRotated: boolean) => GoalTactic;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
// Blast converts each rule it looks up afresh, with fresh variables and Skolem terms. This
|
|
55
|
+
// converts each rule once, numbering them: concl is the conclusion's variable, which conversion
|
|
56
|
+
// sets to *False*, and skolems counts the Skolem terms, which take fresh names in this order. An
|
|
57
|
+
// ill-formed rule has no major premise, but still takes the names its conversion took.
|
|
58
|
+
export interface RuleTemplate {
|
|
59
|
+
readonly count: number;
|
|
60
|
+
readonly concl: number | undefined;
|
|
61
|
+
readonly skolems: number;
|
|
62
|
+
readonly major: Template | undefined;
|
|
63
|
+
readonly prems: readonly (readonly Template[])[];
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
// The conclusion becomes the goal or the negated assumption *False*: delete it. A premise without
|
|
67
|
+
// it is ill-formed and could make reconstruction fail.
|
|
68
|
+
const deleteConcl = (state: BlastState, prems: readonly BlastTerm[]): BlastTerm[] | undefined => {
|
|
69
|
+
const position = prems.findIndex((prem) => {
|
|
70
|
+
if (prem.kind !== "App" || prem.fun.kind !== "Const") return false;
|
|
71
|
+
const arg = prem.arg;
|
|
72
|
+
return (
|
|
73
|
+
arg.kind === "Var" &&
|
|
74
|
+
arg.ref.value?.kind === "Const" &&
|
|
75
|
+
arg.ref.value.name === FALSE_NAME &&
|
|
76
|
+
(prem.fun.name === GOAL_NAME || prem.fun.name === state.context.data.notName)
|
|
77
|
+
);
|
|
78
|
+
});
|
|
79
|
+
return position === -1 ? undefined : [...prems.slice(0, position), ...prems.slice(position + 1)];
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
// Skolemizes a premise with placeholder Skolem terms, adding them to skolems in the order that
|
|
83
|
+
// blast names them.
|
|
84
|
+
const skoPrem = (skolems: BlastTerm[], prem: BlastTerm): BlastTerm => {
|
|
85
|
+
const body = destConstApp(prem, "Pure.all");
|
|
86
|
+
if (body?.kind !== "Abs") return prem;
|
|
87
|
+
const skolem = mkBlastSkolem("", []);
|
|
88
|
+
skolems.push(skolem);
|
|
89
|
+
return skoPrem(skolems, blastSubstBound(skolem, body.body));
|
|
90
|
+
};
|
|
91
|
+
|
|
92
|
+
const illFormed = (skolems: number): RuleTemplate => ({
|
|
93
|
+
count: 0,
|
|
94
|
+
concl: undefined,
|
|
95
|
+
skolems,
|
|
96
|
+
major: undefined,
|
|
97
|
+
prems: [],
|
|
98
|
+
});
|
|
99
|
+
|
|
100
|
+
// fromRule's convertRule, which expects an elimination rule to have a formula variable as its
|
|
101
|
+
// conclusion.
|
|
102
|
+
const makeElimTemplate = (state: BlastState, rule: Thm): RuleTemplate => {
|
|
103
|
+
const trueprop = state.context.data.trueprop;
|
|
104
|
+
const term = fromTerm(state.context.consts, rule.prop);
|
|
105
|
+
const refs: VarRef[] = [];
|
|
106
|
+
toTemplate(refs, [], term);
|
|
107
|
+
const prems = stripBlastImpPrems(trueprop, term);
|
|
108
|
+
const concl = stripBlastImpConcl(trueprop, term);
|
|
109
|
+
if (prems.length === 0 || concl.kind !== "Var") return illFormed(0);
|
|
110
|
+
concl.ref.value = mkBlastConst(FALSE_NAME);
|
|
111
|
+
const skolems: BlastTerm[] = [];
|
|
112
|
+
const converted: BlastTerm[][] = [];
|
|
113
|
+
for (const prem of prems.slice(1)) {
|
|
114
|
+
const skolemized = skoPrem(skolems, prem);
|
|
115
|
+
const deleted = deleteConcl(state, [
|
|
116
|
+
mkGoal(stripBlastImpConcl(trueprop, skolemized)),
|
|
117
|
+
...stripBlastImpPrems(trueprop, skolemized),
|
|
118
|
+
]);
|
|
119
|
+
if (deleted === undefined) return illFormed(skolems.length);
|
|
120
|
+
converted.push(deleted);
|
|
121
|
+
}
|
|
122
|
+
return {
|
|
123
|
+
count: refs.length,
|
|
124
|
+
concl: refs.indexOf(concl.ref),
|
|
125
|
+
skolems: skolems.length,
|
|
126
|
+
major: toTemplate(refs, skolems, prems[0]),
|
|
127
|
+
prems: converted.map((prem) => prem.map((item) => toTemplate(refs, skolems, item))),
|
|
128
|
+
};
|
|
129
|
+
};
|
|
130
|
+
|
|
131
|
+
// fromIntrRule's conversion.
|
|
132
|
+
const makeIntroTemplate = (state: BlastState, rule: Thm): RuleTemplate => {
|
|
133
|
+
const trueprop = state.context.data.trueprop;
|
|
134
|
+
const term = fromTerm(state.context.consts, rule.prop);
|
|
135
|
+
const refs: VarRef[] = [];
|
|
136
|
+
toTemplate(refs, [], term);
|
|
137
|
+
const skolems: BlastTerm[] = [];
|
|
138
|
+
const converted = stripBlastImpPrems(trueprop, term).map((prem) => {
|
|
139
|
+
const skolemized = skoPrem(skolems, prem);
|
|
140
|
+
return [
|
|
141
|
+
mkGoal(stripBlastImpConcl(trueprop, skolemized)),
|
|
142
|
+
...stripBlastImpPrems(trueprop, skolemized),
|
|
143
|
+
];
|
|
144
|
+
});
|
|
145
|
+
return {
|
|
146
|
+
count: refs.length,
|
|
147
|
+
concl: undefined,
|
|
148
|
+
skolems: skolems.length,
|
|
149
|
+
major: toTemplate(refs, skolems, mkGoal(stripBlastImpConcl(trueprop, term))),
|
|
150
|
+
prems: converted.map((prem) => prem.map((item) => toTemplate(refs, skolems, item))),
|
|
151
|
+
};
|
|
152
|
+
};
|
|
153
|
+
|
|
154
|
+
// Like dup_elim, but puts the duplicated major premise first.
|
|
155
|
+
const revDupElim = (rule: Thm) => {
|
|
156
|
+
const result = seqHead(assumption(undefined, 2, rsn(rule, 2, revcutRl)));
|
|
157
|
+
if (result === undefined) throw new TlaIsabelleError("ERROR", "rev_dup_elim: Seq.hd");
|
|
158
|
+
return result;
|
|
159
|
+
};
|
|
160
|
+
|
|
161
|
+
const countNewHyps = (prem: readonly BlastTerm[]) =>
|
|
162
|
+
prem.filter((term) => destConstApp(term, GOAL_NAME) === undefined).length;
|
|
163
|
+
|
|
164
|
+
// Rotates the assumptions in all new subgoals for the LIFO discipline.
|
|
165
|
+
const rotSubgoalsTac =
|
|
166
|
+
(isRotated: boolean, prems: readonly (readonly BlastTerm[])[]): GoalTactic =>
|
|
167
|
+
(index) =>
|
|
168
|
+
(state) =>
|
|
169
|
+
singleSeq(
|
|
170
|
+
(isRotated ? prems.map(countNewHyps) : []).reduce(
|
|
171
|
+
(current, count, offset) =>
|
|
172
|
+
count === 0 ? current : rotateRule(-count, index + offset, current),
|
|
173
|
+
state,
|
|
174
|
+
),
|
|
175
|
+
);
|
|
176
|
+
|
|
177
|
+
// Resolution or matching: if the inference updated the branch, the proof state may be updated.
|
|
178
|
+
// Matching keeps the tactics more deterministic in the presence of variables.
|
|
179
|
+
const emtac = (state: BlastState, isUpdated: boolean, rule: Thm): GoalTactic =>
|
|
180
|
+
isUpdated ? eresolveTac(state.context.limits, [rule]) : ematchTac(state.context.limits, [rule]);
|
|
181
|
+
|
|
182
|
+
const rmtac = (state: BlastState, isUpdated: boolean, rule: Thm): GoalTactic =>
|
|
183
|
+
isUpdated ? resolveTac(state.context.limits, [rule]) : matchTac(state.context.limits, [rule]);
|
|
184
|
+
|
|
185
|
+
const elimRuleTactic =
|
|
186
|
+
(state: BlastState, rule: Thm, prems: readonly (readonly BlastTerm[])[]) =>
|
|
187
|
+
(isUpdated: boolean, isDup: boolean, isRotated: boolean) =>
|
|
188
|
+
(index: number): Tactic =>
|
|
189
|
+
thenTac(
|
|
190
|
+
emtac(state, isUpdated, isDup ? revDupElim(rule) : rule)(index),
|
|
191
|
+
rotSubgoalsTac(isRotated, prems)(index),
|
|
192
|
+
);
|
|
193
|
+
|
|
194
|
+
const intrRuleTactic =
|
|
195
|
+
(state: BlastState, rule: Thm, prems: readonly (readonly BlastTerm[])[]) =>
|
|
196
|
+
(isUpdated: boolean, isDup: boolean, isRotated: boolean) =>
|
|
197
|
+
(index: number): Tactic =>
|
|
198
|
+
thenTac(
|
|
199
|
+
rmtac(
|
|
200
|
+
state,
|
|
201
|
+
isUpdated,
|
|
202
|
+
isDup ? zeroVarIndexes(rs(rule, state.context.data.classical)) : rule,
|
|
203
|
+
)(index),
|
|
204
|
+
rotSubgoalsTac(isRotated, prems)(index),
|
|
205
|
+
);
|
|
206
|
+
|
|
207
|
+
// A tableau rule from a rule's template. Blast tries the rules in order until one's major premise
|
|
208
|
+
// unifies, and often only checks that a rule exists, so this instantiates the template with fresh
|
|
209
|
+
// variables only when the major premise is used, and the premises only when they are.
|
|
210
|
+
class InstantiatedRule implements TableauRule {
|
|
211
|
+
private readonly state: BlastState;
|
|
212
|
+
private readonly rule: Thm;
|
|
213
|
+
private readonly isIntro: boolean;
|
|
214
|
+
private readonly template: RuleTemplate;
|
|
215
|
+
private readonly majorTemplate: Template;
|
|
216
|
+
private readonly skolems: readonly BlastTerm[];
|
|
217
|
+
private vars: readonly BlastTerm[] | undefined;
|
|
218
|
+
private instantiatedMajor: BlastTerm | undefined;
|
|
219
|
+
private instantiatedPrems: readonly (readonly BlastTerm[])[] | undefined;
|
|
220
|
+
|
|
221
|
+
constructor(
|
|
222
|
+
state: BlastState,
|
|
223
|
+
rule: Thm,
|
|
224
|
+
isIntro: boolean,
|
|
225
|
+
template: RuleTemplate,
|
|
226
|
+
majorTemplate: Template,
|
|
227
|
+
skolems: readonly BlastTerm[],
|
|
228
|
+
) {
|
|
229
|
+
this.state = state;
|
|
230
|
+
this.rule = rule;
|
|
231
|
+
this.isIntro = isIntro;
|
|
232
|
+
this.template = template;
|
|
233
|
+
this.majorTemplate = majorTemplate;
|
|
234
|
+
this.skolems = skolems;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
// Fresh variables for the template's, with the conclusion's set to *False*.
|
|
238
|
+
private getVars() {
|
|
239
|
+
if (this.vars !== undefined) return this.vars;
|
|
240
|
+
const vars: BlastTerm[] = [];
|
|
241
|
+
for (let index = 0; index < this.template.count; index += 1)
|
|
242
|
+
vars.push(
|
|
243
|
+
mkBlastVar({
|
|
244
|
+
value: index === this.template.concl ? mkBlastConst(FALSE_NAME) : undefined,
|
|
245
|
+
}),
|
|
246
|
+
);
|
|
247
|
+
this.vars = vars;
|
|
248
|
+
return vars;
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
get major() {
|
|
252
|
+
this.instantiatedMajor ??= instantiateTemplate(
|
|
253
|
+
this.getVars(),
|
|
254
|
+
this.skolems,
|
|
255
|
+
this.majorTemplate,
|
|
256
|
+
);
|
|
257
|
+
return this.instantiatedMajor;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
get prems() {
|
|
261
|
+
this.instantiatedPrems ??= this.template.prems.map((prem) =>
|
|
262
|
+
prem.map((template) => instantiateTemplate(this.getVars(), this.skolems, template)),
|
|
263
|
+
);
|
|
264
|
+
return this.instantiatedPrems;
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
// Since unsafe rules are delayed, dup is always false for introduction rules.
|
|
268
|
+
tactic(isUpdated: boolean, isDup: boolean, isRotated: boolean) {
|
|
269
|
+
return (this.isIntro ? intrRuleTactic : elimRuleTactic)(this.state, this.rule, this.prems)(
|
|
270
|
+
isUpdated,
|
|
271
|
+
isDup,
|
|
272
|
+
isRotated,
|
|
273
|
+
);
|
|
274
|
+
}
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
// fromRule or fromIntrRule: undefined for an ill-formed rule. Its Skolem terms take their names
|
|
278
|
+
// now, as blast converts all the rules it looks up at once.
|
|
279
|
+
const instantiateRule = (
|
|
280
|
+
state: BlastState,
|
|
281
|
+
vars: readonly VarRef[],
|
|
282
|
+
rule: Thm,
|
|
283
|
+
isIntro: boolean,
|
|
284
|
+
): TableauRule | undefined => {
|
|
285
|
+
const templates = isIntro ? state.context.introTemplates : state.context.elimTemplates;
|
|
286
|
+
const known = templates.get(rule);
|
|
287
|
+
const template =
|
|
288
|
+
known ?? (isIntro ? makeIntroTemplate(state, rule) : makeElimTemplate(state, rule));
|
|
289
|
+
if (known === undefined) templates.set(rule, template);
|
|
290
|
+
const skolems: BlastTerm[] = [];
|
|
291
|
+
for (let slot = 0; slot < template.skolems; slot += 1)
|
|
292
|
+
skolems.push(mkBlastSkolem(gensym(state, "S"), vars));
|
|
293
|
+
return template.major === undefined
|
|
294
|
+
? undefined
|
|
295
|
+
: new InstantiatedRule(state, rule, isIntro, template, template.major, skolems);
|
|
296
|
+
};
|
|
297
|
+
|
|
298
|
+
// Too flexible assertions or goals, such as those of (!!P. ~P) ==> 0 == 1.
|
|
299
|
+
const isVarForm = (state: BlastState, term: BlastTerm) =>
|
|
300
|
+
term.kind === "Var" || destConstApp(term, state.context.data.notName)?.kind === "Var";
|
|
301
|
+
|
|
302
|
+
const orderRules = (rules: readonly TaggedRule[]) =>
|
|
303
|
+
orderList(rules.map((rule) => ({ tag: rule.tag, item: rule.rule })));
|
|
304
|
+
|
|
305
|
+
export const netMkRules = (
|
|
306
|
+
state: BlastState,
|
|
307
|
+
formula: BlastTerm,
|
|
308
|
+
vars: readonly VarRef[],
|
|
309
|
+
netpairs: readonly NetPair<TaggedRule>[],
|
|
310
|
+
): TableauRule[] => {
|
|
311
|
+
const goal = destConstApp(formula, GOAL_NAME);
|
|
312
|
+
if (goal === undefined && isVarForm(state, formula)) return [];
|
|
313
|
+
const trueprop = mkConst(state.context.data.trueprop, dummyT);
|
|
314
|
+
const pattern =
|
|
315
|
+
goal === undefined ? mkApp(trueprop, toTerm(3, formula)) : mkApp(trueprop, toTerm(2, goal));
|
|
316
|
+
const matched: TaggedRule[] = [];
|
|
317
|
+
for (const netpair of netpairs)
|
|
318
|
+
for (const rule of unifyTermNet(goal === undefined ? netpair.elim : netpair.intro, pattern))
|
|
319
|
+
matched.push(rule);
|
|
320
|
+
const rules: TableauRule[] = [];
|
|
321
|
+
for (const rule of orderRules(matched)) {
|
|
322
|
+
const instantiated = instantiateRule(state, vars, rule, goal !== undefined);
|
|
323
|
+
if (instantiated !== undefined) rules.push(instantiated);
|
|
324
|
+
}
|
|
325
|
+
return rules;
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
// Converts *Goal* to a negated assumption in first position.
|
|
329
|
+
export const negOfGoalTac = (state: BlastState): GoalTactic =>
|
|
330
|
+
thenGoal(resolveTac(state.context.limits, [state.context.data.ccontr]), rotateTac(-1));
|
|
@@ -0,0 +1,180 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Provers/blast.ML. Copyright (c) 1986-2025 University of Cambridge,
|
|
2
|
+
// Technische Universitaet Muenchen, and contributors, see LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// The object logic's data for blast, and the state of one search: the names of its Skolem
|
|
5
|
+
// constants and the trail of variable assignments that backtracking undoes.
|
|
6
|
+
|
|
7
|
+
import { bumpInit, bumpString } from "../../pure/name";
|
|
8
|
+
import type { GoalTactic } from "../../pure/tactical";
|
|
9
|
+
import type { Limits } from "../../pure/interrupt";
|
|
10
|
+
import type { List } from "../../pure/list";
|
|
11
|
+
import type { Thm } from "../../pure/thm";
|
|
12
|
+
import type { Claset } from "../classical";
|
|
13
|
+
import type { RuleTemplate } from "./rules";
|
|
14
|
+
import { blastAconv, varOccur, wkNorm, type BlastTerm, type ConstType, type VarRef } from "./term";
|
|
15
|
+
|
|
16
|
+
// BLAST_DATA, with the two rules of other structures that blast uses.
|
|
17
|
+
export interface BlastData {
|
|
18
|
+
readonly trueprop: string;
|
|
19
|
+
readonly equalityName: string;
|
|
20
|
+
readonly notName: string;
|
|
21
|
+
// ~P ==> P ==> R
|
|
22
|
+
readonly notE: Thm;
|
|
23
|
+
// (~P ==> False) ==> P
|
|
24
|
+
readonly ccontr: Thm;
|
|
25
|
+
readonly hypSubstTac: (limits: Limits) => GoalTactic;
|
|
26
|
+
// The classical reasoner's (~P ==> P) ==> P, which Classical.dup_intr resolves with.
|
|
27
|
+
readonly classical: Thm;
|
|
28
|
+
// The atomize rules of Object_Logic, newest first, for atomize_prems_tac.
|
|
29
|
+
readonly atomize: readonly Thm[];
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
export interface BlastContext {
|
|
33
|
+
readonly limits: Limits;
|
|
34
|
+
readonly claset: Claset;
|
|
35
|
+
readonly data: BlastData;
|
|
36
|
+
// The constants' declared types, for Sign.const_typargs.
|
|
37
|
+
readonly consts: ReadonlyMap<string, ConstType>;
|
|
38
|
+
// The elimination and introduction rules converted to tableau rules so far.
|
|
39
|
+
readonly elimTemplates: WeakMap<Thm, RuleTemplate>;
|
|
40
|
+
readonly introTemplates: WeakMap<Thm, RuleTemplate>;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
// A formula pending on a branch, with its may-duplicate flag.
|
|
44
|
+
export interface Formula {
|
|
45
|
+
readonly term: BlastTerm;
|
|
46
|
+
readonly md: boolean;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
// The safe and unsafe formulae of one level of a branch.
|
|
50
|
+
export interface Level {
|
|
51
|
+
readonly safe: readonly Formula[];
|
|
52
|
+
readonly unsafe: readonly Formula[];
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
export interface Branch {
|
|
56
|
+
readonly pairs: readonly Level[];
|
|
57
|
+
// Literals: irreducible formulae.
|
|
58
|
+
readonly lits: readonly BlastTerm[];
|
|
59
|
+
// The variables occurring in the branch.
|
|
60
|
+
readonly vars: readonly VarRef[];
|
|
61
|
+
// The resource limit.
|
|
62
|
+
readonly lim: number;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
// A choice point: the trail length and branch count when it was made, and the token its handler
|
|
66
|
+
// catches. The token is undefined for PROVE, the end of the search.
|
|
67
|
+
export interface Choice {
|
|
68
|
+
readonly ntrl: number;
|
|
69
|
+
readonly nbrs: number;
|
|
70
|
+
readonly token: object | undefined;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
export interface BlastState {
|
|
74
|
+
readonly context: BlastContext;
|
|
75
|
+
// The used names with their latest renaming, a Name.context updated in place.
|
|
76
|
+
readonly names: Map<string, string | undefined>;
|
|
77
|
+
// The assigned variables, latest last, so that the trail's length is ntrail.
|
|
78
|
+
readonly trail: VarRef[];
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
// Raising the exception of a choice point: unwinds to the handler that owns the token. Not an
|
|
82
|
+
// Error, since backtracking is frequent and needs no stack trace.
|
|
83
|
+
class Backtrack {
|
|
84
|
+
readonly token: object | undefined;
|
|
85
|
+
constructor(token: object | undefined) {
|
|
86
|
+
this.token = token;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// The choice points, latest first. The last is PROVE's.
|
|
91
|
+
export type Choices = List<Choice> | undefined;
|
|
92
|
+
|
|
93
|
+
export const isBacktrackTo = (error: unknown, token: object | undefined) =>
|
|
94
|
+
error instanceof Backtrack && error.token === token;
|
|
95
|
+
|
|
96
|
+
export const backtrack = (choices: Choices): never => {
|
|
97
|
+
throw new Backtrack(choices?.head.token);
|
|
98
|
+
};
|
|
99
|
+
|
|
100
|
+
// Name.variant on the state's names, for names without trailing underscores.
|
|
101
|
+
export const gensym = (state: BlastState, name: string) => {
|
|
102
|
+
const names = state.names;
|
|
103
|
+
if (!names.has(name)) {
|
|
104
|
+
names.set(name, undefined);
|
|
105
|
+
return name;
|
|
106
|
+
}
|
|
107
|
+
const initial = bumpInit(name);
|
|
108
|
+
let current = initial;
|
|
109
|
+
while (names.has(current)) current = bumpString(names.get(current) ?? current);
|
|
110
|
+
if (current !== initial) names.set(initial, current);
|
|
111
|
+
names.set(current, undefined);
|
|
112
|
+
return current;
|
|
113
|
+
};
|
|
114
|
+
|
|
115
|
+
// Restores the trail to a previous length, for backtracking.
|
|
116
|
+
export const clearTo = (state: BlastState, count: number) => {
|
|
117
|
+
while (state.trail.length > count) {
|
|
118
|
+
const ref = state.trail.pop();
|
|
119
|
+
if (ref !== undefined) ref.value = undefined;
|
|
120
|
+
}
|
|
121
|
+
};
|
|
122
|
+
|
|
123
|
+
// First-order unification with bound variables. The variables of vars are local to a rule: their
|
|
124
|
+
// assignments are not trailed.
|
|
125
|
+
const updateVar = (
|
|
126
|
+
state: BlastState,
|
|
127
|
+
vars: readonly VarRef[],
|
|
128
|
+
variable: Extract<BlastTerm, { kind: "Var" }>,
|
|
129
|
+
term: BlastTerm,
|
|
130
|
+
): boolean => {
|
|
131
|
+
if (blastAconv(variable, term)) return true;
|
|
132
|
+
if (varOccur(variable.ref, term)) return false;
|
|
133
|
+
if (vars.includes(variable.ref)) variable.ref.value = term;
|
|
134
|
+
else if (term.kind === "Var" && vars.includes(term.ref)) term.ref.value = variable;
|
|
135
|
+
else {
|
|
136
|
+
variable.ref.value = term;
|
|
137
|
+
state.trail.push(variable.ref);
|
|
138
|
+
}
|
|
139
|
+
return true;
|
|
140
|
+
};
|
|
141
|
+
|
|
142
|
+
const unifyAux = (
|
|
143
|
+
state: BlastState,
|
|
144
|
+
vars: readonly VarRef[],
|
|
145
|
+
left: BlastTerm,
|
|
146
|
+
right: BlastTerm,
|
|
147
|
+
): boolean => {
|
|
148
|
+
const normalLeft = wkNorm(left);
|
|
149
|
+
const normalRight = wkNorm(right);
|
|
150
|
+
if (normalLeft.kind === "Var") return updateVar(state, vars, normalLeft, normalRight);
|
|
151
|
+
if (normalRight.kind === "Var") return updateVar(state, vars, normalRight, normalLeft);
|
|
152
|
+
if (normalLeft.kind === "Const" && normalRight.kind === "Const")
|
|
153
|
+
return (
|
|
154
|
+
normalLeft.name === normalRight.name &&
|
|
155
|
+
normalLeft.typargs.length === normalRight.typargs.length &&
|
|
156
|
+
normalLeft.typargs.every((arg, index) =>
|
|
157
|
+
unifyAux(state, vars, arg, normalRight.typargs[index]),
|
|
158
|
+
)
|
|
159
|
+
);
|
|
160
|
+
if (normalLeft.kind === "Abs" && normalRight.kind === "Abs")
|
|
161
|
+
return unifyAux(state, vars, normalLeft.body, normalRight.body);
|
|
162
|
+
if (normalLeft.kind === "App" && normalRight.kind === "App")
|
|
163
|
+
return (
|
|
164
|
+
unifyAux(state, vars, normalLeft.fun, normalRight.fun) &&
|
|
165
|
+
unifyAux(state, vars, normalLeft.arg, normalRight.arg)
|
|
166
|
+
);
|
|
167
|
+
return blastAconv(normalLeft, normalRight);
|
|
168
|
+
};
|
|
169
|
+
|
|
170
|
+
export const unify = (
|
|
171
|
+
state: BlastState,
|
|
172
|
+
vars: readonly VarRef[],
|
|
173
|
+
left: BlastTerm,
|
|
174
|
+
right: BlastTerm,
|
|
175
|
+
): boolean => {
|
|
176
|
+
const start = state.trail.length;
|
|
177
|
+
if (unifyAux(state, vars, left, right)) return true;
|
|
178
|
+
clearTo(state, start);
|
|
179
|
+
return false;
|
|
180
|
+
};
|