tla-ts 0.0.4-dev.0be9567 → 0.0.4-dev.1a3acf6
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 +17 -15
- 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 +16 -20
- 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 +119 -71
- 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,546 @@
|
|
|
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
|
+
// Blast's prototerms: untyped terms whose variables are mutable references, so that unification
|
|
5
|
+
// updates them in place and backtracking resets them from the trail. Constants carry their type
|
|
6
|
+
// arguments as terms, so that overloading is tracked faithfully.
|
|
7
|
+
|
|
8
|
+
import { typargs, type TypargPosition } from "../../pure/consts";
|
|
9
|
+
import {
|
|
10
|
+
dummyT,
|
|
11
|
+
mkApp,
|
|
12
|
+
mkBound,
|
|
13
|
+
mkConst,
|
|
14
|
+
mkFree,
|
|
15
|
+
mkVar,
|
|
16
|
+
type Term,
|
|
17
|
+
type Typ,
|
|
18
|
+
} from "../../pure/term";
|
|
19
|
+
|
|
20
|
+
// A variable's assignment: term option Unsynchronized.ref, compared by identity.
|
|
21
|
+
export interface VarRef {
|
|
22
|
+
value: BlastTerm | undefined;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
// The fields of every kind of prototerm. A prototerm has all of them, with the ones its kind
|
|
26
|
+
// doesn't use undefined, and the constructors below list them in this order. So all prototerms
|
|
27
|
+
// share one object layout, and V8 compiles the many switches on kind to monomorphic loads.
|
|
28
|
+
interface Fields {
|
|
29
|
+
readonly name: string;
|
|
30
|
+
readonly typargs: readonly BlastTerm[];
|
|
31
|
+
readonly args: readonly VarRef[];
|
|
32
|
+
readonly ref: VarRef;
|
|
33
|
+
readonly index: number;
|
|
34
|
+
readonly body: BlastTerm;
|
|
35
|
+
readonly fun: BlastTerm;
|
|
36
|
+
readonly arg: BlastTerm;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
type Prototerm<Kind extends string, Used extends keyof Fields> = { readonly kind: Kind } & Pick<
|
|
40
|
+
Fields,
|
|
41
|
+
Used
|
|
42
|
+
> & { readonly [Key in Exclude<keyof Fields, Used>]: undefined };
|
|
43
|
+
|
|
44
|
+
export type BlastTerm =
|
|
45
|
+
| Prototerm<"Const", "name" | "typargs">
|
|
46
|
+
| Prototerm<"Skolem", "name" | "args">
|
|
47
|
+
| Prototerm<"Free", "name">
|
|
48
|
+
| Prototerm<"Var", "ref">
|
|
49
|
+
| Prototerm<"Bound", "index">
|
|
50
|
+
| Prototerm<"Abs", "name" | "body">
|
|
51
|
+
| Prototerm<"App", "fun" | "arg">;
|
|
52
|
+
|
|
53
|
+
export interface ConstType {
|
|
54
|
+
readonly typargs: readonly TypargPosition[];
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
export const GOAL_NAME = "*Goal*";
|
|
58
|
+
export const FALSE_NAME = "*False*";
|
|
59
|
+
|
|
60
|
+
const NO_TYPARGS: readonly BlastTerm[] = [];
|
|
61
|
+
|
|
62
|
+
export const mkBlastConst = (name: string, typargs = NO_TYPARGS): BlastTerm => ({
|
|
63
|
+
kind: "Const",
|
|
64
|
+
name,
|
|
65
|
+
typargs,
|
|
66
|
+
args: undefined,
|
|
67
|
+
ref: undefined,
|
|
68
|
+
index: undefined,
|
|
69
|
+
body: undefined,
|
|
70
|
+
fun: undefined,
|
|
71
|
+
arg: undefined,
|
|
72
|
+
});
|
|
73
|
+
export const mkBlastSkolem = (name: string, args: readonly VarRef[]): BlastTerm => ({
|
|
74
|
+
kind: "Skolem",
|
|
75
|
+
name,
|
|
76
|
+
typargs: undefined,
|
|
77
|
+
args,
|
|
78
|
+
ref: undefined,
|
|
79
|
+
index: undefined,
|
|
80
|
+
body: undefined,
|
|
81
|
+
fun: undefined,
|
|
82
|
+
arg: undefined,
|
|
83
|
+
});
|
|
84
|
+
export const mkBlastFree = (name: string): BlastTerm => ({
|
|
85
|
+
kind: "Free",
|
|
86
|
+
name,
|
|
87
|
+
typargs: undefined,
|
|
88
|
+
args: undefined,
|
|
89
|
+
ref: undefined,
|
|
90
|
+
index: undefined,
|
|
91
|
+
body: undefined,
|
|
92
|
+
fun: undefined,
|
|
93
|
+
arg: undefined,
|
|
94
|
+
});
|
|
95
|
+
export const mkBlastVar = (ref: VarRef): BlastTerm => ({
|
|
96
|
+
kind: "Var",
|
|
97
|
+
name: undefined,
|
|
98
|
+
typargs: undefined,
|
|
99
|
+
args: undefined,
|
|
100
|
+
ref,
|
|
101
|
+
index: undefined,
|
|
102
|
+
body: undefined,
|
|
103
|
+
fun: undefined,
|
|
104
|
+
arg: undefined,
|
|
105
|
+
});
|
|
106
|
+
export const mkBlastBound = (index: number): BlastTerm => ({
|
|
107
|
+
kind: "Bound",
|
|
108
|
+
name: undefined,
|
|
109
|
+
typargs: undefined,
|
|
110
|
+
args: undefined,
|
|
111
|
+
ref: undefined,
|
|
112
|
+
index,
|
|
113
|
+
body: undefined,
|
|
114
|
+
fun: undefined,
|
|
115
|
+
arg: undefined,
|
|
116
|
+
});
|
|
117
|
+
export const mkBlastAbs = (name: string, body: BlastTerm): BlastTerm => ({
|
|
118
|
+
kind: "Abs",
|
|
119
|
+
name,
|
|
120
|
+
typargs: undefined,
|
|
121
|
+
args: undefined,
|
|
122
|
+
ref: undefined,
|
|
123
|
+
index: undefined,
|
|
124
|
+
body,
|
|
125
|
+
fun: undefined,
|
|
126
|
+
arg: undefined,
|
|
127
|
+
});
|
|
128
|
+
export const mkBlastApp = (fun: BlastTerm, arg: BlastTerm): BlastTerm => ({
|
|
129
|
+
kind: "App",
|
|
130
|
+
name: undefined,
|
|
131
|
+
typargs: undefined,
|
|
132
|
+
args: undefined,
|
|
133
|
+
ref: undefined,
|
|
134
|
+
index: undefined,
|
|
135
|
+
body: undefined,
|
|
136
|
+
fun,
|
|
137
|
+
arg,
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
export const listBlastComb = (head: BlastTerm, args: readonly BlastTerm[]) =>
|
|
141
|
+
args.reduce((result, arg) => mkBlastApp(result, arg), head);
|
|
142
|
+
|
|
143
|
+
// Const (c, _) $ t: the argument of a constant applied to one term, if the term is one.
|
|
144
|
+
export const destConstApp = (term: BlastTerm, name: string): BlastTerm | undefined =>
|
|
145
|
+
term.kind === "App" && term.fun.kind === "Const" && term.fun.name === name ? term.arg : undefined;
|
|
146
|
+
|
|
147
|
+
export const mkGoal = (term: BlastTerm) => mkBlastApp(mkBlastConst(GOAL_NAME), term);
|
|
148
|
+
|
|
149
|
+
export const isGoal = (term: BlastTerm) => destConstApp(term, GOAL_NAME) !== undefined;
|
|
150
|
+
|
|
151
|
+
// Tests whether two terms are alpha-convertible, chasing instantiations.
|
|
152
|
+
export const blastAconv = (left: BlastTerm, right: BlastTerm): boolean => {
|
|
153
|
+
if (left === right) return true;
|
|
154
|
+
if (left.kind === "Const" && right.kind === "Const")
|
|
155
|
+
return left.name === right.name && blastAconvs(left.typargs, right.typargs);
|
|
156
|
+
if (left.kind === "Skolem" && right.kind === "Skolem") return left.name === right.name;
|
|
157
|
+
if (left.kind === "Free" && right.kind === "Free") return left.name === right.name;
|
|
158
|
+
if (left.kind === "Var" && left.ref.value !== undefined) return blastAconv(left.ref.value, right);
|
|
159
|
+
if (right.kind === "Var" && right.ref.value !== undefined)
|
|
160
|
+
return blastAconv(left, right.ref.value);
|
|
161
|
+
if (left.kind === "Var" && right.kind === "Var") return left.ref === right.ref;
|
|
162
|
+
if (left.kind === "Bound" && right.kind === "Bound") return left.index === right.index;
|
|
163
|
+
if (left.kind === "Abs" && right.kind === "Abs") return blastAconv(left.body, right.body);
|
|
164
|
+
if (left.kind === "App" && right.kind === "App")
|
|
165
|
+
return blastAconv(left.fun, right.fun) && blastAconv(left.arg, right.arg);
|
|
166
|
+
return false;
|
|
167
|
+
};
|
|
168
|
+
|
|
169
|
+
const blastAconvs = (lefts: readonly BlastTerm[], rights: readonly BlastTerm[]) =>
|
|
170
|
+
lefts.length === rights.length && lefts.every((left, index) => blastAconv(left, rights[index]));
|
|
171
|
+
|
|
172
|
+
const memTerm = (term: BlastTerm, terms: readonly BlastTerm[]) =>
|
|
173
|
+
terms.some((other) => blastAconv(term, other));
|
|
174
|
+
|
|
175
|
+
export const insTerm = (term: BlastTerm, terms: readonly BlastTerm[]) =>
|
|
176
|
+
memTerm(term, terms) ? terms : [term, ...terms];
|
|
177
|
+
|
|
178
|
+
export const sameVars = (left: readonly VarRef[], right: readonly VarRef[]) =>
|
|
179
|
+
left.length === right.length && left.every((ref, index) => ref === right[index]);
|
|
180
|
+
|
|
181
|
+
const memVar = (ref: VarRef, refs: readonly VarRef[]) => refs.includes(ref);
|
|
182
|
+
|
|
183
|
+
const insVar = (ref: VarRef, refs: readonly VarRef[]) =>
|
|
184
|
+
memVar(ref, refs) ? refs : [ref, ...refs];
|
|
185
|
+
|
|
186
|
+
// Accumulates the unassigned variables of a term, suppressing duplicates.
|
|
187
|
+
export const addTermVars = (term: BlastTerm, refs: readonly VarRef[]): readonly VarRef[] => {
|
|
188
|
+
switch (term.kind) {
|
|
189
|
+
case "Skolem":
|
|
190
|
+
return addVarsVars(term.args, refs);
|
|
191
|
+
case "Var":
|
|
192
|
+
return term.ref.value === undefined
|
|
193
|
+
? insVar(term.ref, refs)
|
|
194
|
+
: addTermVars(term.ref.value, refs);
|
|
195
|
+
case "Const":
|
|
196
|
+
return addTermsVars(term.typargs, refs);
|
|
197
|
+
case "Abs":
|
|
198
|
+
return addTermVars(term.body, refs);
|
|
199
|
+
case "App":
|
|
200
|
+
return addTermVars(term.fun, addTermVars(term.arg, refs));
|
|
201
|
+
default:
|
|
202
|
+
return refs;
|
|
203
|
+
}
|
|
204
|
+
};
|
|
205
|
+
|
|
206
|
+
export const addTermsVars = (terms: readonly BlastTerm[], refs: readonly VarRef[]) =>
|
|
207
|
+
terms.reduce((result, term) => addTermVars(term, result), refs);
|
|
208
|
+
|
|
209
|
+
const addVarsVars = (vars: readonly VarRef[], refs: readonly VarRef[]) =>
|
|
210
|
+
vars.reduce(
|
|
211
|
+
(result, ref) =>
|
|
212
|
+
ref.value === undefined ? insVar(ref, result) : addTermVars(ref.value, result),
|
|
213
|
+
refs,
|
|
214
|
+
);
|
|
215
|
+
|
|
216
|
+
// Chases the assignments of the variables, returning the unassigned ones.
|
|
217
|
+
export const varsInVars = (refs: readonly VarRef[]) => addVarsVars(refs, []);
|
|
218
|
+
|
|
219
|
+
const incrBv = (increment: number, level: number, term: BlastTerm): BlastTerm => {
|
|
220
|
+
switch (term.kind) {
|
|
221
|
+
case "Bound":
|
|
222
|
+
return term.index >= level ? mkBlastBound(term.index + increment) : term;
|
|
223
|
+
case "Abs":
|
|
224
|
+
return mkBlastAbs(term.name, incrBv(increment, level + 1, term.body));
|
|
225
|
+
case "App":
|
|
226
|
+
return mkBlastApp(incrBv(increment, level, term.fun), incrBv(increment, level, term.arg));
|
|
227
|
+
default:
|
|
228
|
+
return term;
|
|
229
|
+
}
|
|
230
|
+
};
|
|
231
|
+
|
|
232
|
+
export const incrBlastBoundvars = (increment: number, term: BlastTerm) =>
|
|
233
|
+
increment === 0 ? term : incrBv(increment, 0, term);
|
|
234
|
+
|
|
235
|
+
// member (op =) (loose_bnos term) 0, which does not chase variables.
|
|
236
|
+
export const hasLooseBound0 = (term: BlastTerm, level = 0): boolean => {
|
|
237
|
+
switch (term.kind) {
|
|
238
|
+
case "Bound":
|
|
239
|
+
return term.index === level;
|
|
240
|
+
case "Abs":
|
|
241
|
+
return hasLooseBound0(term.body, level + 1);
|
|
242
|
+
case "App":
|
|
243
|
+
return hasLooseBound0(term.fun, level) || hasLooseBound0(term.arg, level);
|
|
244
|
+
default:
|
|
245
|
+
return false;
|
|
246
|
+
}
|
|
247
|
+
};
|
|
248
|
+
|
|
249
|
+
const substBoundAt = (arg: BlastTerm, level: number, term: BlastTerm): BlastTerm => {
|
|
250
|
+
switch (term.kind) {
|
|
251
|
+
case "Bound":
|
|
252
|
+
if (term.index < level) return term;
|
|
253
|
+
return term.index === level ? incrBlastBoundvars(level, arg) : mkBlastBound(term.index - 1);
|
|
254
|
+
case "Abs":
|
|
255
|
+
return mkBlastAbs(term.name, substBoundAt(arg, level + 1, term.body));
|
|
256
|
+
case "App":
|
|
257
|
+
return mkBlastApp(substBoundAt(arg, level, term.fun), substBoundAt(arg, level, term.arg));
|
|
258
|
+
default:
|
|
259
|
+
return term;
|
|
260
|
+
}
|
|
261
|
+
};
|
|
262
|
+
|
|
263
|
+
export const blastSubstBound = (arg: BlastTerm, body: BlastTerm) => substBoundAt(arg, 0, body);
|
|
264
|
+
|
|
265
|
+
// Normalizes, but not the bodies of abstractions. Returns the very same term where nothing
|
|
266
|
+
// changes, so normalizing a normal formula allocates nothing.
|
|
267
|
+
export const norm = (term: BlastTerm): BlastTerm => {
|
|
268
|
+
switch (term.kind) {
|
|
269
|
+
case "Skolem": {
|
|
270
|
+
const args = varsInVars(term.args);
|
|
271
|
+
return sameVars(args, term.args) ? term : mkBlastSkolem(term.name, args);
|
|
272
|
+
}
|
|
273
|
+
case "Const": {
|
|
274
|
+
if (term.typargs.length === 0) return term;
|
|
275
|
+
const typargs = term.typargs.map(norm);
|
|
276
|
+
return typargs.every((arg, index) => arg === term.typargs[index])
|
|
277
|
+
? term
|
|
278
|
+
: mkBlastConst(term.name, typargs);
|
|
279
|
+
}
|
|
280
|
+
case "Var":
|
|
281
|
+
return term.ref.value === undefined ? term : norm(term.ref.value);
|
|
282
|
+
case "App": {
|
|
283
|
+
const fun = norm(term.fun);
|
|
284
|
+
if (fun.kind === "Abs") return norm(blastSubstBound(term.arg, fun.body));
|
|
285
|
+
const arg = norm(term.arg);
|
|
286
|
+
return fun === term.fun && arg === term.arg ? term : mkBlastApp(fun, arg);
|
|
287
|
+
}
|
|
288
|
+
default:
|
|
289
|
+
return term;
|
|
290
|
+
}
|
|
291
|
+
};
|
|
292
|
+
|
|
293
|
+
const blastHeadOf = (term: BlastTerm) => {
|
|
294
|
+
let head = term;
|
|
295
|
+
while (head.kind === "App") head = head.fun;
|
|
296
|
+
return head;
|
|
297
|
+
};
|
|
298
|
+
|
|
299
|
+
const wkNormAux = (term: BlastTerm): BlastTerm => {
|
|
300
|
+
switch (term.kind) {
|
|
301
|
+
case "Var":
|
|
302
|
+
return term.ref.value === undefined ? term : wkNorm(term.ref.value);
|
|
303
|
+
case "App": {
|
|
304
|
+
const fun = wkNormAux(term.fun);
|
|
305
|
+
return fun.kind === "Abs"
|
|
306
|
+
? wkNorm(blastSubstBound(term.arg, fun.body))
|
|
307
|
+
: mkBlastApp(fun, term.arg);
|
|
308
|
+
}
|
|
309
|
+
case "Abs": {
|
|
310
|
+
const body = wkNormAux(term.body);
|
|
311
|
+
if (body.kind !== "App") return mkBlastAbs(term.name, body);
|
|
312
|
+
const arg = wkNorm(body.arg);
|
|
313
|
+
return hasLooseBound0(body.fun) || arg.kind !== "Bound" || arg.index !== 0
|
|
314
|
+
? mkBlastAbs(term.name, body)
|
|
315
|
+
: wkNorm(incrBlastBoundvars(-1, body.fun));
|
|
316
|
+
}
|
|
317
|
+
default:
|
|
318
|
+
return term;
|
|
319
|
+
}
|
|
320
|
+
};
|
|
321
|
+
|
|
322
|
+
// Weak, one-level normalization for unification; eta-contracts where it can.
|
|
323
|
+
export const wkNorm = (term: BlastTerm): BlastTerm => {
|
|
324
|
+
const head = blastHeadOf(term);
|
|
325
|
+
return head.kind === "Const" || head.kind === "Skolem" || head.kind === "Free"
|
|
326
|
+
? term
|
|
327
|
+
: wkNormAux(term);
|
|
328
|
+
};
|
|
329
|
+
|
|
330
|
+
// Does variable ref occur in term? Dangling bound variables count as occurrences too.
|
|
331
|
+
const occurs = (ref: VarRef, level: number, term: BlastTerm): boolean => {
|
|
332
|
+
switch (term.kind) {
|
|
333
|
+
case "Var":
|
|
334
|
+
return (
|
|
335
|
+
ref === term.ref || (term.ref.value !== undefined && occurs(ref, level, term.ref.value))
|
|
336
|
+
);
|
|
337
|
+
case "Skolem":
|
|
338
|
+
return term.args.some(
|
|
339
|
+
(arg) => ref === arg || (arg.value !== undefined && occurs(ref, level, arg.value)),
|
|
340
|
+
);
|
|
341
|
+
case "Bound":
|
|
342
|
+
return level <= term.index;
|
|
343
|
+
case "Abs":
|
|
344
|
+
return occurs(ref, level + 1, term.body);
|
|
345
|
+
case "App":
|
|
346
|
+
return occurs(ref, level, term.arg) || occurs(ref, level, term.fun);
|
|
347
|
+
default:
|
|
348
|
+
return false;
|
|
349
|
+
}
|
|
350
|
+
};
|
|
351
|
+
|
|
352
|
+
export const varOccur = (ref: VarRef, term: BlastTerm) => occurs(ref, 0, term);
|
|
353
|
+
|
|
354
|
+
// An entry of the association lists from schematic variables to prototerms that fromTerm keeps.
|
|
355
|
+
export interface VarEntry {
|
|
356
|
+
readonly name: string;
|
|
357
|
+
readonly index: number;
|
|
358
|
+
readonly term: BlastTerm;
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
// AList.lookup, adding a fresh variable for a new one.
|
|
362
|
+
const lookupVar = (entries: VarEntry[], name: string, index: number): BlastTerm => {
|
|
363
|
+
const known = entries.find((entry) => entry.index === index && entry.name === name);
|
|
364
|
+
if (known !== undefined) return known.term;
|
|
365
|
+
const fresh = mkBlastVar({ value: undefined });
|
|
366
|
+
entries.push({ name, index, term: fresh });
|
|
367
|
+
return fresh;
|
|
368
|
+
};
|
|
369
|
+
|
|
370
|
+
const fromType = (tvars: VarEntry[], type: Typ): BlastTerm => {
|
|
371
|
+
if (type.kind === "Type")
|
|
372
|
+
return listBlastComb(
|
|
373
|
+
mkBlastConst(type.name),
|
|
374
|
+
type.args.map((arg) => fromType(tvars, arg)),
|
|
375
|
+
);
|
|
376
|
+
if (type.kind === "TFree") return mkBlastFree(type.name);
|
|
377
|
+
return lookupVar(tvars, type.name, type.index);
|
|
378
|
+
};
|
|
379
|
+
|
|
380
|
+
export const fromConst = (
|
|
381
|
+
consts: ReadonlyMap<string, ConstType>,
|
|
382
|
+
tvars: VarEntry[],
|
|
383
|
+
name: string,
|
|
384
|
+
type: Typ,
|
|
385
|
+
) => {
|
|
386
|
+
const declared = consts.get(name);
|
|
387
|
+
// Sign.const_typargs. Constants the map lacks are the ones a theory declares, which have none.
|
|
388
|
+
return declared === undefined || declared.typargs.length === 0
|
|
389
|
+
? mkBlastConst(name)
|
|
390
|
+
: mkBlastConst(
|
|
391
|
+
name,
|
|
392
|
+
typargs(declared.typargs, type).map((arg) => fromType(tvars, arg)),
|
|
393
|
+
);
|
|
394
|
+
};
|
|
395
|
+
|
|
396
|
+
const fromTermAux = (
|
|
397
|
+
consts: ReadonlyMap<string, ConstType>,
|
|
398
|
+
vars: VarEntry[],
|
|
399
|
+
tvars: VarEntry[],
|
|
400
|
+
term: Term,
|
|
401
|
+
): BlastTerm => {
|
|
402
|
+
switch (term.kind) {
|
|
403
|
+
case "Const":
|
|
404
|
+
return fromConst(consts, tvars, term.name, term.type);
|
|
405
|
+
case "Free":
|
|
406
|
+
return mkBlastFree(term.name);
|
|
407
|
+
case "Bound":
|
|
408
|
+
return mkBlastBound(term.index);
|
|
409
|
+
case "Var":
|
|
410
|
+
return lookupVar(vars, term.name, term.index);
|
|
411
|
+
case "Abs": {
|
|
412
|
+
const body = fromTermAux(consts, vars, tvars, term.body);
|
|
413
|
+
return body.kind === "App" &&
|
|
414
|
+
body.arg.kind === "Bound" &&
|
|
415
|
+
body.arg.index === 0 &&
|
|
416
|
+
!hasLooseBound0(body.fun)
|
|
417
|
+
? incrBlastBoundvars(-1, body.fun)
|
|
418
|
+
: mkBlastAbs(term.name, body);
|
|
419
|
+
}
|
|
420
|
+
case "App":
|
|
421
|
+
return mkBlastApp(
|
|
422
|
+
fromTermAux(consts, vars, tvars, term.fun),
|
|
423
|
+
fromTermAux(consts, vars, tvars, term.arg),
|
|
424
|
+
);
|
|
425
|
+
}
|
|
426
|
+
};
|
|
427
|
+
|
|
428
|
+
// Converts a real term to a prototerm, eta-contracting it.
|
|
429
|
+
export const fromTerm = (consts: ReadonlyMap<string, ConstType>, term: Term): BlastTerm =>
|
|
430
|
+
fromTermAux(consts, [], [], term);
|
|
431
|
+
|
|
432
|
+
// A prototerm with its variables and Skolem terms numbered, so that instantiating it with fresh
|
|
433
|
+
// ones gives a copy that shares the parts without them, which blast never updates.
|
|
434
|
+
export type Template =
|
|
435
|
+
| { readonly kind: "ground"; readonly term: BlastTerm }
|
|
436
|
+
| { readonly kind: "var"; readonly index: number }
|
|
437
|
+
| { readonly kind: "skolem"; readonly slot: number }
|
|
438
|
+
| { readonly kind: "const"; readonly name: string; readonly typargs: readonly Template[] }
|
|
439
|
+
| { readonly kind: "abs"; readonly name: string; readonly body: Template }
|
|
440
|
+
| { readonly kind: "app"; readonly fun: Template; readonly arg: Template };
|
|
441
|
+
|
|
442
|
+
const isGround = (template: Template) => template.kind === "ground";
|
|
443
|
+
|
|
444
|
+
// Numbers the variables in refs, adding new ones, and the Skolem terms by their place in skolems.
|
|
445
|
+
export const toTemplate = (
|
|
446
|
+
refs: VarRef[],
|
|
447
|
+
skolems: readonly BlastTerm[],
|
|
448
|
+
term: BlastTerm,
|
|
449
|
+
): Template => {
|
|
450
|
+
switch (term.kind) {
|
|
451
|
+
case "Var": {
|
|
452
|
+
const index = refs.indexOf(term.ref);
|
|
453
|
+
if (index >= 0) return { kind: "var", index };
|
|
454
|
+
refs.push(term.ref);
|
|
455
|
+
return { kind: "var", index: refs.length - 1 };
|
|
456
|
+
}
|
|
457
|
+
case "Skolem": {
|
|
458
|
+
const slot = skolems.indexOf(term);
|
|
459
|
+
return slot >= 0 ? { kind: "skolem", slot } : { kind: "ground", term };
|
|
460
|
+
}
|
|
461
|
+
case "Const": {
|
|
462
|
+
const typargs = term.typargs.map((arg) => toTemplate(refs, skolems, arg));
|
|
463
|
+
return typargs.every(isGround)
|
|
464
|
+
? { kind: "ground", term }
|
|
465
|
+
: { kind: "const", name: term.name, typargs };
|
|
466
|
+
}
|
|
467
|
+
case "Abs": {
|
|
468
|
+
const body = toTemplate(refs, skolems, term.body);
|
|
469
|
+
return isGround(body) ? { kind: "ground", term } : { kind: "abs", name: term.name, body };
|
|
470
|
+
}
|
|
471
|
+
case "App": {
|
|
472
|
+
const fun = toTemplate(refs, skolems, term.fun);
|
|
473
|
+
const arg = toTemplate(refs, skolems, term.arg);
|
|
474
|
+
return isGround(fun) && isGround(arg) ? { kind: "ground", term } : { kind: "app", fun, arg };
|
|
475
|
+
}
|
|
476
|
+
default:
|
|
477
|
+
return { kind: "ground", term };
|
|
478
|
+
}
|
|
479
|
+
};
|
|
480
|
+
|
|
481
|
+
export const instantiateTemplate = (
|
|
482
|
+
vars: readonly BlastTerm[],
|
|
483
|
+
skolems: readonly BlastTerm[],
|
|
484
|
+
template: Template,
|
|
485
|
+
): BlastTerm => {
|
|
486
|
+
switch (template.kind) {
|
|
487
|
+
case "ground":
|
|
488
|
+
return template.term;
|
|
489
|
+
case "var":
|
|
490
|
+
return vars[template.index];
|
|
491
|
+
case "skolem":
|
|
492
|
+
return skolems[template.slot];
|
|
493
|
+
case "const":
|
|
494
|
+
return mkBlastConst(
|
|
495
|
+
template.name,
|
|
496
|
+
template.typargs.map((arg) => instantiateTemplate(vars, skolems, arg)),
|
|
497
|
+
);
|
|
498
|
+
case "abs":
|
|
499
|
+
return mkBlastAbs(template.name, instantiateTemplate(vars, skolems, template.body));
|
|
500
|
+
case "app":
|
|
501
|
+
return mkBlastApp(
|
|
502
|
+
instantiateTemplate(vars, skolems, template.fun),
|
|
503
|
+
instantiateTemplate(vars, skolems, template.arg),
|
|
504
|
+
);
|
|
505
|
+
}
|
|
506
|
+
};
|
|
507
|
+
|
|
508
|
+
const dummyVar = mkVar("etc", 0, dummyT);
|
|
509
|
+
|
|
510
|
+
// Converts a prototerm to a real term with dummy types for net lookup, stopping at depth.
|
|
511
|
+
export const toTerm = (depth: number, term: BlastTerm): Term => {
|
|
512
|
+
if (depth === 0) return dummyVar;
|
|
513
|
+
switch (term.kind) {
|
|
514
|
+
case "Const":
|
|
515
|
+
case "Skolem":
|
|
516
|
+
return mkConst(term.name, dummyT);
|
|
517
|
+
case "Free":
|
|
518
|
+
return mkFree(term.name, dummyT);
|
|
519
|
+
case "Bound":
|
|
520
|
+
return mkBound(term.index);
|
|
521
|
+
case "App":
|
|
522
|
+
return mkApp(toTerm(depth, term.fun), toTerm(depth - 1, term.arg));
|
|
523
|
+
default:
|
|
524
|
+
return dummyVar;
|
|
525
|
+
}
|
|
526
|
+
};
|
|
527
|
+
|
|
528
|
+
const stripTrueprop = (trueprop: string, term: BlastTerm) => destConstApp(term, trueprop) ?? term;
|
|
529
|
+
|
|
530
|
+
// A1 ==> ... ==> An ==> B goes to [A1, ..., An], where B is not an implication.
|
|
531
|
+
export const stripBlastImpPrems = (trueprop: string, term: BlastTerm): BlastTerm[] =>
|
|
532
|
+
term.kind === "App" &&
|
|
533
|
+
term.fun.kind === "App" &&
|
|
534
|
+
term.fun.fun.kind === "Const" &&
|
|
535
|
+
term.fun.fun.name === "Pure.imp"
|
|
536
|
+
? [stripTrueprop(trueprop, term.fun.arg), ...stripBlastImpPrems(trueprop, term.arg)]
|
|
537
|
+
: [];
|
|
538
|
+
|
|
539
|
+
// A1 ==> ... ==> An ==> B goes to B, where B is not an implication.
|
|
540
|
+
export const stripBlastImpConcl = (trueprop: string, term: BlastTerm): BlastTerm =>
|
|
541
|
+
term.kind === "App" &&
|
|
542
|
+
term.fun.kind === "App" &&
|
|
543
|
+
term.fun.fun.kind === "Const" &&
|
|
544
|
+
term.fun.fun.name === "Pure.imp"
|
|
545
|
+
? stripBlastImpConcl(trueprop, term.arg)
|
|
546
|
+
: stripTrueprop(trueprop, term);
|
|
@@ -0,0 +1,150 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Provers/clasimp.ML and the prune_params_tac of Pure/tactic.ML.
|
|
2
|
+
// Copyright (c) 1986-2025 University of Cambridge, Technische Universitaet Muenchen, and
|
|
3
|
+
// contributors, see LICENSE.
|
|
4
|
+
//
|
|
5
|
+
// The classical reasoner combined with the simplifier: auto, clarsimp and force.
|
|
6
|
+
|
|
7
|
+
import { trivForallEquality } from "../pure/drule";
|
|
8
|
+
import { selectGoal } from "../pure/goal";
|
|
9
|
+
import { addSimps, emptySimpset, type SimpContext } from "../pure/raw-simplifier";
|
|
10
|
+
import { gconvRule } from "../pure/conv";
|
|
11
|
+
import { rewriteCterm, simpleProver } from "../pure/rewriter";
|
|
12
|
+
import { asmFullSimpTac, safeAsmFullSimpTac } from "../pure/simplifier";
|
|
13
|
+
import {
|
|
14
|
+
allGoals,
|
|
15
|
+
allTac,
|
|
16
|
+
appendTac,
|
|
17
|
+
changed,
|
|
18
|
+
depthSolve,
|
|
19
|
+
determ,
|
|
20
|
+
every,
|
|
21
|
+
firstGoalTac,
|
|
22
|
+
noTac,
|
|
23
|
+
orElseGoal,
|
|
24
|
+
primitive,
|
|
25
|
+
repeatDeterm,
|
|
26
|
+
thenAllNew,
|
|
27
|
+
thenElse,
|
|
28
|
+
thenTac,
|
|
29
|
+
tryTac,
|
|
30
|
+
type GoalTactic,
|
|
31
|
+
type Tactic,
|
|
32
|
+
} from "../pure/tactical";
|
|
33
|
+
import { nprems, type Thm } from "../pure/thm";
|
|
34
|
+
import {
|
|
35
|
+
addbefore,
|
|
36
|
+
addSafter,
|
|
37
|
+
appWrappers,
|
|
38
|
+
clarifyTac,
|
|
39
|
+
firstBestTac,
|
|
40
|
+
inst0StepTac,
|
|
41
|
+
instpStepTac,
|
|
42
|
+
safeStepsTac,
|
|
43
|
+
safeTac,
|
|
44
|
+
unsafeStepTac,
|
|
45
|
+
withClaset,
|
|
46
|
+
type ClassicalContext,
|
|
47
|
+
} from "./classical";
|
|
48
|
+
|
|
49
|
+
export interface ClasimpContext {
|
|
50
|
+
readonly classical: ClassicalContext;
|
|
51
|
+
readonly simp: SimpContext;
|
|
52
|
+
// Blast.depth_tac, the Blast argument of the Clasimp functor.
|
|
53
|
+
readonly blastDepthTac: (context: ClassicalContext, limit: number) => GoalTactic;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
// addss: the simplifier as an unsafe wrapper.
|
|
57
|
+
const addss = (context: ClasimpContext): ClassicalContext =>
|
|
58
|
+
withClaset(
|
|
59
|
+
context.classical,
|
|
60
|
+
addbefore(context.classical.claset, "asm_full_simp_tac", (index) =>
|
|
61
|
+
changed(asmFullSimpTac(context.simp)(index)),
|
|
62
|
+
),
|
|
63
|
+
);
|
|
64
|
+
|
|
65
|
+
// addSss: the simplifier as a safe wrapper.
|
|
66
|
+
const addSss = (context: ClasimpContext): ClassicalContext =>
|
|
67
|
+
withClaset(
|
|
68
|
+
context.classical,
|
|
69
|
+
addSafter(context.classical.claset, "safe_asm_full_simp_tac", (index) =>
|
|
70
|
+
changed(safeAsmFullSimpTac(context.simp)(index)),
|
|
71
|
+
),
|
|
72
|
+
);
|
|
73
|
+
|
|
74
|
+
export const clarsimpTac = (context: ClasimpContext): GoalTactic =>
|
|
75
|
+
thenAllNew(safeAsmFullSimpTac(context.simp), clarifyTac(addSss(context)));
|
|
76
|
+
|
|
77
|
+
// A variant of Classical.depth_tac that keeps the simplifier from interfering with dup_step_tac.
|
|
78
|
+
const nodupDepthTac =
|
|
79
|
+
(context: ClassicalContext, limit: number): GoalTactic =>
|
|
80
|
+
(index) =>
|
|
81
|
+
(state) =>
|
|
82
|
+
selectGoal(
|
|
83
|
+
thenElse(
|
|
84
|
+
safeStepsTac(context)(1),
|
|
85
|
+
depthSolve(nodupDepthTac(context, limit)(1)),
|
|
86
|
+
appendTac(
|
|
87
|
+
inst0StepTac(context)(1),
|
|
88
|
+
limit === 0
|
|
89
|
+
? noTac
|
|
90
|
+
: thenTac(
|
|
91
|
+
appWrappers(context, (goal) =>
|
|
92
|
+
appendTac(instpStepTac(context)(goal), unsafeStepTac(context)(goal)),
|
|
93
|
+
)(1),
|
|
94
|
+
depthSolve(nodupDepthTac(context, limit - 1)(1)),
|
|
95
|
+
),
|
|
96
|
+
),
|
|
97
|
+
),
|
|
98
|
+
)(index)(state);
|
|
99
|
+
|
|
100
|
+
// prune_params_tac: drops the parameters that no goal uses.
|
|
101
|
+
const pruneParamsTac = (simp: SimpContext): Tactic => {
|
|
102
|
+
const empty = { ...simp, simpset: emptySimpset };
|
|
103
|
+
const context = { ...empty, simpset: addSimps(empty, [trivForallEquality]) };
|
|
104
|
+
return primitive((state) =>
|
|
105
|
+
Array.from({ length: nprems(state) }, (_, offset) => offset + 1).reduce(
|
|
106
|
+
(current, index) =>
|
|
107
|
+
gconvRule(
|
|
108
|
+
(term) =>
|
|
109
|
+
rewriteCterm(
|
|
110
|
+
{ simprem: true, useprem: true, mutsimp: true },
|
|
111
|
+
simpleProver,
|
|
112
|
+
context,
|
|
113
|
+
term,
|
|
114
|
+
),
|
|
115
|
+
index,
|
|
116
|
+
current,
|
|
117
|
+
),
|
|
118
|
+
state,
|
|
119
|
+
),
|
|
120
|
+
);
|
|
121
|
+
};
|
|
122
|
+
|
|
123
|
+
const mkAutoTac = (context: ClasimpContext, depth: number, nodupDepth: number): Tactic => {
|
|
124
|
+
const mainTac = orElseGoal(context.blastDepthTac(context.classical, depth), (index) =>
|
|
125
|
+
changed(nodupDepthTac(addss(context), nodupDepth)(index)),
|
|
126
|
+
);
|
|
127
|
+
return every([
|
|
128
|
+
// PARALLEL_ALLGOALS simplifies each goal on its own only when no goal has schematic variables,
|
|
129
|
+
// which gives the same result as simplifying them in turn.
|
|
130
|
+
determ(allGoals(asmFullSimpTac(context.simp))),
|
|
131
|
+
tryTac(safeTac(context.classical)),
|
|
132
|
+
repeatDeterm(firstGoalTac(mainTac)),
|
|
133
|
+
tryTac(safeTac(addSss(context))),
|
|
134
|
+
pruneParamsTac(context.simp),
|
|
135
|
+
]);
|
|
136
|
+
};
|
|
137
|
+
|
|
138
|
+
export const autoTac = (context: ClasimpContext) => mkAutoTac(context, 4, 2);
|
|
139
|
+
|
|
140
|
+
// force_tac: aims to solve the goal outright, with clarify, the simplifier and best-first search.
|
|
141
|
+
export const forceTac = (context: ClasimpContext, atomizeRules: readonly Thm[]): GoalTactic => {
|
|
142
|
+
const classical = addss(context);
|
|
143
|
+
return selectGoal(
|
|
144
|
+
every([
|
|
145
|
+
clarifyTac(classical)(1),
|
|
146
|
+
(state) => (nprems(state) === 0 ? allTac(state) : asmFullSimpTac(context.simp)(1)(state)),
|
|
147
|
+
allGoals(firstBestTac(classical, atomizeRules)),
|
|
148
|
+
]),
|
|
149
|
+
);
|
|
150
|
+
};
|