tla-ts 0.0.4-dev.a0009b7 → 0.0.4-dev.a11a30a
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 +32 -143
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +35 -1
- package/dist/index.d.ts +35 -1
- 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 +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -47
- package/dist/run-cli.js +37 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/codegen.ts +26 -7
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +63 -20
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
- package/src/{obligation-source.ts → obligations/source.ts} +154 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +446 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +508 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +529 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +181 -0
- package/src/prove/smt/rewrite.ts +772 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +379 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +283 -81
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +97 -47
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,650 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/pattern.ML and Pure/more_pattern.ML. Copyright (c) 1986-2025
|
|
2
|
+
// University of Cambridge, Technische Universitaet Muenchen, and contributors, see LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// Unification and matching of higher-order patterns. Isabelle signals failure with the
|
|
5
|
+
// exceptions Unif, Pattern and MATCH; here they stay inside this module and the exported
|
|
6
|
+
// functions return undefined instead.
|
|
7
|
+
|
|
8
|
+
import { TlaIsabelleError } from "../../../errors";
|
|
9
|
+
import {
|
|
10
|
+
aeconv,
|
|
11
|
+
emptyTEnv,
|
|
12
|
+
genvar,
|
|
13
|
+
headNorm,
|
|
14
|
+
lookup,
|
|
15
|
+
lookup1,
|
|
16
|
+
substTerm,
|
|
17
|
+
update,
|
|
18
|
+
type Envir,
|
|
19
|
+
type TEnv,
|
|
20
|
+
} from "./envir";
|
|
21
|
+
import { hasKey, indexnameOrd, updateTable } from "./table";
|
|
22
|
+
import {
|
|
23
|
+
eqTyp,
|
|
24
|
+
fastypeOf,
|
|
25
|
+
funTs,
|
|
26
|
+
flagsOf,
|
|
27
|
+
HAS_VAR,
|
|
28
|
+
isOpen,
|
|
29
|
+
listComb,
|
|
30
|
+
looseBnos,
|
|
31
|
+
mkAbs,
|
|
32
|
+
mkApp,
|
|
33
|
+
mkBound,
|
|
34
|
+
renameAbs,
|
|
35
|
+
stripComb,
|
|
36
|
+
aconv,
|
|
37
|
+
type Term,
|
|
38
|
+
type Typ,
|
|
39
|
+
type Var,
|
|
40
|
+
} from "./term";
|
|
41
|
+
import { emptyTyEnv, matchTypes, normType, substType, unifyTypes, type TyEnv } from "./type";
|
|
42
|
+
|
|
43
|
+
class Unif {}
|
|
44
|
+
class NotPattern {}
|
|
45
|
+
class Match {}
|
|
46
|
+
|
|
47
|
+
interface Binder {
|
|
48
|
+
name: string;
|
|
49
|
+
type: Typ;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
const occurs = (variable: Var, term: Term, envir: Envir): boolean => {
|
|
53
|
+
const visit = (current: Term): boolean => {
|
|
54
|
+
if ((flagsOf(current) & HAS_VAR) === 0) return false;
|
|
55
|
+
switch (current.kind) {
|
|
56
|
+
case "Var": {
|
|
57
|
+
const assigned = lookup(envir, current);
|
|
58
|
+
return assigned === undefined
|
|
59
|
+
? current.name === variable.name && current.index === variable.index
|
|
60
|
+
: visit(assigned);
|
|
61
|
+
}
|
|
62
|
+
case "App":
|
|
63
|
+
return visit(current.fun) || visit(current.arg);
|
|
64
|
+
case "Abs":
|
|
65
|
+
return visit(current.body);
|
|
66
|
+
default:
|
|
67
|
+
return false;
|
|
68
|
+
}
|
|
69
|
+
};
|
|
70
|
+
return visit(term);
|
|
71
|
+
};
|
|
72
|
+
|
|
73
|
+
const mapBound = (map: (index: number) => number, term: Term): Term => {
|
|
74
|
+
const visit = (current: Term, depth: number): Term => {
|
|
75
|
+
switch (current.kind) {
|
|
76
|
+
case "Bound":
|
|
77
|
+
return current.index < depth ? current : mkBound(map(current.index - depth) + depth);
|
|
78
|
+
case "Abs":
|
|
79
|
+
return mkAbs(current.name, current.type, visit(current.body, depth + 1));
|
|
80
|
+
case "App":
|
|
81
|
+
return mkApp(visit(current.fun, depth), visit(current.arg, depth));
|
|
82
|
+
default:
|
|
83
|
+
return current;
|
|
84
|
+
}
|
|
85
|
+
};
|
|
86
|
+
return visit(term, 0);
|
|
87
|
+
};
|
|
88
|
+
|
|
89
|
+
const indexOf = (indexes: readonly number[], target: number) => {
|
|
90
|
+
const position = indexes.indexOf(target);
|
|
91
|
+
if (position === -1) throw new Unif();
|
|
92
|
+
return indexes.length - 1 - position;
|
|
93
|
+
};
|
|
94
|
+
|
|
95
|
+
const mkAbsOver = (binders: readonly Binder[], indexes: readonly number[], body: Term): Term =>
|
|
96
|
+
indexes.reduceRight((result, index) => {
|
|
97
|
+
const binder = binders[index];
|
|
98
|
+
return mkAbs(binder.name, binder.type, result);
|
|
99
|
+
}, body);
|
|
100
|
+
|
|
101
|
+
const incr = (term: Term) => mapBound((index) => index + 1, term);
|
|
102
|
+
|
|
103
|
+
const intsOf = (terms: readonly Term[]): number[] => {
|
|
104
|
+
const indexes: number[] = [];
|
|
105
|
+
for (let position = terms.length - 1; position >= 0; position -= 1) {
|
|
106
|
+
const term = terms[position];
|
|
107
|
+
if (term.kind !== "Bound" || indexes.includes(term.index)) throw new NotPattern();
|
|
108
|
+
indexes.unshift(term.index);
|
|
109
|
+
}
|
|
110
|
+
return indexes;
|
|
111
|
+
};
|
|
112
|
+
|
|
113
|
+
const intsOfEnv = (envir: Envir, terms: readonly Term[]) =>
|
|
114
|
+
intsOf(terms.map((term) => headNorm(envir, term)));
|
|
115
|
+
|
|
116
|
+
const appBounds = (head: Term, indexes: readonly number[]) =>
|
|
117
|
+
indexes.reduce((result, index) => mkApp(result, mkBound(index)), head);
|
|
118
|
+
|
|
119
|
+
const red = (term: Term, indexes: readonly number[], bound: readonly number[]): Term => {
|
|
120
|
+
if (term.kind === "Abs" && indexes.length > 0)
|
|
121
|
+
return red(term.body, indexes.slice(1), [indexes[0], ...bound]);
|
|
122
|
+
if (indexes.length === 0 && bound.length === 0) return term;
|
|
123
|
+
return appBounds(
|
|
124
|
+
mapBound((index) => bound[index], term),
|
|
125
|
+
indexes,
|
|
126
|
+
);
|
|
127
|
+
};
|
|
128
|
+
|
|
129
|
+
const splitType = (type: Typ, count: number): [Typ[], Typ] => {
|
|
130
|
+
const types: Typ[] = [];
|
|
131
|
+
let current = type;
|
|
132
|
+
for (let remaining = count; remaining > 0; remaining -= 1) {
|
|
133
|
+
if (current.kind !== "Type" || current.name !== "fun")
|
|
134
|
+
throw new TlaIsabelleError("TERM", "split_type");
|
|
135
|
+
types.unshift(current.args[0]);
|
|
136
|
+
current = current.args[1];
|
|
137
|
+
}
|
|
138
|
+
return [types, current];
|
|
139
|
+
};
|
|
140
|
+
|
|
141
|
+
const typeOfG = (envir: Envir, type: Typ, count: number, indexes: readonly number[]) => {
|
|
142
|
+
const [types, range] = splitType(normType(envir.tyenv, type), count);
|
|
143
|
+
return funTs(
|
|
144
|
+
indexes.map((index) => types[index]),
|
|
145
|
+
range,
|
|
146
|
+
);
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
const mkHnf = (
|
|
150
|
+
binders: readonly Binder[],
|
|
151
|
+
indexes: readonly number[],
|
|
152
|
+
head: Term,
|
|
153
|
+
args: readonly number[],
|
|
154
|
+
) => mkAbsOver(binders, indexes, appBounds(head, args));
|
|
155
|
+
|
|
156
|
+
const mkNewHnf = (
|
|
157
|
+
envir: Envir,
|
|
158
|
+
binders: readonly Binder[],
|
|
159
|
+
indexes: readonly number[],
|
|
160
|
+
variable: Var,
|
|
161
|
+
args: readonly number[],
|
|
162
|
+
) => {
|
|
163
|
+
const [updated, fresh] = genvar(
|
|
164
|
+
variable.name,
|
|
165
|
+
envir,
|
|
166
|
+
typeOfG(envir, variable.type, indexes.length, args),
|
|
167
|
+
);
|
|
168
|
+
return update(variable, mkHnf(binders, indexes, fresh, args), updated);
|
|
169
|
+
};
|
|
170
|
+
|
|
171
|
+
// downto0 (is, n): whether is is [n, n - 1, ..., 0].
|
|
172
|
+
const isDownto0 = (indexes: readonly number[], count: number) =>
|
|
173
|
+
indexes.length === count + 1 && indexes.every((index, position) => index === count - position);
|
|
174
|
+
|
|
175
|
+
const mkProjList = (indexes: readonly (number | undefined)[]) =>
|
|
176
|
+
indexes.flatMap((index, position) =>
|
|
177
|
+
index === undefined ? [] : [indexes.length - 1 - position],
|
|
178
|
+
);
|
|
179
|
+
|
|
180
|
+
const project = (
|
|
181
|
+
term: Term,
|
|
182
|
+
envir: Envir,
|
|
183
|
+
binders: readonly Binder[],
|
|
184
|
+
indexes: readonly number[],
|
|
185
|
+
): [Term, Envir] => {
|
|
186
|
+
const translate = (depth: number, index: number) =>
|
|
187
|
+
index < depth ? index : indexOf(indexes, index - depth) + depth;
|
|
188
|
+
const tryTranslate = (depth: number, index: number) => {
|
|
189
|
+
if (index < depth) return index;
|
|
190
|
+
const position = indexes.indexOf(index - depth);
|
|
191
|
+
return position === -1 ? undefined : indexes.length - 1 - position + depth;
|
|
192
|
+
};
|
|
193
|
+
const projectList = (
|
|
194
|
+
terms: readonly Term[],
|
|
195
|
+
state: Envir,
|
|
196
|
+
depth: number,
|
|
197
|
+
innerBinders: readonly Binder[],
|
|
198
|
+
): [Term[], Envir] => {
|
|
199
|
+
const results: Term[] = [];
|
|
200
|
+
let current = state;
|
|
201
|
+
for (const item of terms) {
|
|
202
|
+
const [projected, next] = projectTerm(item, current, depth, innerBinders);
|
|
203
|
+
results.push(projected);
|
|
204
|
+
current = next;
|
|
205
|
+
}
|
|
206
|
+
return [results, current];
|
|
207
|
+
};
|
|
208
|
+
const projectTerm = (
|
|
209
|
+
current: Term,
|
|
210
|
+
state: Envir,
|
|
211
|
+
depth: number,
|
|
212
|
+
innerBinders: readonly Binder[],
|
|
213
|
+
): [Term, Envir] => {
|
|
214
|
+
const normal = headNorm(state, current);
|
|
215
|
+
if (normal.kind === "Abs") {
|
|
216
|
+
const [body, next] = projectTerm(normal.body, state, depth + 1, [
|
|
217
|
+
{ name: normal.name, type: normal.type },
|
|
218
|
+
...innerBinders,
|
|
219
|
+
]);
|
|
220
|
+
return [mkAbs(normal.name, normal.type, body), next];
|
|
221
|
+
}
|
|
222
|
+
const [head, args] = stripComb(normal);
|
|
223
|
+
if (head.kind === "Const" || head.kind === "Free") {
|
|
224
|
+
const [projected, next] = projectList(args, state, depth, innerBinders);
|
|
225
|
+
return [listComb(head, projected), next];
|
|
226
|
+
}
|
|
227
|
+
if (head.kind === "Bound") {
|
|
228
|
+
const index = translate(depth, head.index);
|
|
229
|
+
const [projected, next] = projectList(args, state, depth, innerBinders);
|
|
230
|
+
return [listComb(mkBound(index), projected), next];
|
|
231
|
+
}
|
|
232
|
+
if (head.kind === "Var") {
|
|
233
|
+
const argIndexes = intsOfEnv(state, args);
|
|
234
|
+
const translated = argIndexes.map((index) => tryTranslate(depth, index));
|
|
235
|
+
const kept = mkProjList(translated);
|
|
236
|
+
const projectedBounds = translated.flatMap((index) => (index === undefined ? [] : [index]));
|
|
237
|
+
const [updated, fresh] = genvar(
|
|
238
|
+
head.name,
|
|
239
|
+
state,
|
|
240
|
+
typeOfG(state, head.type, argIndexes.length, kept),
|
|
241
|
+
);
|
|
242
|
+
const next = update(head, mkHnf(innerBinders, argIndexes, fresh, kept), updated);
|
|
243
|
+
return [appBounds(fresh, projectedBounds), next];
|
|
244
|
+
}
|
|
245
|
+
throw new NotPattern();
|
|
246
|
+
};
|
|
247
|
+
if (isDownto0(indexes, binders.length - 1)) return [term, envir];
|
|
248
|
+
return projectTerm(term, envir, 0, binders);
|
|
249
|
+
};
|
|
250
|
+
|
|
251
|
+
const mkFfList = (left: readonly number[], right: readonly number[]) => {
|
|
252
|
+
if (left.length !== right.length) throw new TlaIsabelleError("TERM", "mk_ff_list");
|
|
253
|
+
return left.flatMap((index, position) =>
|
|
254
|
+
index === right[position] ? [left.length - 1 - position] : [],
|
|
255
|
+
);
|
|
256
|
+
};
|
|
257
|
+
|
|
258
|
+
const flexflex1 = (
|
|
259
|
+
envir: Envir,
|
|
260
|
+
binders: readonly Binder[],
|
|
261
|
+
variable: Var,
|
|
262
|
+
left: readonly number[],
|
|
263
|
+
right: readonly number[],
|
|
264
|
+
) =>
|
|
265
|
+
left.length === right.length && left.every((index, position) => index === right[position])
|
|
266
|
+
? envir
|
|
267
|
+
: mkNewHnf(envir, binders, left, variable, mkFfList(left, right));
|
|
268
|
+
|
|
269
|
+
const flexflex2 = (
|
|
270
|
+
envir: Envir,
|
|
271
|
+
binders: readonly Binder[],
|
|
272
|
+
leftVar: Var,
|
|
273
|
+
leftIndexes: readonly number[],
|
|
274
|
+
rightVar: Var,
|
|
275
|
+
rightIndexes: readonly number[],
|
|
276
|
+
) => {
|
|
277
|
+
const assign = (
|
|
278
|
+
first: Var,
|
|
279
|
+
firstIndexes: readonly number[],
|
|
280
|
+
second: Var,
|
|
281
|
+
secondIndexes: readonly number[],
|
|
282
|
+
) => {
|
|
283
|
+
if (secondIndexes.every((index) => firstIndexes.includes(index))) {
|
|
284
|
+
const term = mkAbsOver(
|
|
285
|
+
binders,
|
|
286
|
+
firstIndexes,
|
|
287
|
+
appBounds(
|
|
288
|
+
second,
|
|
289
|
+
secondIndexes.map((index) => indexOf(firstIndexes, index)),
|
|
290
|
+
),
|
|
291
|
+
);
|
|
292
|
+
return update(first, term, envir);
|
|
293
|
+
}
|
|
294
|
+
const common = firstIndexes.filter((index) => secondIndexes.includes(index));
|
|
295
|
+
const [updated, fresh] = genvar(
|
|
296
|
+
second.name,
|
|
297
|
+
envir,
|
|
298
|
+
typeOfG(
|
|
299
|
+
envir,
|
|
300
|
+
first.type,
|
|
301
|
+
firstIndexes.length,
|
|
302
|
+
common.map((index) => indexOf(firstIndexes, index)),
|
|
303
|
+
),
|
|
304
|
+
);
|
|
305
|
+
const lam = (indexes: readonly number[]) =>
|
|
306
|
+
mkAbsOver(
|
|
307
|
+
binders,
|
|
308
|
+
indexes,
|
|
309
|
+
appBounds(
|
|
310
|
+
fresh,
|
|
311
|
+
common.map((index) => indexOf(indexes, index)),
|
|
312
|
+
),
|
|
313
|
+
);
|
|
314
|
+
return update(second, lam(secondIndexes), update(first, lam(firstIndexes), updated));
|
|
315
|
+
};
|
|
316
|
+
return indexnameOrd(rightVar, leftVar) < 0
|
|
317
|
+
? assign(leftVar, leftIndexes, rightVar, rightIndexes)
|
|
318
|
+
: assign(rightVar, rightIndexes, leftVar, leftIndexes);
|
|
319
|
+
};
|
|
320
|
+
|
|
321
|
+
// Pattern.unify_types: undefined where Isabelle raises Unif.
|
|
322
|
+
export const unifyTypesEnvir = (left: Typ, right: Typ, envir: Envir): Envir | undefined => {
|
|
323
|
+
if (eqTyp(left, right)) return envir;
|
|
324
|
+
const tyenv = unifyTypes(right, left, envir.tyenv);
|
|
325
|
+
return tyenv === undefined ? undefined : { ...envir, tyenv };
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
const unifyTypesOrFail = (left: Typ, right: Typ, envir: Envir) => {
|
|
329
|
+
const result = unifyTypesEnvir(left, right, envir);
|
|
330
|
+
if (result === undefined) throw new Unif();
|
|
331
|
+
return result;
|
|
332
|
+
};
|
|
333
|
+
|
|
334
|
+
const unif = (binders: readonly Binder[], left: Term, right: Term, envir: Envir): Envir => {
|
|
335
|
+
const leftNorm = headNorm(envir, left);
|
|
336
|
+
const rightNorm = headNorm(envir, right);
|
|
337
|
+
if (leftNorm.kind === "Abs" && rightNorm.kind === "Abs") {
|
|
338
|
+
const name = leftNorm.name === "" ? rightNorm.name : leftNorm.name;
|
|
339
|
+
return unif(
|
|
340
|
+
[{ name, type: leftNorm.type }, ...binders],
|
|
341
|
+
leftNorm.body,
|
|
342
|
+
rightNorm.body,
|
|
343
|
+
unifyTypesOrFail(leftNorm.type, rightNorm.type, envir),
|
|
344
|
+
);
|
|
345
|
+
}
|
|
346
|
+
if (leftNorm.kind === "Abs")
|
|
347
|
+
return unif(
|
|
348
|
+
[{ name: leftNorm.name, type: leftNorm.type }, ...binders],
|
|
349
|
+
leftNorm.body,
|
|
350
|
+
mkApp(incr(rightNorm), mkBound(0)),
|
|
351
|
+
envir,
|
|
352
|
+
);
|
|
353
|
+
if (rightNorm.kind === "Abs")
|
|
354
|
+
return unif(
|
|
355
|
+
[{ name: rightNorm.name, type: rightNorm.type }, ...binders],
|
|
356
|
+
mkApp(incr(leftNorm), mkBound(0)),
|
|
357
|
+
rightNorm.body,
|
|
358
|
+
envir,
|
|
359
|
+
);
|
|
360
|
+
return cases(binders, envir, leftNorm, rightNorm);
|
|
361
|
+
};
|
|
362
|
+
|
|
363
|
+
const unifArgs = (
|
|
364
|
+
binders: readonly Binder[],
|
|
365
|
+
left: readonly Term[],
|
|
366
|
+
right: readonly Term[],
|
|
367
|
+
envir: Envir,
|
|
368
|
+
) => {
|
|
369
|
+
if (left.length !== right.length) throw new Unif();
|
|
370
|
+
return left.reduce((state, item, index) => unif(binders, item, right[index], state), envir);
|
|
371
|
+
};
|
|
372
|
+
|
|
373
|
+
const cases = (binders: readonly Binder[], envir: Envir, left: Term, right: Term): Envir => {
|
|
374
|
+
const [leftHead, leftArgs] = stripComb(left);
|
|
375
|
+
const [rightHead, rightArgs] = stripComb(right);
|
|
376
|
+
if (leftHead.kind === "Var" && rightHead.kind === "Var") {
|
|
377
|
+
if (leftHead.name === rightHead.name && leftHead.index === rightHead.index)
|
|
378
|
+
return flexflex1(
|
|
379
|
+
envir,
|
|
380
|
+
binders,
|
|
381
|
+
leftHead,
|
|
382
|
+
intsOfEnv(envir, leftArgs),
|
|
383
|
+
intsOfEnv(envir, rightArgs),
|
|
384
|
+
);
|
|
385
|
+
return flexflex2(
|
|
386
|
+
envir,
|
|
387
|
+
binders,
|
|
388
|
+
leftHead,
|
|
389
|
+
intsOfEnv(envir, leftArgs),
|
|
390
|
+
rightHead,
|
|
391
|
+
intsOfEnv(envir, rightArgs),
|
|
392
|
+
);
|
|
393
|
+
}
|
|
394
|
+
if (leftHead.kind === "Var")
|
|
395
|
+
return flexRigid(envir, binders, leftHead, intsOfEnv(envir, leftArgs), right);
|
|
396
|
+
if (rightHead.kind === "Var")
|
|
397
|
+
return flexRigid(envir, binders, rightHead, intsOfEnv(envir, rightArgs), left);
|
|
398
|
+
if (
|
|
399
|
+
(leftHead.kind === "Const" && rightHead.kind === "Const") ||
|
|
400
|
+
(leftHead.kind === "Free" && rightHead.kind === "Free")
|
|
401
|
+
) {
|
|
402
|
+
if (leftHead.name !== rightHead.name) throw new Unif();
|
|
403
|
+
return unifArgs(
|
|
404
|
+
binders,
|
|
405
|
+
leftArgs,
|
|
406
|
+
rightArgs,
|
|
407
|
+
unifyTypesOrFail(leftHead.type, rightHead.type, envir),
|
|
408
|
+
);
|
|
409
|
+
}
|
|
410
|
+
if (leftHead.kind === "Bound" && rightHead.kind === "Bound") {
|
|
411
|
+
if (leftHead.index !== rightHead.index) throw new Unif();
|
|
412
|
+
return unifArgs(binders, leftArgs, rightArgs, envir);
|
|
413
|
+
}
|
|
414
|
+
if (leftHead.kind === "Abs" || rightHead.kind === "Abs") throw new NotPattern();
|
|
415
|
+
throw new Unif();
|
|
416
|
+
};
|
|
417
|
+
|
|
418
|
+
const flexRigid = (
|
|
419
|
+
envir: Envir,
|
|
420
|
+
binders: readonly Binder[],
|
|
421
|
+
variable: Var,
|
|
422
|
+
indexes: readonly number[],
|
|
423
|
+
term: Term,
|
|
424
|
+
) => {
|
|
425
|
+
if (occurs(variable, term, envir)) throw new Unif();
|
|
426
|
+
const [projected, updated] = project(term, envir, binders, indexes);
|
|
427
|
+
return update(variable, mkAbsOver(binders, indexes, projected), updated);
|
|
428
|
+
};
|
|
429
|
+
|
|
430
|
+
export type PatternUnifyResult =
|
|
431
|
+
| { kind: "unified"; envir: Envir }
|
|
432
|
+
| { kind: "clash" }
|
|
433
|
+
| { kind: "not a pattern" };
|
|
434
|
+
|
|
435
|
+
// Pattern.unify: distinguishes a clash (Unif) from terms outside the pattern fragment (Pattern).
|
|
436
|
+
export const unifyPattern = (left: Term, right: Term, envir: Envir): PatternUnifyResult => {
|
|
437
|
+
try {
|
|
438
|
+
return { kind: "unified", envir: unif([], left, right, envir) };
|
|
439
|
+
} catch (error) {
|
|
440
|
+
if (error instanceof Unif) return { kind: "clash" };
|
|
441
|
+
if (error instanceof NotPattern) return { kind: "not a pattern" };
|
|
442
|
+
throw error;
|
|
443
|
+
}
|
|
444
|
+
};
|
|
445
|
+
|
|
446
|
+
export interface MatchEnv {
|
|
447
|
+
readonly tyenv: TyEnv;
|
|
448
|
+
readonly tenv: TEnv;
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
const typMatch = (pattern: Typ, object: Typ, tyenv: TyEnv) => {
|
|
452
|
+
const result = matchTypes(pattern, object, tyenv);
|
|
453
|
+
if (result === undefined) throw new Match();
|
|
454
|
+
return result;
|
|
455
|
+
};
|
|
456
|
+
|
|
457
|
+
const updateNewTEnv = (tenv: TEnv, variable: Var, term: Term): TEnv => {
|
|
458
|
+
if (hasKey(tenv, variable)) throw new TlaIsabelleError("TERM", "Vartab.update_new: duplicate");
|
|
459
|
+
return updateTable(
|
|
460
|
+
tenv,
|
|
461
|
+
{ name: variable.name, index: variable.index },
|
|
462
|
+
{ type: variable.type, term },
|
|
463
|
+
);
|
|
464
|
+
};
|
|
465
|
+
|
|
466
|
+
const firstOrderMatchAt = (isInAbs: boolean, state: MatchEnv, pat: Term, obj: Term): MatchEnv => {
|
|
467
|
+
if (pat.kind === "Var") {
|
|
468
|
+
if (isInAbs && isOpen(obj)) throw new Match();
|
|
469
|
+
const assigned = lookup1(state.tenv, pat);
|
|
470
|
+
if (assigned === undefined)
|
|
471
|
+
return {
|
|
472
|
+
tyenv: typMatch(pat.type, fastypeOf(obj), state.tyenv),
|
|
473
|
+
tenv: updateNewTEnv(state.tenv, pat, obj),
|
|
474
|
+
};
|
|
475
|
+
if (aeconv(obj, assigned)) return state;
|
|
476
|
+
throw new Match();
|
|
477
|
+
}
|
|
478
|
+
if (
|
|
479
|
+
(pat.kind === "Free" && obj.kind === "Free") ||
|
|
480
|
+
(pat.kind === "Const" && obj.kind === "Const")
|
|
481
|
+
) {
|
|
482
|
+
if (pat.name !== obj.name) throw new Match();
|
|
483
|
+
return { tyenv: typMatch(pat.type, obj.type, state.tyenv), tenv: state.tenv };
|
|
484
|
+
}
|
|
485
|
+
if (pat.kind === "Bound" && obj.kind === "Bound") {
|
|
486
|
+
if (pat.index !== obj.index) throw new Match();
|
|
487
|
+
return state;
|
|
488
|
+
}
|
|
489
|
+
if (pat.kind === "Abs" && obj.kind === "Abs")
|
|
490
|
+
return firstOrderMatchAt(
|
|
491
|
+
true,
|
|
492
|
+
{ tyenv: typMatch(pat.type, obj.type, state.tyenv), tenv: state.tenv },
|
|
493
|
+
pat.body,
|
|
494
|
+
obj.body,
|
|
495
|
+
);
|
|
496
|
+
if (pat.kind === "App" && obj.kind === "App")
|
|
497
|
+
return firstOrderMatchAt(
|
|
498
|
+
isInAbs,
|
|
499
|
+
firstOrderMatchAt(isInAbs, state, pat.fun, obj.fun),
|
|
500
|
+
pat.arg,
|
|
501
|
+
obj.arg,
|
|
502
|
+
);
|
|
503
|
+
if (obj.kind === "Abs")
|
|
504
|
+
return firstOrderMatchAt(true, state, mkApp(incr(pat), mkBound(0)), obj.body);
|
|
505
|
+
throw new Match();
|
|
506
|
+
};
|
|
507
|
+
|
|
508
|
+
const firstOrderMatch = (pattern: Term, object: Term, env: MatchEnv) =>
|
|
509
|
+
firstOrderMatchAt(false, env, pattern, object);
|
|
510
|
+
|
|
511
|
+
const matchBind = (
|
|
512
|
+
tenv: TEnv,
|
|
513
|
+
binders: readonly Binder[],
|
|
514
|
+
variable: Var,
|
|
515
|
+
indexes: readonly number[],
|
|
516
|
+
term: Term,
|
|
517
|
+
): TEnv => {
|
|
518
|
+
const loose = looseBnos(term);
|
|
519
|
+
if (indexes.length === 0) {
|
|
520
|
+
if (loose.length === 0) return updateNewTEnv(tenv, variable, term);
|
|
521
|
+
throw new Match();
|
|
522
|
+
}
|
|
523
|
+
if (!loose.every((index) => indexes.includes(index))) throw new Match();
|
|
524
|
+
const body = isDownto0(indexes, binders.length - 1)
|
|
525
|
+
? term
|
|
526
|
+
: mapBound((index) => indexOf(indexes, index), term);
|
|
527
|
+
return updateNewTEnv(tenv, variable, mkAbsOver(binders, indexes, body));
|
|
528
|
+
};
|
|
529
|
+
|
|
530
|
+
const higherOrderMatch = (pattern: Term, object: Term, env: MatchEnv): MatchEnv => {
|
|
531
|
+
const visit = (binders: readonly Binder[], pat: Term, obj: Term, state: MatchEnv): MatchEnv => {
|
|
532
|
+
if (pat.kind === "Abs") {
|
|
533
|
+
if (obj.kind === "Abs")
|
|
534
|
+
return visit([{ name: obj.name, type: obj.type }, ...binders], pat.body, obj.body, state);
|
|
535
|
+
const type = substType(state.tyenv, pat.type);
|
|
536
|
+
return visit(
|
|
537
|
+
[{ name: pat.name, type }, ...binders],
|
|
538
|
+
pat.body,
|
|
539
|
+
mkApp(incr(obj), mkBound(0)),
|
|
540
|
+
state,
|
|
541
|
+
);
|
|
542
|
+
}
|
|
543
|
+
if (obj.kind === "Abs")
|
|
544
|
+
return visit(
|
|
545
|
+
[{ name: obj.name, type: obj.type }, ...binders],
|
|
546
|
+
mkApp(incr(pat), mkBound(0)),
|
|
547
|
+
obj.body,
|
|
548
|
+
state,
|
|
549
|
+
);
|
|
550
|
+
return matchCases(binders, state, pat, obj);
|
|
551
|
+
};
|
|
552
|
+
const matchCases = (
|
|
553
|
+
binders: readonly Binder[],
|
|
554
|
+
state: MatchEnv,
|
|
555
|
+
pat: Term,
|
|
556
|
+
obj: Term,
|
|
557
|
+
): MatchEnv => {
|
|
558
|
+
const [patHead, patArgs] = stripComb(pat);
|
|
559
|
+
const rigidArgs = (tyenv: TyEnv, objArgs: readonly Term[]) => {
|
|
560
|
+
if (patArgs.length !== objArgs.length) throw new Match();
|
|
561
|
+
return patArgs.reduce((result, arg, index) => visit(binders, arg, objArgs[index], result), {
|
|
562
|
+
tyenv,
|
|
563
|
+
tenv: state.tenv,
|
|
564
|
+
});
|
|
565
|
+
};
|
|
566
|
+
if (patHead.kind === "Var") {
|
|
567
|
+
const indexes = intsOf(patArgs);
|
|
568
|
+
const assigned = lookup1(state.tenv, patHead);
|
|
569
|
+
if (assigned === undefined)
|
|
570
|
+
return { tyenv: state.tyenv, tenv: matchBind(state.tenv, binders, patHead, indexes, obj) };
|
|
571
|
+
if (aeconv(obj, red(assigned, indexes, []))) return state;
|
|
572
|
+
throw new Match();
|
|
573
|
+
}
|
|
574
|
+
const [objHead, objArgs] = stripComb(obj);
|
|
575
|
+
if (
|
|
576
|
+
(patHead.kind === "Const" && objHead.kind === "Const") ||
|
|
577
|
+
(patHead.kind === "Free" && objHead.kind === "Free")
|
|
578
|
+
) {
|
|
579
|
+
if (patHead.name !== objHead.name) throw new Match();
|
|
580
|
+
return rigidArgs(typMatch(patHead.type, objHead.type, state.tyenv), objArgs);
|
|
581
|
+
}
|
|
582
|
+
if (patHead.kind === "Bound" && objHead.kind === "Bound") {
|
|
583
|
+
if (patHead.index !== objHead.index) throw new Match();
|
|
584
|
+
return rigidArgs(state.tyenv, objArgs);
|
|
585
|
+
}
|
|
586
|
+
if (patHead.kind === "Abs" || objHead.kind === "Abs") throw new NotPattern();
|
|
587
|
+
throw new Match();
|
|
588
|
+
};
|
|
589
|
+
const initial = {
|
|
590
|
+
tyenv: typMatch(fastypeOf(pattern), fastypeOf(object), env.tyenv),
|
|
591
|
+
tenv: env.tenv,
|
|
592
|
+
};
|
|
593
|
+
try {
|
|
594
|
+
return visit([], pattern, object, initial);
|
|
595
|
+
} catch (error) {
|
|
596
|
+
if (error instanceof NotPattern) return firstOrderMatch(pattern, object, initial);
|
|
597
|
+
throw error;
|
|
598
|
+
}
|
|
599
|
+
};
|
|
600
|
+
|
|
601
|
+
const catchMatch = (run: () => MatchEnv): MatchEnv | undefined => {
|
|
602
|
+
try {
|
|
603
|
+
return run();
|
|
604
|
+
} catch (error) {
|
|
605
|
+
if (error instanceof Match) return undefined;
|
|
606
|
+
throw error;
|
|
607
|
+
}
|
|
608
|
+
};
|
|
609
|
+
|
|
610
|
+
// Pattern.match: undefined where Isabelle raises MATCH.
|
|
611
|
+
export const matchPattern = (pattern: Term, object: Term, env: MatchEnv): MatchEnv | undefined =>
|
|
612
|
+
catchMatch(() => higherOrderMatch(pattern, object, env));
|
|
613
|
+
|
|
614
|
+
// Pattern.first_order_match
|
|
615
|
+
export const firstOrderMatchPattern = (
|
|
616
|
+
pattern: Term,
|
|
617
|
+
object: Term,
|
|
618
|
+
env: MatchEnv,
|
|
619
|
+
): MatchEnv | undefined => catchMatch(() => firstOrderMatch(pattern, object, env));
|
|
620
|
+
|
|
621
|
+
// Pattern.matches
|
|
622
|
+
export const matches = (pattern: Term, object: Term, tyenv: TyEnv, tenv: TEnv) =>
|
|
623
|
+
matchPattern(pattern, object, { tyenv, tenv }) !== undefined;
|
|
624
|
+
|
|
625
|
+
// Pattern.pattern
|
|
626
|
+
export const isPattern = (term: Term): boolean => {
|
|
627
|
+
if (term.kind === "Abs") return isPattern(term.body);
|
|
628
|
+
const [head, args] = stripComb(term);
|
|
629
|
+
if (head.kind === "Var")
|
|
630
|
+
return (
|
|
631
|
+
args.every((arg) => arg.kind === "Bound") &&
|
|
632
|
+
!args.some((arg, index) => args.findIndex((other) => aconv(other, arg)) !== index)
|
|
633
|
+
);
|
|
634
|
+
return args.every(isPattern);
|
|
635
|
+
};
|
|
636
|
+
|
|
637
|
+
// Pattern.first_order
|
|
638
|
+
export const isFirstOrder = (term: Term): boolean => {
|
|
639
|
+
if (term.kind === "Abs") return isFirstOrder(term.body);
|
|
640
|
+
if (term.kind === "App")
|
|
641
|
+
return term.fun.kind !== "Var" && isFirstOrder(term.fun) && isFirstOrder(term.arg);
|
|
642
|
+
return true;
|
|
643
|
+
};
|
|
644
|
+
|
|
645
|
+
// Pattern.match_rew
|
|
646
|
+
export const matchRew = (term: Term, lhs: Term, rhs: Term): [Term, Term] | undefined => {
|
|
647
|
+
const renamed = renameAbs(lhs, term, rhs) ?? rhs;
|
|
648
|
+
const env = matchPattern(lhs, term, { tyenv: emptyTyEnv, tenv: emptyTEnv });
|
|
649
|
+
return env === undefined ? undefined : [substTerm(env.tyenv, env.tenv, renamed), renamed];
|
|
650
|
+
};
|