tla-ts 0.0.4-dev.a0009b7 → 0.0.4-dev.b254db0
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 +33 -143
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +37 -1
- package/dist/index.d.ts +37 -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} +265 -55
- package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
- package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
- package/src/{obligations.ts → obligations/index.ts} +29 -13
- package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
- package/src/{obligation-module.ts → obligations/module.ts} +56 -33
- 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 -1
- package/src/{obligation-source.ts → obligations/source.ts} +159 -97
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- 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 +100 -0
- package/src/prove/deciders.ts +33 -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 +503 -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 +521 -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 +557 -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 +25 -0
- package/src/prove/prove.ts +505 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -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 +222 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +166 -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 +182 -0
- package/src/prove/smt/rewrite.ts +773 -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 +437 -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 +334 -75
- 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,808 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/term.ML. Copyright (c) 1986-2025 University of Cambridge,
|
|
2
|
+
// Technische Universitaet Muenchen, and contributors, see LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// Simply typed lambda terms with de Bruijn indices. Functions that rebuild a term return the
|
|
5
|
+
// very same object when nothing changes, as Isabelle's Same.SAME does, so pointer equality stays a
|
|
6
|
+
// fast path.
|
|
7
|
+
//
|
|
8
|
+
// Unlike Isabelle, applications, abstractions and compound types record what their subterms
|
|
9
|
+
// contain when built: the largest index (maxidx), a bound above every loose bound variable (loose),
|
|
10
|
+
// whether a schematic variable, a beta redex or an eta redex occurs, and a bit for the name of each
|
|
11
|
+
// free variable (flags). A term has every flag of its subterms. Traversals use this to skip
|
|
12
|
+
// subterms they would return unchanged, which gives the same results while touching only the parts
|
|
13
|
+
// that change.
|
|
14
|
+
|
|
15
|
+
import { TlaIsabelleError } from "../../../errors";
|
|
16
|
+
|
|
17
|
+
export type Sort = readonly string[];
|
|
18
|
+
|
|
19
|
+
export type Typ =
|
|
20
|
+
| {
|
|
21
|
+
readonly kind: "Type";
|
|
22
|
+
readonly name: string;
|
|
23
|
+
readonly args: readonly Typ[];
|
|
24
|
+
readonly maxidx: number;
|
|
25
|
+
}
|
|
26
|
+
| { readonly kind: "TFree"; readonly name: string; readonly sort: Sort }
|
|
27
|
+
| { readonly kind: "TVar"; readonly name: string; readonly index: number; readonly sort: Sort };
|
|
28
|
+
|
|
29
|
+
// The fields of every kind of term. A term has all of them, with the ones its kind doesn't use
|
|
30
|
+
// undefined, and the constructors below list them in this order. So all terms share one object
|
|
31
|
+
// layout, and V8 compiles the many switches on kind to monomorphic loads.
|
|
32
|
+
interface TermFields {
|
|
33
|
+
readonly name: string;
|
|
34
|
+
readonly type: Typ;
|
|
35
|
+
readonly index: number;
|
|
36
|
+
readonly body: Term;
|
|
37
|
+
readonly fun: Term;
|
|
38
|
+
readonly arg: Term;
|
|
39
|
+
readonly loose: number;
|
|
40
|
+
readonly maxidx: number;
|
|
41
|
+
readonly flags: number;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
type TermOf<Kind extends string, Used extends keyof TermFields> = { readonly kind: Kind } & Pick<
|
|
45
|
+
TermFields,
|
|
46
|
+
Used
|
|
47
|
+
> & { readonly [Key in Exclude<keyof TermFields, Used>]: undefined };
|
|
48
|
+
|
|
49
|
+
export type Term =
|
|
50
|
+
| TermOf<"Const", "name" | "type">
|
|
51
|
+
| TermOf<"Free", "name" | "type">
|
|
52
|
+
| TermOf<"Var", "name" | "index" | "type">
|
|
53
|
+
| TermOf<"Bound", "index">
|
|
54
|
+
| TermOf<"Abs", "name" | "type" | "body" | "loose" | "maxidx" | "flags">
|
|
55
|
+
| TermOf<"App", "fun" | "arg" | "loose" | "maxidx" | "flags">;
|
|
56
|
+
|
|
57
|
+
export type Var = Extract<Term, { kind: "Var" }>;
|
|
58
|
+
export type Abs = Extract<Term, { kind: "Abs" }>;
|
|
59
|
+
export type App = Extract<Term, { kind: "App" }>;
|
|
60
|
+
export type TVar = Extract<Typ, { kind: "TVar" }>;
|
|
61
|
+
|
|
62
|
+
export interface Indexname {
|
|
63
|
+
readonly name: string;
|
|
64
|
+
readonly index: number;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
export const HAS_VAR = 1;
|
|
68
|
+
export const HAS_REDEX = 2;
|
|
69
|
+
export const HAS_ETA_REDEX = 4;
|
|
70
|
+
|
|
71
|
+
export const maxidxOfTyp = (type: Typ, maxidx = -1) =>
|
|
72
|
+
Math.max(maxidx, type.kind === "TFree" ? -1 : type.kind === "TVar" ? type.index : type.maxidx);
|
|
73
|
+
|
|
74
|
+
export const maxidxOfTerm = (term: Term, maxidx = -1): number => {
|
|
75
|
+
switch (term.kind) {
|
|
76
|
+
case "Var":
|
|
77
|
+
return Math.max(maxidx, term.index, maxidxOfTyp(term.type));
|
|
78
|
+
case "Const":
|
|
79
|
+
case "Free":
|
|
80
|
+
return maxidxOfTyp(term.type, maxidx);
|
|
81
|
+
case "Bound":
|
|
82
|
+
return maxidx;
|
|
83
|
+
default:
|
|
84
|
+
return Math.max(maxidx, term.maxidx);
|
|
85
|
+
}
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
// The bound on loose bound variables: every one is below it.
|
|
89
|
+
export const looseOf = (term: Term) =>
|
|
90
|
+
term.kind === "Bound"
|
|
91
|
+
? term.index + 1
|
|
92
|
+
: term.kind === "App" || term.kind === "Abs"
|
|
93
|
+
? term.loose
|
|
94
|
+
: 0;
|
|
95
|
+
|
|
96
|
+
// One of the 28 bits above the others, picked by a cheap hash of the name.
|
|
97
|
+
const freeBit = (name: string) =>
|
|
98
|
+
8 <<
|
|
99
|
+
((name.length * 31 + (name.charCodeAt(0) | 0) * 7 + (name.charCodeAt(name.length - 1) | 0)) % 28);
|
|
100
|
+
|
|
101
|
+
export const flagsOf = (term: Term) =>
|
|
102
|
+
term.kind === "Var"
|
|
103
|
+
? HAS_VAR
|
|
104
|
+
: term.kind === "Free"
|
|
105
|
+
? freeBit(term.name)
|
|
106
|
+
: term.kind === "App" || term.kind === "Abs"
|
|
107
|
+
? term.flags
|
|
108
|
+
: 0;
|
|
109
|
+
|
|
110
|
+
// Whether a subterm aconv to pattern could occur in term.
|
|
111
|
+
export const mayOccur = (pattern: Term, term: Term) => (flagsOf(pattern) & ~flagsOf(term)) === 0;
|
|
112
|
+
|
|
113
|
+
export const mkType = (name: string, args: readonly Typ[] = []): Typ => ({
|
|
114
|
+
kind: "Type",
|
|
115
|
+
name,
|
|
116
|
+
args,
|
|
117
|
+
maxidx: args.reduce((result, arg) => maxidxOfTyp(arg, result), -1),
|
|
118
|
+
});
|
|
119
|
+
export const mkTFree = (name: string, sort: Sort = []): Typ => ({ kind: "TFree", name, sort });
|
|
120
|
+
export const mkTVar = (name: string, index: number, sort: Sort = []): Typ => ({
|
|
121
|
+
kind: "TVar",
|
|
122
|
+
name,
|
|
123
|
+
index,
|
|
124
|
+
sort,
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
export const mkConst = (name: string, type: Typ): Term => ({
|
|
128
|
+
kind: "Const",
|
|
129
|
+
name,
|
|
130
|
+
type,
|
|
131
|
+
index: undefined,
|
|
132
|
+
body: undefined,
|
|
133
|
+
fun: undefined,
|
|
134
|
+
arg: undefined,
|
|
135
|
+
loose: undefined,
|
|
136
|
+
maxidx: undefined,
|
|
137
|
+
flags: undefined,
|
|
138
|
+
});
|
|
139
|
+
export const mkFree = (name: string, type: Typ): Term => ({
|
|
140
|
+
kind: "Free",
|
|
141
|
+
name,
|
|
142
|
+
type,
|
|
143
|
+
index: undefined,
|
|
144
|
+
body: undefined,
|
|
145
|
+
fun: undefined,
|
|
146
|
+
arg: undefined,
|
|
147
|
+
loose: undefined,
|
|
148
|
+
maxidx: undefined,
|
|
149
|
+
flags: undefined,
|
|
150
|
+
});
|
|
151
|
+
export const mkVar = (name: string, index: number, type: Typ): Var => ({
|
|
152
|
+
kind: "Var",
|
|
153
|
+
name,
|
|
154
|
+
type,
|
|
155
|
+
index,
|
|
156
|
+
body: undefined,
|
|
157
|
+
fun: undefined,
|
|
158
|
+
arg: undefined,
|
|
159
|
+
loose: undefined,
|
|
160
|
+
maxidx: undefined,
|
|
161
|
+
flags: undefined,
|
|
162
|
+
});
|
|
163
|
+
export const mkBound = (index: number): Term => ({
|
|
164
|
+
kind: "Bound",
|
|
165
|
+
name: undefined,
|
|
166
|
+
type: undefined,
|
|
167
|
+
index,
|
|
168
|
+
body: undefined,
|
|
169
|
+
fun: undefined,
|
|
170
|
+
arg: undefined,
|
|
171
|
+
loose: undefined,
|
|
172
|
+
maxidx: undefined,
|
|
173
|
+
flags: undefined,
|
|
174
|
+
});
|
|
175
|
+
export const mkAbs = (name: string, type: Typ, body: Term): Term => ({
|
|
176
|
+
kind: "Abs",
|
|
177
|
+
name,
|
|
178
|
+
type,
|
|
179
|
+
index: undefined,
|
|
180
|
+
body,
|
|
181
|
+
fun: undefined,
|
|
182
|
+
arg: undefined,
|
|
183
|
+
loose: Math.max(looseOf(body) - 1, 0),
|
|
184
|
+
maxidx: maxidxOfTerm(body, maxidxOfTyp(type)),
|
|
185
|
+
flags:
|
|
186
|
+
flagsOf(body) |
|
|
187
|
+
(body.kind === "App" && body.arg.kind === "Bound" && body.arg.index === 0 ? HAS_ETA_REDEX : 0),
|
|
188
|
+
});
|
|
189
|
+
export const mkApp = (fun: Term, arg: Term): Term => ({
|
|
190
|
+
kind: "App",
|
|
191
|
+
name: undefined,
|
|
192
|
+
type: undefined,
|
|
193
|
+
index: undefined,
|
|
194
|
+
body: undefined,
|
|
195
|
+
fun,
|
|
196
|
+
arg,
|
|
197
|
+
loose: Math.max(looseOf(fun), looseOf(arg)),
|
|
198
|
+
maxidx: maxidxOfTerm(arg, maxidxOfTerm(fun)),
|
|
199
|
+
flags: flagsOf(fun) | flagsOf(arg) | (fun.kind === "Abs" ? HAS_REDEX : 0),
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
export const dummyT = mkType("dummy");
|
|
203
|
+
export const propT = mkType("prop");
|
|
204
|
+
|
|
205
|
+
export const funT = (domain: Typ, range: Typ) => mkType("fun", [domain, range]);
|
|
206
|
+
|
|
207
|
+
// op --->
|
|
208
|
+
export const funTs = (domains: readonly Typ[], range: Typ) =>
|
|
209
|
+
domains.reduceRight((result, domain) => funT(domain, result), range);
|
|
210
|
+
|
|
211
|
+
export const isFunType = (type: Typ) => type.kind === "Type" && type.name === "fun";
|
|
212
|
+
|
|
213
|
+
export const domainType = (type: Typ) => {
|
|
214
|
+
if (type.kind !== "Type" || type.name !== "fun")
|
|
215
|
+
throw new TlaIsabelleError("TYPE", "domain_type");
|
|
216
|
+
return type.args[0];
|
|
217
|
+
};
|
|
218
|
+
|
|
219
|
+
export const rangeType = (type: Typ) => {
|
|
220
|
+
if (type.kind !== "Type" || type.name !== "fun") throw new TlaIsabelleError("TYPE", "range_type");
|
|
221
|
+
return type.args[1];
|
|
222
|
+
};
|
|
223
|
+
|
|
224
|
+
export const binderTypes = (type: Typ): Typ[] => {
|
|
225
|
+
const types: Typ[] = [];
|
|
226
|
+
let current = type;
|
|
227
|
+
while (current.kind === "Type" && current.name === "fun") {
|
|
228
|
+
types.push(current.args[0]);
|
|
229
|
+
current = current.args[1];
|
|
230
|
+
}
|
|
231
|
+
return types;
|
|
232
|
+
};
|
|
233
|
+
|
|
234
|
+
export const bodyType = (type: Typ): Typ =>
|
|
235
|
+
type.kind === "Type" && type.name === "fun" ? bodyType(type.args[1]) : type;
|
|
236
|
+
|
|
237
|
+
const eqSort = (left: Sort, right: Sort) =>
|
|
238
|
+
left === right ||
|
|
239
|
+
(left.length === right.length && left.every((name, index) => name === right[index]));
|
|
240
|
+
|
|
241
|
+
export const eqTyp = (left: Typ, right: Typ): boolean => {
|
|
242
|
+
if (left === right) return true;
|
|
243
|
+
if (left.kind === "Type")
|
|
244
|
+
return (
|
|
245
|
+
right.kind === "Type" &&
|
|
246
|
+
left.name === right.name &&
|
|
247
|
+
left.args.length === right.args.length &&
|
|
248
|
+
left.args.every((arg, index) => eqTyp(arg, right.args[index]))
|
|
249
|
+
);
|
|
250
|
+
if (left.kind === "TFree")
|
|
251
|
+
return right.kind === "TFree" && left.name === right.name && eqSort(left.sort, right.sort);
|
|
252
|
+
return (
|
|
253
|
+
right.kind === "TVar" &&
|
|
254
|
+
left.name === right.name &&
|
|
255
|
+
left.index === right.index &&
|
|
256
|
+
eqSort(left.sort, right.sort)
|
|
257
|
+
);
|
|
258
|
+
};
|
|
259
|
+
|
|
260
|
+
// fastype_of1: the type of a term, with minimal checking. Types holds the types of the loose
|
|
261
|
+
// bound variables, innermost first.
|
|
262
|
+
export const fastypeOf1 = (types: readonly Typ[], term: Term): Typ => {
|
|
263
|
+
switch (term.kind) {
|
|
264
|
+
case "Const":
|
|
265
|
+
case "Free":
|
|
266
|
+
case "Var":
|
|
267
|
+
return term.type;
|
|
268
|
+
case "Bound": {
|
|
269
|
+
const type = types[term.index];
|
|
270
|
+
if (type === undefined) throw new TlaIsabelleError("TYPE", "fastype_of: Bound");
|
|
271
|
+
return type;
|
|
272
|
+
}
|
|
273
|
+
case "Abs":
|
|
274
|
+
return funT(term.type, fastypeOf1([term.type, ...types], term.body));
|
|
275
|
+
case "App": {
|
|
276
|
+
const type = fastypeOf1(types, term.fun);
|
|
277
|
+
if (type.kind !== "Type" || type.name !== "fun")
|
|
278
|
+
throw new TlaIsabelleError("TYPE", "fastype_of: expected function type");
|
|
279
|
+
return type.args[1];
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
};
|
|
283
|
+
|
|
284
|
+
export const fastypeOf = (term: Term) => fastypeOf1([], term);
|
|
285
|
+
|
|
286
|
+
export const listComb = (head: Term, args: readonly Term[]) =>
|
|
287
|
+
args.reduce((result, arg) => mkApp(result, arg), head);
|
|
288
|
+
|
|
289
|
+
export const stripComb = (term: Term): [Term, Term[]] => {
|
|
290
|
+
const args: Term[] = [];
|
|
291
|
+
let current = term;
|
|
292
|
+
while (current.kind === "App") {
|
|
293
|
+
args.push(current.arg);
|
|
294
|
+
current = current.fun;
|
|
295
|
+
}
|
|
296
|
+
return [current, args.reverse()];
|
|
297
|
+
};
|
|
298
|
+
|
|
299
|
+
export const headOf = (term: Term): Term => {
|
|
300
|
+
let current = term;
|
|
301
|
+
while (current.kind === "App") current = current.fun;
|
|
302
|
+
return current;
|
|
303
|
+
};
|
|
304
|
+
|
|
305
|
+
export const argsOf = (term: Term) => stripComb(term)[1];
|
|
306
|
+
|
|
307
|
+
export const stripAbs = (term: Term): [{ name: string; type: Typ }[], Term] => {
|
|
308
|
+
const vars: { name: string; type: Typ }[] = [];
|
|
309
|
+
let current = term;
|
|
310
|
+
while (current.kind === "Abs") {
|
|
311
|
+
vars.push({ name: current.name, type: current.type });
|
|
312
|
+
current = current.body;
|
|
313
|
+
}
|
|
314
|
+
return [vars, current];
|
|
315
|
+
};
|
|
316
|
+
|
|
317
|
+
export const stripAbsBody = (term: Term): Term =>
|
|
318
|
+
term.kind === "Abs" ? stripAbsBody(term.body) : term;
|
|
319
|
+
|
|
320
|
+
export const sizeOfTerm = (term: Term): number => {
|
|
321
|
+
switch (term.kind) {
|
|
322
|
+
case "Abs":
|
|
323
|
+
return 1 + sizeOfTerm(term.body);
|
|
324
|
+
case "App":
|
|
325
|
+
return sizeOfTerm(term.fun) + sizeOfTerm(term.arg);
|
|
326
|
+
default:
|
|
327
|
+
return 1;
|
|
328
|
+
}
|
|
329
|
+
};
|
|
330
|
+
|
|
331
|
+
export const isAllConst = (term: Term) => term.kind === "Const" && term.name === "Pure.all";
|
|
332
|
+
|
|
333
|
+
export const stripAllBody = (term: Term): Term =>
|
|
334
|
+
term.kind === "App" && isAllConst(term.fun) && term.arg.kind === "Abs"
|
|
335
|
+
? stripAllBody(term.arg.body)
|
|
336
|
+
: term;
|
|
337
|
+
|
|
338
|
+
export const stripAllVars = (term: Term): { name: string; type: Typ }[] =>
|
|
339
|
+
term.kind === "App" && isAllConst(term.fun) && term.arg.kind === "Abs"
|
|
340
|
+
? [{ name: term.arg.name, type: term.arg.type }, ...stripAllVars(term.arg.body)]
|
|
341
|
+
: [];
|
|
342
|
+
|
|
343
|
+
// Rebuilds an application, keeping the original object when neither part changed.
|
|
344
|
+
export const updateApp = (term: App, fun: Term, arg: Term): Term =>
|
|
345
|
+
fun === term.fun && arg === term.arg ? term : mkApp(fun, arg);
|
|
346
|
+
|
|
347
|
+
export const updateAbs = (term: Abs, body: Term, type: Typ = term.type): Term =>
|
|
348
|
+
body === term.body && type === term.type ? term : mkAbs(term.name, type, body);
|
|
349
|
+
|
|
350
|
+
// incr_bv: increments the bound variables at or above level by increment.
|
|
351
|
+
const incrBvAt = (increment: number, level: number, term: Term): Term => {
|
|
352
|
+
if (looseOf(term) <= level) return term;
|
|
353
|
+
switch (term.kind) {
|
|
354
|
+
case "Bound":
|
|
355
|
+
return mkBound(term.index + increment);
|
|
356
|
+
case "Abs":
|
|
357
|
+
return updateAbs(term, incrBvAt(increment, level + 1, term.body));
|
|
358
|
+
case "App":
|
|
359
|
+
return updateApp(
|
|
360
|
+
term,
|
|
361
|
+
incrBvAt(increment, level, term.fun),
|
|
362
|
+
incrBvAt(increment, level, term.arg),
|
|
363
|
+
);
|
|
364
|
+
default:
|
|
365
|
+
return term;
|
|
366
|
+
}
|
|
367
|
+
};
|
|
368
|
+
|
|
369
|
+
export const incrBv = (increment: number, level: number, term: Term) =>
|
|
370
|
+
increment === 0 ? term : incrBvAt(increment, level, term);
|
|
371
|
+
|
|
372
|
+
export const incrBoundvars = (increment: number, term: Term) => incrBv(increment, 0, term);
|
|
373
|
+
|
|
374
|
+
// loose_bvar: whether term has a loose bound variable at level or beyond.
|
|
375
|
+
export const looseBvar = (term: Term, level: number) => looseOf(term) > level;
|
|
376
|
+
|
|
377
|
+
export const looseBvar1 = (term: Term, level: number): boolean => {
|
|
378
|
+
if (looseOf(term) <= level) return false;
|
|
379
|
+
switch (term.kind) {
|
|
380
|
+
case "Bound":
|
|
381
|
+
return term.index === level;
|
|
382
|
+
case "App":
|
|
383
|
+
return looseBvar1(term.fun, level) || looseBvar1(term.arg, level);
|
|
384
|
+
case "Abs":
|
|
385
|
+
return looseBvar1(term.body, level + 1);
|
|
386
|
+
default:
|
|
387
|
+
return false;
|
|
388
|
+
}
|
|
389
|
+
};
|
|
390
|
+
|
|
391
|
+
export const isOpen = (term: Term) => looseBvar(term, 0);
|
|
392
|
+
export const isDependent = (term: Term) => looseBvar1(term, 0);
|
|
393
|
+
|
|
394
|
+
// loose_bnos: the loose bound variables, in Isabelle's insertion order.
|
|
395
|
+
export const looseBnos = (term: Term): number[] => {
|
|
396
|
+
const numbers: number[] = [];
|
|
397
|
+
const add = (current: Term, level: number) => {
|
|
398
|
+
switch (current.kind) {
|
|
399
|
+
case "Bound":
|
|
400
|
+
if (current.index >= level && !numbers.includes(current.index - level))
|
|
401
|
+
numbers.unshift(current.index - level);
|
|
402
|
+
return;
|
|
403
|
+
case "Abs":
|
|
404
|
+
add(current.body, level + 1);
|
|
405
|
+
return;
|
|
406
|
+
case "App":
|
|
407
|
+
add(current.arg, level);
|
|
408
|
+
add(current.fun, level);
|
|
409
|
+
return;
|
|
410
|
+
default:
|
|
411
|
+
return;
|
|
412
|
+
}
|
|
413
|
+
};
|
|
414
|
+
add(term, 0);
|
|
415
|
+
return numbers;
|
|
416
|
+
};
|
|
417
|
+
|
|
418
|
+
// subst_bounds: Bound i becomes args[i]; loose bound variables beyond shift down.
|
|
419
|
+
const substBoundsAt = (args: readonly Term[], level: number, term: Term): Term => {
|
|
420
|
+
if (looseOf(term) <= level) return term;
|
|
421
|
+
switch (term.kind) {
|
|
422
|
+
case "Bound":
|
|
423
|
+
return term.index - level < args.length
|
|
424
|
+
? incrBoundvars(level, args[term.index - level])
|
|
425
|
+
: mkBound(term.index - args.length);
|
|
426
|
+
case "Abs":
|
|
427
|
+
return updateAbs(term, substBoundsAt(args, level + 1, term.body));
|
|
428
|
+
case "App":
|
|
429
|
+
return updateApp(
|
|
430
|
+
term,
|
|
431
|
+
substBoundsAt(args, level, term.fun),
|
|
432
|
+
substBoundsAt(args, level, term.arg),
|
|
433
|
+
);
|
|
434
|
+
default:
|
|
435
|
+
return term;
|
|
436
|
+
}
|
|
437
|
+
};
|
|
438
|
+
|
|
439
|
+
export const substBounds = (args: readonly Term[], body: Term) =>
|
|
440
|
+
args.length === 0 ? body : substBoundsAt(args, 0, body);
|
|
441
|
+
|
|
442
|
+
export const substBound = (arg: Term, body: Term) => substBounds([arg], body);
|
|
443
|
+
|
|
444
|
+
export const betapply = (fun: Term, arg: Term) =>
|
|
445
|
+
fun.kind === "Abs" ? substBound(arg, fun.body) : mkApp(fun, arg);
|
|
446
|
+
|
|
447
|
+
export const betapplys = (fun: Term, args: readonly Term[]) =>
|
|
448
|
+
args.reduce((result, arg) => betapply(result, arg), fun);
|
|
449
|
+
|
|
450
|
+
export const aconv = (left: Term, right: Term): boolean => {
|
|
451
|
+
if (left === right) return true;
|
|
452
|
+
switch (left.kind) {
|
|
453
|
+
case "App":
|
|
454
|
+
return right.kind === "App" && aconv(left.fun, right.fun) && aconv(left.arg, right.arg);
|
|
455
|
+
case "Abs":
|
|
456
|
+
return right.kind === "Abs" && aconv(left.body, right.body) && eqTyp(left.type, right.type);
|
|
457
|
+
case "Const":
|
|
458
|
+
case "Free":
|
|
459
|
+
return right.kind === left.kind && left.name === right.name && eqTyp(left.type, right.type);
|
|
460
|
+
case "Var":
|
|
461
|
+
return (
|
|
462
|
+
right.kind === "Var" &&
|
|
463
|
+
left.name === right.name &&
|
|
464
|
+
left.index === right.index &&
|
|
465
|
+
eqTyp(left.type, right.type)
|
|
466
|
+
);
|
|
467
|
+
case "Bound":
|
|
468
|
+
return right.kind === "Bound" && left.index === right.index;
|
|
469
|
+
}
|
|
470
|
+
};
|
|
471
|
+
|
|
472
|
+
// Structural equality including the names of abstractions, ML's (op =) on terms.
|
|
473
|
+
export const eqTerm = (left: Term, right: Term): boolean => {
|
|
474
|
+
if (left === right) return true;
|
|
475
|
+
switch (left.kind) {
|
|
476
|
+
case "App":
|
|
477
|
+
return right.kind === "App" && eqTerm(left.fun, right.fun) && eqTerm(left.arg, right.arg);
|
|
478
|
+
case "Abs":
|
|
479
|
+
return (
|
|
480
|
+
right.kind === "Abs" &&
|
|
481
|
+
left.name === right.name &&
|
|
482
|
+
eqTyp(left.type, right.type) &&
|
|
483
|
+
eqTerm(left.body, right.body)
|
|
484
|
+
);
|
|
485
|
+
default:
|
|
486
|
+
return aconv(left, right);
|
|
487
|
+
}
|
|
488
|
+
};
|
|
489
|
+
|
|
490
|
+
// could_unify: a fast filter, false only if the normal terms can't unify.
|
|
491
|
+
const matchRands = (left: Term, right: Term): boolean => {
|
|
492
|
+
let currentLeft = left;
|
|
493
|
+
let currentRight = right;
|
|
494
|
+
while (currentLeft.kind === "App" && currentRight.kind === "App") {
|
|
495
|
+
if (!couldUnify(currentLeft.arg, currentRight.arg)) return false;
|
|
496
|
+
currentLeft = currentLeft.fun;
|
|
497
|
+
currentRight = currentRight.fun;
|
|
498
|
+
}
|
|
499
|
+
return true;
|
|
500
|
+
};
|
|
501
|
+
|
|
502
|
+
export const couldUnify = (left: Term, right: Term): boolean => {
|
|
503
|
+
const leftHead = headOf(left);
|
|
504
|
+
const rightHead = headOf(right);
|
|
505
|
+
if (rightHead.kind === "Var" || leftHead.kind === "Var") return true;
|
|
506
|
+
if (leftHead.kind === "Abs" || rightHead.kind === "Abs") return true;
|
|
507
|
+
if (leftHead.kind === "Const" && rightHead.kind === "Const")
|
|
508
|
+
return leftHead.name === rightHead.name && matchRands(left, right);
|
|
509
|
+
if (leftHead.kind === "Free" && rightHead.kind === "Free")
|
|
510
|
+
return leftHead.name === rightHead.name && matchRands(left, right);
|
|
511
|
+
if (leftHead.kind === "Bound" && rightHead.kind === "Bound")
|
|
512
|
+
return leftHead.index === rightHead.index && matchRands(left, right);
|
|
513
|
+
return false;
|
|
514
|
+
};
|
|
515
|
+
|
|
516
|
+
// abstract_over: replaces the occurrences of pattern with Bound, ready to become an Abs body.
|
|
517
|
+
const abstractAt = (pattern: Term, level: number, term: Term): Term => {
|
|
518
|
+
if (!mayOccur(pattern, term)) return term;
|
|
519
|
+
if (aconv(pattern, term)) return mkBound(level);
|
|
520
|
+
switch (term.kind) {
|
|
521
|
+
case "Abs":
|
|
522
|
+
return updateAbs(term, abstractAt(pattern, level + 1, term.body));
|
|
523
|
+
case "App":
|
|
524
|
+
return updateApp(
|
|
525
|
+
term,
|
|
526
|
+
abstractAt(pattern, level, term.fun),
|
|
527
|
+
abstractAt(pattern, level, term.arg),
|
|
528
|
+
);
|
|
529
|
+
default:
|
|
530
|
+
return term;
|
|
531
|
+
}
|
|
532
|
+
};
|
|
533
|
+
|
|
534
|
+
export const abstractOver = (pattern: Term, body: Term) => abstractAt(pattern, 0, body);
|
|
535
|
+
|
|
536
|
+
const baseName = (name: string) => name.slice(name.lastIndexOf(".") + 1);
|
|
537
|
+
|
|
538
|
+
export const termName = (term: Term) =>
|
|
539
|
+
term.kind === "Const"
|
|
540
|
+
? baseName(term.name)
|
|
541
|
+
: term.kind === "Free" || term.kind === "Var"
|
|
542
|
+
? term.name
|
|
543
|
+
: "uu";
|
|
544
|
+
|
|
545
|
+
export const lambdaName = (name: string, variable: Term, body: Term) =>
|
|
546
|
+
mkAbs(name === "" ? termName(variable) : name, fastypeOf(variable), abstractOver(variable, body));
|
|
547
|
+
|
|
548
|
+
export const lambda = (variable: Term, body: Term) => lambdaName("", variable, body);
|
|
549
|
+
|
|
550
|
+
export const absfree = (name: string, type: Typ, body: Term) =>
|
|
551
|
+
mkAbs(name, type, abstractOver(mkFree(name, type), body));
|
|
552
|
+
|
|
553
|
+
export const mapTypes = (mapType: (type: Typ) => Typ, term: Term): Term => {
|
|
554
|
+
const visit = (current: Term): Term => {
|
|
555
|
+
switch (current.kind) {
|
|
556
|
+
case "Const":
|
|
557
|
+
case "Free": {
|
|
558
|
+
const type = mapType(current.type);
|
|
559
|
+
return type === current.type ? current : { ...current, type };
|
|
560
|
+
}
|
|
561
|
+
case "Var": {
|
|
562
|
+
const type = mapType(current.type);
|
|
563
|
+
return type === current.type ? current : { ...current, type };
|
|
564
|
+
}
|
|
565
|
+
case "Bound":
|
|
566
|
+
return current;
|
|
567
|
+
case "Abs":
|
|
568
|
+
return updateAbs(current, visit(current.body), mapType(current.type));
|
|
569
|
+
case "App":
|
|
570
|
+
return updateApp(current, visit(current.fun), visit(current.arg));
|
|
571
|
+
}
|
|
572
|
+
};
|
|
573
|
+
return visit(term);
|
|
574
|
+
};
|
|
575
|
+
|
|
576
|
+
export const mapAtyps = (mapAtyp: (type: Typ) => Typ, type: Typ): Typ => {
|
|
577
|
+
if (type.kind !== "Type") return mapAtyp(type);
|
|
578
|
+
const args = type.args.map((arg) => mapAtyps(mapAtyp, arg));
|
|
579
|
+
return args.every((arg, index) => arg === type.args[index]) ? type : mkType(type.name, args);
|
|
580
|
+
};
|
|
581
|
+
|
|
582
|
+
export const mapAterms = (mapAterm: (term: Term) => Term, term: Term): Term => {
|
|
583
|
+
switch (term.kind) {
|
|
584
|
+
case "Abs":
|
|
585
|
+
return updateAbs(term, mapAterms(mapAterm, term.body));
|
|
586
|
+
case "App":
|
|
587
|
+
return updateApp(term, mapAterms(mapAterm, term.fun), mapAterms(mapAterm, term.arg));
|
|
588
|
+
default:
|
|
589
|
+
return mapAterm(term);
|
|
590
|
+
}
|
|
591
|
+
};
|
|
592
|
+
|
|
593
|
+
export const foldAterms = <State>(
|
|
594
|
+
visit: (term: Term, state: State) => State,
|
|
595
|
+
term: Term,
|
|
596
|
+
state: State,
|
|
597
|
+
): State => {
|
|
598
|
+
switch (term.kind) {
|
|
599
|
+
case "App":
|
|
600
|
+
return foldAterms(visit, term.arg, foldAterms(visit, term.fun, state));
|
|
601
|
+
case "Abs":
|
|
602
|
+
return foldAterms(visit, term.body, state);
|
|
603
|
+
default:
|
|
604
|
+
return visit(term, state);
|
|
605
|
+
}
|
|
606
|
+
};
|
|
607
|
+
|
|
608
|
+
// fold_aterms over the schematic variables only, skipping the subterms without one.
|
|
609
|
+
export const foldVars = <State>(
|
|
610
|
+
visit: (variable: Var, state: State) => State,
|
|
611
|
+
term: Term,
|
|
612
|
+
state: State,
|
|
613
|
+
): State => {
|
|
614
|
+
if ((flagsOf(term) & HAS_VAR) === 0) return state;
|
|
615
|
+
switch (term.kind) {
|
|
616
|
+
case "App":
|
|
617
|
+
return foldVars(visit, term.arg, foldVars(visit, term.fun, state));
|
|
618
|
+
case "Abs":
|
|
619
|
+
return foldVars(visit, term.body, state);
|
|
620
|
+
case "Var":
|
|
621
|
+
return visit(term, state);
|
|
622
|
+
default:
|
|
623
|
+
return state;
|
|
624
|
+
}
|
|
625
|
+
};
|
|
626
|
+
|
|
627
|
+
export const foldAtyps = <State>(
|
|
628
|
+
visit: (type: Typ, state: State) => State,
|
|
629
|
+
type: Typ,
|
|
630
|
+
state: State,
|
|
631
|
+
): State =>
|
|
632
|
+
type.kind === "Type"
|
|
633
|
+
? type.args.reduce((result, arg) => foldAtyps(visit, arg, result), state)
|
|
634
|
+
: visit(type, state);
|
|
635
|
+
|
|
636
|
+
export const foldTypes = <State>(
|
|
637
|
+
visit: (type: Typ, state: State) => State,
|
|
638
|
+
term: Term,
|
|
639
|
+
state: State,
|
|
640
|
+
): State => {
|
|
641
|
+
switch (term.kind) {
|
|
642
|
+
case "Const":
|
|
643
|
+
case "Free":
|
|
644
|
+
case "Var":
|
|
645
|
+
return visit(term.type, state);
|
|
646
|
+
case "Bound":
|
|
647
|
+
return state;
|
|
648
|
+
case "Abs":
|
|
649
|
+
return foldTypes(visit, term.body, visit(term.type, state));
|
|
650
|
+
case "App":
|
|
651
|
+
return foldTypes(visit, term.arg, foldTypes(visit, term.fun, state));
|
|
652
|
+
}
|
|
653
|
+
};
|
|
654
|
+
|
|
655
|
+
export const existsSubterm = (predicate: (term: Term) => boolean, term: Term): boolean => {
|
|
656
|
+
if (predicate(term)) return true;
|
|
657
|
+
if (term.kind === "App")
|
|
658
|
+
return existsSubterm(predicate, term.fun) || existsSubterm(predicate, term.arg);
|
|
659
|
+
if (term.kind === "Abs") return existsSubterm(predicate, term.body);
|
|
660
|
+
return false;
|
|
661
|
+
};
|
|
662
|
+
|
|
663
|
+
export const existsSubtype = (predicate: (type: Typ) => boolean, type: Typ): boolean =>
|
|
664
|
+
predicate(type) ||
|
|
665
|
+
(type.kind === "Type" && type.args.some((arg) => existsSubtype(predicate, arg)));
|
|
666
|
+
|
|
667
|
+
export const existsType = (predicate: (type: Typ) => boolean, term: Term): boolean => {
|
|
668
|
+
switch (term.kind) {
|
|
669
|
+
case "Const":
|
|
670
|
+
case "Free":
|
|
671
|
+
case "Var":
|
|
672
|
+
return predicate(term.type);
|
|
673
|
+
case "Bound":
|
|
674
|
+
return false;
|
|
675
|
+
case "Abs":
|
|
676
|
+
return predicate(term.type) || existsType(predicate, term.body);
|
|
677
|
+
case "App":
|
|
678
|
+
return existsType(predicate, term.fun) || existsType(predicate, term.arg);
|
|
679
|
+
}
|
|
680
|
+
};
|
|
681
|
+
|
|
682
|
+
export const eqIndexname = (left: Indexname, right: Indexname) =>
|
|
683
|
+
left.index === right.index && left.name === right.name;
|
|
684
|
+
|
|
685
|
+
const sameVar = (left: Var, right: Var) =>
|
|
686
|
+
left.name === right.name && left.index === right.index && eqTyp(left.type, right.type);
|
|
687
|
+
|
|
688
|
+
// add_vars: the schematic variables, latest first, as Isabelle's insert builds the list.
|
|
689
|
+
export const addVars = (term: Term, vars: Var[]): Var[] =>
|
|
690
|
+
foldVars(
|
|
691
|
+
(current, result: Var[]) =>
|
|
692
|
+
!result.some((other) => sameVar(other, current)) ? [current, ...result] : result,
|
|
693
|
+
term,
|
|
694
|
+
vars,
|
|
695
|
+
);
|
|
696
|
+
|
|
697
|
+
export const addTVarsT = (type: Typ, tvars: TVar[]): TVar[] =>
|
|
698
|
+
foldAtyps(
|
|
699
|
+
(current, result: TVar[]) =>
|
|
700
|
+
current.kind === "TVar" &&
|
|
701
|
+
!result.some(
|
|
702
|
+
(other) =>
|
|
703
|
+
other.name === current.name &&
|
|
704
|
+
other.index === current.index &&
|
|
705
|
+
eqSort(other.sort, current.sort),
|
|
706
|
+
)
|
|
707
|
+
? [current, ...result]
|
|
708
|
+
: result,
|
|
709
|
+
type,
|
|
710
|
+
tvars,
|
|
711
|
+
);
|
|
712
|
+
|
|
713
|
+
export const addTVars = (term: Term, tvars: TVar[]) =>
|
|
714
|
+
foldTypes((type, result: TVar[]) => addTVarsT(type, result), term, tvars);
|
|
715
|
+
|
|
716
|
+
export const addFreeNames = (term: Term, names: string[]): string[] =>
|
|
717
|
+
foldAterms(
|
|
718
|
+
(current, result: string[]) =>
|
|
719
|
+
current.kind === "Free" && !result.includes(current.name)
|
|
720
|
+
? [current.name, ...result]
|
|
721
|
+
: result,
|
|
722
|
+
term,
|
|
723
|
+
names,
|
|
724
|
+
);
|
|
725
|
+
|
|
726
|
+
export const addFrees = (term: Term, frees: Term[]): Term[] =>
|
|
727
|
+
foldAterms(
|
|
728
|
+
(current, result: Term[]) =>
|
|
729
|
+
current.kind === "Free" && !result.some((other) => aconv(other, current))
|
|
730
|
+
? [current, ...result]
|
|
731
|
+
: result,
|
|
732
|
+
term,
|
|
733
|
+
frees,
|
|
734
|
+
);
|
|
735
|
+
|
|
736
|
+
export const addTFreeNames = (term: Term, names: string[]): string[] =>
|
|
737
|
+
foldTypes(
|
|
738
|
+
(type, result: string[]) =>
|
|
739
|
+
foldAtyps(
|
|
740
|
+
(current, inner: string[]) =>
|
|
741
|
+
current.kind === "TFree" && !inner.includes(current.name)
|
|
742
|
+
? [current.name, ...inner]
|
|
743
|
+
: inner,
|
|
744
|
+
type,
|
|
745
|
+
result,
|
|
746
|
+
),
|
|
747
|
+
term,
|
|
748
|
+
names,
|
|
749
|
+
);
|
|
750
|
+
|
|
751
|
+
export const isSchematic = (term: Term) => maxidxOfTerm(term) >= 0;
|
|
752
|
+
|
|
753
|
+
// match_bvs: the pairs of corresponding abstraction names while two terms look alike.
|
|
754
|
+
export const matchBvs = (
|
|
755
|
+
left: Term,
|
|
756
|
+
right: Term,
|
|
757
|
+
pairs: [string, string][],
|
|
758
|
+
): [string, string][] => {
|
|
759
|
+
if (left.kind === "Abs" && right.kind === "Abs") {
|
|
760
|
+
const added: [string, string][] =
|
|
761
|
+
left.name !== "" && right.name !== "" ? [[left.name, right.name], ...pairs] : pairs;
|
|
762
|
+
return matchBvs(left.body, right.body, added);
|
|
763
|
+
}
|
|
764
|
+
if (left.kind === "App" && right.kind === "App")
|
|
765
|
+
return matchBvs(left.fun, right.fun, matchBvs(left.arg, right.arg, pairs));
|
|
766
|
+
return pairs;
|
|
767
|
+
};
|
|
768
|
+
|
|
769
|
+
export const matchBvars = (left: Term, right: Term, pairs: [string, string][]) =>
|
|
770
|
+
matchBvs(stripAbsBody(left), stripAbsBody(right), pairs);
|
|
771
|
+
|
|
772
|
+
export const mapAbsVars = (rename: (name: string) => string, term: Term): Term => {
|
|
773
|
+
switch (term.kind) {
|
|
774
|
+
case "Abs": {
|
|
775
|
+
const name = rename(term.name);
|
|
776
|
+
const body = mapAbsVars(rename, term.body);
|
|
777
|
+
return name === term.name ? updateAbs(term, body) : mkAbs(name, term.type, body);
|
|
778
|
+
}
|
|
779
|
+
case "App":
|
|
780
|
+
return updateApp(term, mapAbsVars(rename, term.fun), mapAbsVars(rename, term.arg));
|
|
781
|
+
default:
|
|
782
|
+
return term;
|
|
783
|
+
}
|
|
784
|
+
};
|
|
785
|
+
|
|
786
|
+
// rename_abs: renames the abstractions of term after those of obj where pat matches obj.
|
|
787
|
+
export const renameAbs = (pattern: Term, object: Term, term: Term): Term | undefined => {
|
|
788
|
+
const renaming = new Map<string, string>();
|
|
789
|
+
matchBvs(pattern, object, []).forEach(([from, to]) => {
|
|
790
|
+
if (!renaming.has(from)) renaming.set(from, to);
|
|
791
|
+
});
|
|
792
|
+
if ([...renaming].every(([from, to]) => from === to)) return undefined;
|
|
793
|
+
const renamed = mapAbsVars((name) => renaming.get(name) ?? name, term);
|
|
794
|
+
return renamed === term ? undefined : renamed;
|
|
795
|
+
};
|
|
796
|
+
|
|
797
|
+
// subst_free: replaces subterms by the first pair whose left side they equal.
|
|
798
|
+
export const substFree = (pairs: readonly [Term, Term][], term: Term): Term => {
|
|
799
|
+
if (pairs.length === 0) return term;
|
|
800
|
+
const visit = (current: Term): Term => {
|
|
801
|
+
const pair = pairs.find(([from]) => aconv(from, current));
|
|
802
|
+
if (pair) return pair[1];
|
|
803
|
+
if (current.kind === "Abs") return updateAbs(current, visit(current.body));
|
|
804
|
+
if (current.kind === "App") return updateApp(current, visit(current.fun), visit(current.arg));
|
|
805
|
+
return current;
|
|
806
|
+
};
|
|
807
|
+
return visit(term);
|
|
808
|
+
};
|