tla-ts 0.0.4-dev.2be6058 → 0.0.4-dev.2da24e1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +37 -126
- package/dist/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 +255 -56
- 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 +25 -6
- 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,753 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/unify.ML, Huet's higher-order unification with the search
|
|
2
|
+
// bound of 60. Copyright (c) 1986-2025 University of Cambridge, Technische Universitaet Muenchen,
|
|
3
|
+
// and contributors, see LICENSE.
|
|
4
|
+
|
|
5
|
+
import { checkInterrupt, type Limits } from "./interrupt";
|
|
6
|
+
import { TlaIsabelleError } from "../../../errors";
|
|
7
|
+
import {
|
|
8
|
+
envBinderTypes,
|
|
9
|
+
envBodyType,
|
|
10
|
+
fastype,
|
|
11
|
+
genvar,
|
|
12
|
+
genvars,
|
|
13
|
+
headNorm,
|
|
14
|
+
lookup,
|
|
15
|
+
normTerm,
|
|
16
|
+
update,
|
|
17
|
+
vupdate,
|
|
18
|
+
type Envir,
|
|
19
|
+
} from "./envir";
|
|
20
|
+
import { combound, rlistAbs, type Binder } from "./logic";
|
|
21
|
+
import { unifyPattern, unifyTypesEnvir } from "./pattern";
|
|
22
|
+
import {
|
|
23
|
+
consSeq,
|
|
24
|
+
emptySeq,
|
|
25
|
+
itRightSeq,
|
|
26
|
+
deferSeq,
|
|
27
|
+
mapSeq,
|
|
28
|
+
mapsSeq,
|
|
29
|
+
singleSeq,
|
|
30
|
+
type Seq,
|
|
31
|
+
} from "./seq";
|
|
32
|
+
import { indexnameOrd } from "./table";
|
|
33
|
+
import { lookupTyEnv } from "./type";
|
|
34
|
+
import {
|
|
35
|
+
aconv,
|
|
36
|
+
eqTyp,
|
|
37
|
+
funTs,
|
|
38
|
+
flagsOf,
|
|
39
|
+
HAS_VAR,
|
|
40
|
+
headOf,
|
|
41
|
+
incrBoundvars,
|
|
42
|
+
listComb,
|
|
43
|
+
looseBnos,
|
|
44
|
+
mkAbs,
|
|
45
|
+
mkApp,
|
|
46
|
+
mkBound,
|
|
47
|
+
stripAbsBody,
|
|
48
|
+
stripComb,
|
|
49
|
+
type Term,
|
|
50
|
+
type Typ,
|
|
51
|
+
type Var,
|
|
52
|
+
} from "./term";
|
|
53
|
+
|
|
54
|
+
const SEARCH_BOUND = 60;
|
|
55
|
+
|
|
56
|
+
interface Dpair {
|
|
57
|
+
readonly binders: readonly Binder[];
|
|
58
|
+
readonly left: Term;
|
|
59
|
+
readonly right: Term;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
export type Tpair = readonly [Term, Term];
|
|
63
|
+
|
|
64
|
+
class CantUnify {}
|
|
65
|
+
class ChangeFail {}
|
|
66
|
+
|
|
67
|
+
const binderTypes = (binders: readonly Binder[]) => binders.map((binder) => binder.type);
|
|
68
|
+
|
|
69
|
+
const fastypeIn = (envir: Envir, binders: readonly Binder[], term: Term) =>
|
|
70
|
+
fastype(envir, binderTypes(binders), term);
|
|
71
|
+
|
|
72
|
+
const etaNorm = (envir: Envir, binders: readonly Binder[], term: Term): Term => {
|
|
73
|
+
const etif = (type: Typ, current: Term): Term => {
|
|
74
|
+
if (type.kind === "Type" && type.name === "fun")
|
|
75
|
+
return mkAbs(
|
|
76
|
+
"",
|
|
77
|
+
type.args[0],
|
|
78
|
+
etif(type.args[1], mkApp(incrBoundvars(1, current), mkBound(0))),
|
|
79
|
+
);
|
|
80
|
+
if (type.kind === "TVar") {
|
|
81
|
+
const assigned = lookupTyEnv(envir.tyenv, type);
|
|
82
|
+
return assigned === undefined ? current : etif(assigned, current);
|
|
83
|
+
}
|
|
84
|
+
return current;
|
|
85
|
+
};
|
|
86
|
+
const etaNm = (scope: readonly Binder[], current: Term): Term =>
|
|
87
|
+
current.kind === "Abs"
|
|
88
|
+
? mkAbs(
|
|
89
|
+
current.name,
|
|
90
|
+
current.type,
|
|
91
|
+
etaNm([{ name: current.name, type: current.type }, ...scope], current.body),
|
|
92
|
+
)
|
|
93
|
+
: etif(fastypeIn(envir, scope, current), current);
|
|
94
|
+
return etaNm(binders, term);
|
|
95
|
+
};
|
|
96
|
+
|
|
97
|
+
const sameIndexname = (
|
|
98
|
+
left: { name: string; index: number },
|
|
99
|
+
right: { name: string; index: number },
|
|
100
|
+
) => left.name === right.name && left.index === right.index;
|
|
101
|
+
|
|
102
|
+
const occursTerms = (seen: Var[], envir: Envir, variable: Var, terms: readonly Term[]): boolean => {
|
|
103
|
+
const occur = (term: Term): boolean => {
|
|
104
|
+
if ((flagsOf(term) & HAS_VAR) === 0) return false;
|
|
105
|
+
switch (term.kind) {
|
|
106
|
+
case "Const":
|
|
107
|
+
case "Bound":
|
|
108
|
+
case "Free":
|
|
109
|
+
return false;
|
|
110
|
+
case "Var": {
|
|
111
|
+
if (seen.some((other) => sameIndexname(other, term))) return false;
|
|
112
|
+
if (sameIndexname(variable, term)) return true;
|
|
113
|
+
seen.push(term);
|
|
114
|
+
const assigned = lookup(envir, term);
|
|
115
|
+
return assigned !== undefined && occur(assigned);
|
|
116
|
+
}
|
|
117
|
+
case "Abs":
|
|
118
|
+
return occur(term.body);
|
|
119
|
+
case "App":
|
|
120
|
+
return occur(term.arg) || occur(term.fun);
|
|
121
|
+
}
|
|
122
|
+
};
|
|
123
|
+
return terms.some(occur);
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
const headOfIn = (envir: Envir, term: Term): Term => {
|
|
127
|
+
if (term.kind === "App") return headOfIn(envir, term.fun);
|
|
128
|
+
if (term.kind === "Var") {
|
|
129
|
+
const assigned = lookup(envir, term);
|
|
130
|
+
return assigned === undefined ? term : headOfIn(envir, assigned);
|
|
131
|
+
}
|
|
132
|
+
return term;
|
|
133
|
+
};
|
|
134
|
+
|
|
135
|
+
type Occurrence = "none" | "nonrigid" | "rigid";
|
|
136
|
+
|
|
137
|
+
const rigidOccursTerm = (seen: Var[], envir: Envir, variable: Var, term: Term): Occurrence => {
|
|
138
|
+
const nonrigid = (current: Term): Occurrence =>
|
|
139
|
+
occursTerms(seen, envir, variable, [current]) ? "nonrigid" : "none";
|
|
140
|
+
const occomb = (current: Term): Occurrence => {
|
|
141
|
+
if (current.kind !== "App") return occur(current);
|
|
142
|
+
const argument = occur(current.arg);
|
|
143
|
+
if (argument === "rigid") return "rigid";
|
|
144
|
+
const rest = occomb(current.fun);
|
|
145
|
+
return rest === "none" ? argument : rest;
|
|
146
|
+
};
|
|
147
|
+
const occur = (current: Term): Occurrence => {
|
|
148
|
+
switch (current.kind) {
|
|
149
|
+
case "Const":
|
|
150
|
+
case "Bound":
|
|
151
|
+
case "Free":
|
|
152
|
+
return "none";
|
|
153
|
+
case "Var": {
|
|
154
|
+
if (seen.some((other) => sameIndexname(other, current))) return "none";
|
|
155
|
+
if (sameIndexname(variable, current)) return "rigid";
|
|
156
|
+
seen.push(current);
|
|
157
|
+
const assigned = lookup(envir, current);
|
|
158
|
+
return assigned === undefined ? "none" : occur(assigned);
|
|
159
|
+
}
|
|
160
|
+
case "Abs":
|
|
161
|
+
return occur(current.body);
|
|
162
|
+
case "App": {
|
|
163
|
+
const head = headOfIn(envir, current.fun);
|
|
164
|
+
if (head.kind === "Var") return sameIndexname(variable, head) ? "rigid" : nonrigid(current);
|
|
165
|
+
if (head.kind === "Abs") return nonrigid(current);
|
|
166
|
+
return occomb(current);
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
};
|
|
170
|
+
return occur(term);
|
|
171
|
+
};
|
|
172
|
+
|
|
173
|
+
const unifyTypes = (left: Typ, right: Typ, envir: Envir) => {
|
|
174
|
+
const result = unifyTypesEnvir(left, right, envir);
|
|
175
|
+
if (result === undefined) throw new CantUnify();
|
|
176
|
+
return result;
|
|
177
|
+
};
|
|
178
|
+
|
|
179
|
+
// get_eta_var: the variable a term eta-contracts to over the binders, or undefined for ASSIGN.
|
|
180
|
+
const getEtaVar = (binders: readonly Binder[], level: number, term: Term): Var | undefined => {
|
|
181
|
+
if (binders.length === 0) return term.kind === "Var" ? term : undefined;
|
|
182
|
+
if (term.kind === "App" && term.arg.kind === "Bound" && term.arg.index === level)
|
|
183
|
+
return getEtaVar(binders.slice(1), level + 1, term.fun);
|
|
184
|
+
return undefined;
|
|
185
|
+
};
|
|
186
|
+
|
|
187
|
+
// assignment: undefined where Isabelle raises ASSIGN.
|
|
188
|
+
const assignment = (
|
|
189
|
+
binders: readonly Binder[],
|
|
190
|
+
left: Term,
|
|
191
|
+
right: Term,
|
|
192
|
+
envir: Envir,
|
|
193
|
+
): Envir | undefined => {
|
|
194
|
+
const variable = getEtaVar(binders, 0, left);
|
|
195
|
+
if (variable === undefined) return undefined;
|
|
196
|
+
const occurrence = rigidOccursTerm([], envir, variable, right);
|
|
197
|
+
if (occurrence === "nonrigid") return undefined;
|
|
198
|
+
if (occurrence === "rigid") throw new CantUnify();
|
|
199
|
+
const unified = unifyTypes(
|
|
200
|
+
envBodyType(envir, variable.type),
|
|
201
|
+
fastypeIn(envir, binders, right),
|
|
202
|
+
envir,
|
|
203
|
+
);
|
|
204
|
+
return update(variable, rlistAbs(binders, right), unified);
|
|
205
|
+
};
|
|
206
|
+
|
|
207
|
+
const newDpair = (
|
|
208
|
+
binders: readonly Binder[],
|
|
209
|
+
left: Term,
|
|
210
|
+
right: Term,
|
|
211
|
+
envir: Envir,
|
|
212
|
+
): [Dpair, Envir] => {
|
|
213
|
+
if (left.kind === "Abs" && right.kind === "Abs") {
|
|
214
|
+
const unified = unifyTypes(left.type, right.type, envir);
|
|
215
|
+
const name = left.name === "" ? right.name : left.name;
|
|
216
|
+
return newDpair([{ name, type: left.type }, ...binders], left.body, right.body, unified);
|
|
217
|
+
}
|
|
218
|
+
if (left.kind === "Abs" || right.kind === "Abs") throw new TlaIsabelleError("TERM", "new_dpair");
|
|
219
|
+
return [{ binders, left, right }, envir];
|
|
220
|
+
};
|
|
221
|
+
|
|
222
|
+
const headNormDpair = (envir: Envir, dpair: Dpair) =>
|
|
223
|
+
newDpair(
|
|
224
|
+
dpair.binders,
|
|
225
|
+
etaNorm(envir, dpair.binders, headNorm(envir, dpair.left)),
|
|
226
|
+
etaNorm(envir, dpair.binders, headNorm(envir, dpair.right)),
|
|
227
|
+
envir,
|
|
228
|
+
);
|
|
229
|
+
|
|
230
|
+
interface Simplified {
|
|
231
|
+
readonly envir: Envir;
|
|
232
|
+
readonly flexflex: Dpair[];
|
|
233
|
+
readonly flexrigid: Dpair[];
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
const simpl0 = (start: Dpair, state: Simplified): Simplified => {
|
|
237
|
+
const [dpair, envir] = headNormDpair(state.envir, start);
|
|
238
|
+
const simRands = (left: Term, right: Term, current: Simplified): Simplified => {
|
|
239
|
+
if (left.kind === "App" && right.kind === "App")
|
|
240
|
+
return simpl0(
|
|
241
|
+
{ binders: dpair.binders, left: left.arg, right: right.arg },
|
|
242
|
+
simRands(left.fun, right.fun, current),
|
|
243
|
+
);
|
|
244
|
+
if (left.kind === "App" || right.kind === "App")
|
|
245
|
+
throw new TlaIsabelleError("TERM", "SIMPL: operands mismatch");
|
|
246
|
+
return current;
|
|
247
|
+
};
|
|
248
|
+
const leftHead = headOf(dpair.left);
|
|
249
|
+
const rightHead = headOf(dpair.right);
|
|
250
|
+
const rest = { flexflex: state.flexflex, flexrigid: state.flexrigid };
|
|
251
|
+
if (leftHead.kind === "Var" && rightHead.kind === "Var") {
|
|
252
|
+
const unified = unifyTypes(
|
|
253
|
+
envBodyType(envir, leftHead.type),
|
|
254
|
+
envBodyType(envir, rightHead.type),
|
|
255
|
+
envir,
|
|
256
|
+
);
|
|
257
|
+
return { envir: unified, flexflex: [dpair, ...state.flexflex], flexrigid: state.flexrigid };
|
|
258
|
+
}
|
|
259
|
+
if (leftHead.kind === "Var") {
|
|
260
|
+
const assigned = assignment(dpair.binders, dpair.left, dpair.right, envir);
|
|
261
|
+
return assigned === undefined
|
|
262
|
+
? { envir, flexflex: state.flexflex, flexrigid: [dpair, ...state.flexrigid] }
|
|
263
|
+
: { envir: assigned, ...rest };
|
|
264
|
+
}
|
|
265
|
+
if (rightHead.kind === "Var") {
|
|
266
|
+
const assigned = assignment(dpair.binders, dpair.right, dpair.left, envir);
|
|
267
|
+
return assigned === undefined
|
|
268
|
+
? {
|
|
269
|
+
envir,
|
|
270
|
+
flexflex: state.flexflex,
|
|
271
|
+
flexrigid: [
|
|
272
|
+
{ binders: dpair.binders, left: dpair.right, right: dpair.left },
|
|
273
|
+
...state.flexrigid,
|
|
274
|
+
],
|
|
275
|
+
}
|
|
276
|
+
: { envir: assigned, ...rest };
|
|
277
|
+
}
|
|
278
|
+
if (
|
|
279
|
+
(leftHead.kind === "Const" && rightHead.kind === "Const") ||
|
|
280
|
+
(leftHead.kind === "Free" && rightHead.kind === "Free")
|
|
281
|
+
) {
|
|
282
|
+
if (leftHead.name !== rightHead.name) throw new CantUnify();
|
|
283
|
+
return simRands(dpair.left, dpair.right, {
|
|
284
|
+
envir: unifyTypes(leftHead.type, rightHead.type, envir),
|
|
285
|
+
...rest,
|
|
286
|
+
});
|
|
287
|
+
}
|
|
288
|
+
if (leftHead.kind === "Bound" && rightHead.kind === "Bound") {
|
|
289
|
+
if (leftHead.index !== rightHead.index) throw new CantUnify();
|
|
290
|
+
return simRands(dpair.left, dpair.right, { envir, ...rest });
|
|
291
|
+
}
|
|
292
|
+
throw new CantUnify();
|
|
293
|
+
};
|
|
294
|
+
|
|
295
|
+
const isChanged = (envir: Envir, term: Term): boolean => {
|
|
296
|
+
if (term.kind === "App") return isChanged(envir, term.fun);
|
|
297
|
+
return term.kind === "Var" && lookup(envir, term) !== undefined;
|
|
298
|
+
};
|
|
299
|
+
|
|
300
|
+
const simpl = (envir: Envir, dpairs: readonly Dpair[]): Simplified => {
|
|
301
|
+
const all = dpairs.reduceRight<Simplified>((state, dpair) => simpl0(dpair, state), {
|
|
302
|
+
envir,
|
|
303
|
+
flexflex: [],
|
|
304
|
+
flexrigid: [],
|
|
305
|
+
});
|
|
306
|
+
const remaining = [...all.flexrigid, ...all.flexflex];
|
|
307
|
+
return remaining.some(
|
|
308
|
+
(dpair) => isChanged(all.envir, dpair.left) || isChanged(all.envir, dpair.right),
|
|
309
|
+
)
|
|
310
|
+
? simpl(all.envir, remaining)
|
|
311
|
+
: all;
|
|
312
|
+
};
|
|
313
|
+
|
|
314
|
+
const makeArgs = (
|
|
315
|
+
name: string,
|
|
316
|
+
binder: readonly Typ[],
|
|
317
|
+
envir: Envir,
|
|
318
|
+
types: readonly Typ[],
|
|
319
|
+
): [Envir, Term[]] => {
|
|
320
|
+
if (types.length === 0) return [envir, []];
|
|
321
|
+
const [updated, vars] = genvars(
|
|
322
|
+
name,
|
|
323
|
+
envir,
|
|
324
|
+
types.map((type) => funTs(binder, type)),
|
|
325
|
+
);
|
|
326
|
+
return [updated, vars.map((variable) => combound(variable, 0, binder.length))];
|
|
327
|
+
};
|
|
328
|
+
|
|
329
|
+
const typesAbs = (types: readonly Typ[], body: Term) =>
|
|
330
|
+
types.reduceRight((result, type) => mkAbs("", type, result), body);
|
|
331
|
+
|
|
332
|
+
const stripType = (envir: Envir, type: Typ): [Typ[], Typ] => [
|
|
333
|
+
envBinderTypes(envir, type),
|
|
334
|
+
envBodyType(envir, type),
|
|
335
|
+
];
|
|
336
|
+
|
|
337
|
+
interface Copy {
|
|
338
|
+
readonly term: Term;
|
|
339
|
+
readonly envir: Envir;
|
|
340
|
+
readonly dpairs: readonly Dpair[];
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
const matchcopy = (name: string) => {
|
|
344
|
+
const copy = (
|
|
345
|
+
binders: readonly Binder[],
|
|
346
|
+
targs: readonly Term[],
|
|
347
|
+
target: Term,
|
|
348
|
+
envir: Envir,
|
|
349
|
+
dpairs: readonly Dpair[],
|
|
350
|
+
): Seq<Copy> => {
|
|
351
|
+
const copycons = (
|
|
352
|
+
uarg: Term,
|
|
353
|
+
prefix: { args: Term[]; envir: Envir; dpairs: readonly Dpair[] },
|
|
354
|
+
) =>
|
|
355
|
+
mapSeq(
|
|
356
|
+
(result: Copy) => ({
|
|
357
|
+
args: [result.term, ...prefix.args],
|
|
358
|
+
envir: result.envir,
|
|
359
|
+
dpairs: result.dpairs,
|
|
360
|
+
}),
|
|
361
|
+
copy(
|
|
362
|
+
binders,
|
|
363
|
+
targs,
|
|
364
|
+
etaNorm(prefix.envir, binders, headNorm(prefix.envir, uarg)),
|
|
365
|
+
prefix.envir,
|
|
366
|
+
prefix.dpairs,
|
|
367
|
+
),
|
|
368
|
+
);
|
|
369
|
+
const copyargs = (
|
|
370
|
+
uargs: readonly Term[],
|
|
371
|
+
): Seq<{ args: Term[]; envir: Envir; dpairs: readonly Dpair[] }> =>
|
|
372
|
+
uargs.length === 0
|
|
373
|
+
? consSeq({ args: [], envir, dpairs }, emptySeq)
|
|
374
|
+
: mapsSeq((prefix) => copycons(uargs[0], prefix), copyargs(uargs.slice(1)));
|
|
375
|
+
const [uhead, uargs] = stripComb(target);
|
|
376
|
+
const base = envBodyType(envir, fastypeIn(envir, binders, uhead));
|
|
377
|
+
const types = targs.map((targ) => fastypeIn(envir, binders, targ));
|
|
378
|
+
const projenv = (
|
|
379
|
+
head: Term,
|
|
380
|
+
argTypes: Typ[],
|
|
381
|
+
bodyType: Typ,
|
|
382
|
+
targ: Term,
|
|
383
|
+
tail: Seq<Copy>,
|
|
384
|
+
): Seq<Copy> => {
|
|
385
|
+
const unified = unifyTypesEnvir(base, bodyType, envir);
|
|
386
|
+
if (unified === undefined) return tail;
|
|
387
|
+
return deferSeq(() => {
|
|
388
|
+
try {
|
|
389
|
+
const [withArgs, args] = makeArgs(name, types, unified, argTypes);
|
|
390
|
+
const plugin = (arg: Term) => listComb(headOf(arg), targs);
|
|
391
|
+
const dpair = { binders, left: listComb(targ, args.map(plugin)), right: target };
|
|
392
|
+
const simplified = simpl(withArgs, [dpair, ...dpairs]);
|
|
393
|
+
return [
|
|
394
|
+
{
|
|
395
|
+
term: listComb(head, args),
|
|
396
|
+
envir: simplified.envir,
|
|
397
|
+
dpairs: [...simplified.flexrigid, ...simplified.flexflex],
|
|
398
|
+
},
|
|
399
|
+
tail,
|
|
400
|
+
];
|
|
401
|
+
} catch (error) {
|
|
402
|
+
if (error instanceof CantUnify) return tail;
|
|
403
|
+
throw error;
|
|
404
|
+
}
|
|
405
|
+
});
|
|
406
|
+
};
|
|
407
|
+
const joinargs = (result: { args: Term[]; envir: Envir; dpairs: readonly Dpair[] }): Copy => ({
|
|
408
|
+
term: listComb(uhead, result.args),
|
|
409
|
+
envir: result.envir,
|
|
410
|
+
dpairs: result.dpairs,
|
|
411
|
+
});
|
|
412
|
+
const matchfun = (projections: readonly [Term, Typ, Term][]): Seq<Copy> => {
|
|
413
|
+
if (projections.length > 0) {
|
|
414
|
+
const [bvar, type, targ] = projections[0];
|
|
415
|
+
const [argTypes, bodyType] = stripType(envir, type);
|
|
416
|
+
return projenv(bvar, argTypes, bodyType, targ, matchfun(projections.slice(1)));
|
|
417
|
+
}
|
|
418
|
+
return uhead.kind === "Const" || uhead.kind === "Free"
|
|
419
|
+
? mapSeq(joinargs, copyargs(uargs))
|
|
420
|
+
: emptySeq;
|
|
421
|
+
};
|
|
422
|
+
if (uhead.kind === "Abs")
|
|
423
|
+
return mapSeq(
|
|
424
|
+
(result: Copy) => ({ ...result, term: mkAbs(uhead.name, uhead.type, result.term) }),
|
|
425
|
+
copy(
|
|
426
|
+
[{ name: uhead.name, type: uhead.type }, ...binders],
|
|
427
|
+
[...targs.map((targ) => incrBoundvars(1, targ)), mkBound(0)],
|
|
428
|
+
uhead.body,
|
|
429
|
+
envir,
|
|
430
|
+
dpairs,
|
|
431
|
+
),
|
|
432
|
+
);
|
|
433
|
+
if (uhead.kind === "Var") {
|
|
434
|
+
const [updated, head] = genvar(uhead.name, envir, funTs(types, base));
|
|
435
|
+
return singleSeq({
|
|
436
|
+
term: combound(head, 0, types.length),
|
|
437
|
+
envir: updated,
|
|
438
|
+
dpairs: [{ binders, left: listComb(head, targs), right: target }, ...dpairs],
|
|
439
|
+
});
|
|
440
|
+
}
|
|
441
|
+
const projections = types.map((type, index): [Term, Typ, Term] => [
|
|
442
|
+
mkBound(types.length - 1 - index),
|
|
443
|
+
type,
|
|
444
|
+
targs[index],
|
|
445
|
+
]);
|
|
446
|
+
return matchfun(projections.reverse());
|
|
447
|
+
};
|
|
448
|
+
return copy;
|
|
449
|
+
};
|
|
450
|
+
|
|
451
|
+
const match = (
|
|
452
|
+
envir: Envir,
|
|
453
|
+
dpair: Dpair,
|
|
454
|
+
dpairs: readonly Dpair[],
|
|
455
|
+
): Seq<[Envir, readonly Dpair[]]> => {
|
|
456
|
+
const [head, targs] = stripComb(dpair.left);
|
|
457
|
+
if (head.kind !== "Var") throw new TlaIsabelleError("TERM", "MATCH");
|
|
458
|
+
const types = envBinderTypes(envir, head.type);
|
|
459
|
+
return mapSeq(
|
|
460
|
+
(result: Copy): [Envir, readonly Dpair[]] => {
|
|
461
|
+
const assigned = lookup(result.envir, head);
|
|
462
|
+
return assigned === undefined
|
|
463
|
+
? [update(head, typesAbs(types, result.term), result.envir), result.dpairs]
|
|
464
|
+
: [
|
|
465
|
+
result.envir,
|
|
466
|
+
[
|
|
467
|
+
{ binders: [], left: assigned, right: typesAbs(types, result.term) },
|
|
468
|
+
...result.dpairs,
|
|
469
|
+
],
|
|
470
|
+
];
|
|
471
|
+
},
|
|
472
|
+
matchcopy(head.name)(dpair.binders, targs, dpair.right, envir, dpairs),
|
|
473
|
+
);
|
|
474
|
+
};
|
|
475
|
+
|
|
476
|
+
// ff_assign: undefined where Isabelle raises ASSIGN.
|
|
477
|
+
const ffAssign = (
|
|
478
|
+
envir: Envir,
|
|
479
|
+
binders: readonly Binder[],
|
|
480
|
+
left: Term,
|
|
481
|
+
right: Term,
|
|
482
|
+
): Envir | undefined => {
|
|
483
|
+
const variable = getEtaVar(binders, 0, left);
|
|
484
|
+
if (variable === undefined) return undefined;
|
|
485
|
+
if (occursTerms([], envir, variable, [right])) return undefined;
|
|
486
|
+
const unified = unifyTypes(
|
|
487
|
+
envBodyType(envir, variable.type),
|
|
488
|
+
fastypeIn(envir, binders, right),
|
|
489
|
+
envir,
|
|
490
|
+
);
|
|
491
|
+
return vupdate(variable, rlistAbs(binders, right), unified);
|
|
492
|
+
};
|
|
493
|
+
|
|
494
|
+
interface Flarg {
|
|
495
|
+
readonly index: number;
|
|
496
|
+
readonly term: Term;
|
|
497
|
+
readonly type: Typ;
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
const rigidBound = (level: number, banned: readonly number[], term: Term): boolean => {
|
|
501
|
+
const [head, args] = stripComb(term);
|
|
502
|
+
if (head.kind === "Bound")
|
|
503
|
+
return (
|
|
504
|
+
banned.includes(head.index - level) || args.some((arg) => rigidBound(level, banned, arg))
|
|
505
|
+
);
|
|
506
|
+
if (head.kind === "Var") return false;
|
|
507
|
+
if (head.kind === "Abs")
|
|
508
|
+
return (
|
|
509
|
+
rigidBound(level + 1, banned, head.body) || args.some((arg) => rigidBound(level, banned, arg))
|
|
510
|
+
);
|
|
511
|
+
return args.some((arg) => rigidBound(level, banned, arg));
|
|
512
|
+
};
|
|
513
|
+
|
|
514
|
+
const changeBnos = (banned: readonly number[], term: Term) => {
|
|
515
|
+
const change = (level: number, current: Term): Term => {
|
|
516
|
+
if (current.kind === "Bound") {
|
|
517
|
+
if (current.index < level) return current;
|
|
518
|
+
if (banned.includes(current.index - level)) throw new ChangeFail();
|
|
519
|
+
return mkBound(
|
|
520
|
+
current.index - banned.filter((index) => index < current.index - level).length,
|
|
521
|
+
);
|
|
522
|
+
}
|
|
523
|
+
if (current.kind === "Abs")
|
|
524
|
+
return mkAbs(current.name, current.type, change(level + 1, current.body));
|
|
525
|
+
if (current.kind === "App")
|
|
526
|
+
return mkApp(change(level, current.fun), change(level, current.arg));
|
|
527
|
+
return current;
|
|
528
|
+
};
|
|
529
|
+
return change(0, term);
|
|
530
|
+
};
|
|
531
|
+
|
|
532
|
+
const sortArgs = (args: readonly Flarg[]): Flarg[] => {
|
|
533
|
+
const lessArg = (left: Flarg, right: Flarg) =>
|
|
534
|
+
left.term.kind === "Bound" && right.term.kind === "Bound" && right.term.index < left.term.index;
|
|
535
|
+
const insert = (item: Flarg, sorted: readonly Flarg[]): Flarg[] => {
|
|
536
|
+
if (sorted.length === 0) return [item];
|
|
537
|
+
return lessArg(sorted[0], item)
|
|
538
|
+
? [sorted[0], ...insert(item, sorted.slice(1))]
|
|
539
|
+
: [item, ...sorted];
|
|
540
|
+
};
|
|
541
|
+
return args.length === 0 ? [] : insert(args[0], sortArgs(args.slice(1)));
|
|
542
|
+
};
|
|
543
|
+
|
|
544
|
+
const isDecreasing = (count: number, args: readonly Flarg[]): boolean =>
|
|
545
|
+
args.length === 0
|
|
546
|
+
? count === 0
|
|
547
|
+
: args[0].index === count - 1 && isDecreasing(count - 1, args.slice(1));
|
|
548
|
+
|
|
549
|
+
const cleanTerm = (banned: readonly number[], envir: Envir, term: Term): [Envir, Term] => {
|
|
550
|
+
const [head, terms] = stripComb(term);
|
|
551
|
+
if (head.kind !== "Var") throw new TlaIsabelleError("TERM", "clean_term");
|
|
552
|
+
const [types, bodyType] = stripType(envir, head.type);
|
|
553
|
+
if (terms.length !== types.length) throw new ChangeFail();
|
|
554
|
+
const flexargs = terms.map((arg, position): Flarg => ({
|
|
555
|
+
index: terms.length - 1 - position,
|
|
556
|
+
term: arg,
|
|
557
|
+
type: types[position],
|
|
558
|
+
}));
|
|
559
|
+
const changed = flexargs.reduceRight<Flarg[]>(
|
|
560
|
+
(result, arg) =>
|
|
561
|
+
rigidBound(0, banned, arg.term)
|
|
562
|
+
? result
|
|
563
|
+
: [{ ...arg, term: changeBnos(banned, arg.term) }, ...result],
|
|
564
|
+
[],
|
|
565
|
+
);
|
|
566
|
+
const args = sortArgs(changed);
|
|
567
|
+
if (isDecreasing(types.length, args))
|
|
568
|
+
return [
|
|
569
|
+
envir,
|
|
570
|
+
listComb(
|
|
571
|
+
head,
|
|
572
|
+
args.map((arg) => arg.term),
|
|
573
|
+
),
|
|
574
|
+
];
|
|
575
|
+
const [withVar, fresh] = genvar(
|
|
576
|
+
head.name,
|
|
577
|
+
envir,
|
|
578
|
+
funTs(
|
|
579
|
+
args.map((arg) => arg.type),
|
|
580
|
+
bodyType,
|
|
581
|
+
),
|
|
582
|
+
);
|
|
583
|
+
const body = listComb(
|
|
584
|
+
fresh,
|
|
585
|
+
args.map((arg) => mkBound(arg.index)),
|
|
586
|
+
);
|
|
587
|
+
const updated = vupdate(head, typesAbs(types, body), withVar);
|
|
588
|
+
return [
|
|
589
|
+
updated,
|
|
590
|
+
normTerm(
|
|
591
|
+
updated,
|
|
592
|
+
listComb(
|
|
593
|
+
fresh,
|
|
594
|
+
args.map((arg) => arg.term),
|
|
595
|
+
),
|
|
596
|
+
),
|
|
597
|
+
];
|
|
598
|
+
};
|
|
599
|
+
|
|
600
|
+
const addTpair = (
|
|
601
|
+
binders: readonly Binder[],
|
|
602
|
+
left: Term,
|
|
603
|
+
right: Term,
|
|
604
|
+
tpairs: readonly Tpair[],
|
|
605
|
+
): Tpair[] => {
|
|
606
|
+
if (aconv(left, right)) return [...tpairs];
|
|
607
|
+
const leftAbs = rlistAbs(binders, left);
|
|
608
|
+
const rightAbs = rlistAbs(binders, right);
|
|
609
|
+
return tpairs.some((pair) => aconv(leftAbs, pair[0]) && aconv(rightAbs, pair[1]))
|
|
610
|
+
? [...tpairs]
|
|
611
|
+
: [[leftAbs, rightAbs], ...tpairs];
|
|
612
|
+
};
|
|
613
|
+
|
|
614
|
+
const cleanFfpair = (dpair: Dpair, envir: Envir, tpairs: readonly Tpair[]): [Envir, Tpair[]] => {
|
|
615
|
+
try {
|
|
616
|
+
const leftLoose = looseBnos(dpair.left);
|
|
617
|
+
const rightLoose = looseBnos(dpair.right);
|
|
618
|
+
const banned: number[] = [];
|
|
619
|
+
const kept: Binder[] = [];
|
|
620
|
+
for (let index = dpair.binders.length - 1; index >= 0; index -= 1) {
|
|
621
|
+
if (leftLoose.includes(index) && rightLoose.includes(index))
|
|
622
|
+
kept.unshift(dpair.binders[index]);
|
|
623
|
+
else banned.unshift(index);
|
|
624
|
+
}
|
|
625
|
+
const [leftEnvir, left] = cleanTerm(banned, envir, dpair.left);
|
|
626
|
+
const [rightEnvir, right] = cleanTerm(banned, leftEnvir, dpair.right);
|
|
627
|
+
const assigned =
|
|
628
|
+
ffAssign(rightEnvir, kept, left, right) ?? ffAssign(rightEnvir, kept, right, left);
|
|
629
|
+
return assigned === undefined
|
|
630
|
+
? [rightEnvir, addTpair(kept, left, right, tpairs)]
|
|
631
|
+
: [assigned, [...tpairs]];
|
|
632
|
+
} catch (error) {
|
|
633
|
+
if (error instanceof ChangeFail)
|
|
634
|
+
return [envir, addTpair(dpair.binders, dpair.left, dpair.right, tpairs)];
|
|
635
|
+
throw error;
|
|
636
|
+
}
|
|
637
|
+
};
|
|
638
|
+
|
|
639
|
+
const addFfpair = (dpair: Dpair, envir: Envir, tpairs: readonly Tpair[]): [Envir, Tpair[]] => {
|
|
640
|
+
const left = normTerm(envir, dpair.left);
|
|
641
|
+
const right = normTerm(envir, dpair.right);
|
|
642
|
+
const leftHead = headOf(left);
|
|
643
|
+
const rightHead = headOf(right);
|
|
644
|
+
if (leftHead.kind !== "Var" || rightHead.kind !== "Var")
|
|
645
|
+
throw new TlaIsabelleError("TERM", "add_ffpair: Vars expected");
|
|
646
|
+
if (sameIndexname(leftHead, rightHead)) {
|
|
647
|
+
if (!eqTyp(leftHead.type, rightHead.type))
|
|
648
|
+
throw new TlaIsabelleError("TERM", "add_ffpair: Var name confusion");
|
|
649
|
+
return [envir, addTpair(dpair.binders, left, right, tpairs)];
|
|
650
|
+
}
|
|
651
|
+
return indexnameOrd(leftHead, rightHead) < 0
|
|
652
|
+
? cleanFfpair({ binders: dpair.binders, left: right, right: left }, envir, tpairs)
|
|
653
|
+
: cleanFfpair({ binders: dpair.binders, left, right }, envir, tpairs);
|
|
654
|
+
};
|
|
655
|
+
|
|
656
|
+
export interface Unifier {
|
|
657
|
+
readonly envir: Envir;
|
|
658
|
+
readonly tpairs: readonly Tpair[];
|
|
659
|
+
}
|
|
660
|
+
|
|
661
|
+
const hounifiers = (
|
|
662
|
+
limits: Limits | undefined,
|
|
663
|
+
binders: readonly Binder[],
|
|
664
|
+
envir: Envir,
|
|
665
|
+
pairs: readonly Tpair[],
|
|
666
|
+
): Seq<Unifier> => {
|
|
667
|
+
const addUnify = (
|
|
668
|
+
depth: number,
|
|
669
|
+
envirIn: Envir,
|
|
670
|
+
dpairs: readonly Dpair[],
|
|
671
|
+
rest: Seq<Unifier>,
|
|
672
|
+
): Seq<Unifier> =>
|
|
673
|
+
// Isabelle pulls the alternatives inside its handler for CANTUNIFY, but each alternative
|
|
674
|
+
// handles its own, so handing them over to the caller's loop changes nothing.
|
|
675
|
+
deferSeq(() => {
|
|
676
|
+
if (limits !== undefined) checkInterrupt(limits);
|
|
677
|
+
try {
|
|
678
|
+
const simplified = simpl(envirIn, dpairs);
|
|
679
|
+
if (simplified.flexrigid.length === 0) {
|
|
680
|
+
const result = simplified.flexflex.reduceRight<[Envir, Tpair[]]>(
|
|
681
|
+
(state, dpair) => addFfpair(dpair, state[0], state[1]),
|
|
682
|
+
[simplified.envir, []],
|
|
683
|
+
);
|
|
684
|
+
return [{ envir: result[0], tpairs: result[1] }, rest];
|
|
685
|
+
}
|
|
686
|
+
if (depth > SEARCH_BOUND) return rest;
|
|
687
|
+
const [first, ...others] = simplified.flexrigid;
|
|
688
|
+
return itRightSeq(
|
|
689
|
+
(item: [Envir, readonly Dpair[]], tail: Seq<Unifier>) =>
|
|
690
|
+
addUnify(depth + 1, item[0], item[1], tail),
|
|
691
|
+
match(simplified.envir, first, [...others, ...simplified.flexflex]),
|
|
692
|
+
rest,
|
|
693
|
+
);
|
|
694
|
+
} catch (error) {
|
|
695
|
+
if (error instanceof CantUnify) return rest;
|
|
696
|
+
throw error;
|
|
697
|
+
}
|
|
698
|
+
});
|
|
699
|
+
return addUnify(
|
|
700
|
+
1,
|
|
701
|
+
envir,
|
|
702
|
+
pairs.map((pair) => ({ binders, left: pair[0], right: pair[1] })),
|
|
703
|
+
emptySeq,
|
|
704
|
+
);
|
|
705
|
+
};
|
|
706
|
+
|
|
707
|
+
// Unify.unifiers: pattern unification first, Huet's procedure outside the pattern fragment.
|
|
708
|
+
export const unifiers = (
|
|
709
|
+
limits: Limits | undefined,
|
|
710
|
+
envir: Envir,
|
|
711
|
+
pairs: readonly Tpair[],
|
|
712
|
+
): Seq<Unifier> => {
|
|
713
|
+
let current = envir;
|
|
714
|
+
for (const pair of pairs) {
|
|
715
|
+
const result = unifyPattern(pair[0], pair[1], current);
|
|
716
|
+
if (result.kind === "clash") return emptySeq;
|
|
717
|
+
if (result.kind === "not a pattern") return hounifiers(limits, [], envir, pairs);
|
|
718
|
+
current = result.envir;
|
|
719
|
+
}
|
|
720
|
+
return singleSeq({ envir: current, tpairs: [] });
|
|
721
|
+
};
|
|
722
|
+
|
|
723
|
+
const varHeadOf = (envir: Envir, term: Term): Var => {
|
|
724
|
+
const head = headOf(stripAbsBody(normTerm(envir, term)));
|
|
725
|
+
if (head.kind !== "Var") throw new TlaIsabelleError("ERROR", "CANTUNIFY");
|
|
726
|
+
return head;
|
|
727
|
+
};
|
|
728
|
+
|
|
729
|
+
const typeAbs = (envir: Envir, type: Typ, term: Term) =>
|
|
730
|
+
typesAbs(envBinderTypes(envir, type), term);
|
|
731
|
+
|
|
732
|
+
const smashFlexflex1 = (pair: Tpair, envir: Envir): Envir => {
|
|
733
|
+
const left = varHeadOf(envir, pair[0]);
|
|
734
|
+
const right = varHeadOf(envir, pair[1]);
|
|
735
|
+
const [withVar, fresh] = genvar(left.name, envir, envBodyType(envir, left.type));
|
|
736
|
+
const updated = vupdate(right, typeAbs(withVar, right.type, fresh), withVar);
|
|
737
|
+
return sameIndexname(left, right) && eqTyp(left.type, right.type)
|
|
738
|
+
? updated
|
|
739
|
+
: vupdate(left, typeAbs(withVar, left.type, fresh), updated);
|
|
740
|
+
};
|
|
741
|
+
|
|
742
|
+
// Unify.smash_unifiers: unifiers with no remaining flex-flex pairs. A pair whose side is not
|
|
743
|
+
// flexible stops the sequence, as CANTUNIFY escapes Seq.map in Isabelle.
|
|
744
|
+
export const smashUnifiers = (
|
|
745
|
+
limits: Limits | undefined,
|
|
746
|
+
pairs: readonly Tpair[],
|
|
747
|
+
envir: Envir,
|
|
748
|
+
): Seq<Envir> =>
|
|
749
|
+
mapSeq(
|
|
750
|
+
(unifier: Unifier) =>
|
|
751
|
+
unifier.tpairs.reduceRight((state, pair) => smashFlexflex1(pair, state), unifier.envir),
|
|
752
|
+
unifiers(limits, envir, pairs),
|
|
753
|
+
);
|