tla-ts 0.0.4-dev.66582d4 → 0.0.4-dev.702eb98
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 +26 -141
- 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 +515 -0
- package/dist/prove.js +515 -0
- package/dist/run-cli.cjs +30 -47
- package/dist/run-cli.js +30 -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 +280 -80
- package/src/index.ts +10 -0
- package/src/{obligation-action.ts → obligations/action.ts} +258 -37
- package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
- package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
- package/src/{obligations.ts → obligations/index.ts} +26 -12
- package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
- package/src/{obligation-module.ts → obligations/module.ts} +46 -20
- package/src/obligations/pickle.ts +100 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +91 -35
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- 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 +27 -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 +477 -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 +520 -0
- package/src/prove/prep/defs.ts +27 -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 +552 -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 +29 -0
- package/src/prove/prove.ts +417 -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 +210 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +665 -0
- package/src/prove/smt/encode.ts +169 -0
- package/src/prove/smt/extensionality.ts +63 -0
- package/src/prove/smt/flatten.ts +127 -0
- package/src/prove/smt/format.ts +143 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +784 -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 +97 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +13 -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 +444 -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 +78 -35
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +25 -6
- 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
- /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
|
@@ -0,0 +1,806 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/thm.ML, the inference kernel. Copyright (c) 1986-2025
|
|
2
|
+
// University of Cambridge, Technische Universitaet Muenchen, and contributors, see LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// Every TLA+ type variable has the empty sort, so the kernel drops the sort hypotheses and
|
|
5
|
+
// constraints. Proof terms and certificates are not recorded either.
|
|
6
|
+
|
|
7
|
+
import { TlaIsabelleError } from "../../../errors";
|
|
8
|
+
import {
|
|
9
|
+
betaNorm,
|
|
10
|
+
emptyEnvir,
|
|
11
|
+
etaContract,
|
|
12
|
+
isEmptyEnvir,
|
|
13
|
+
above,
|
|
14
|
+
normTerm,
|
|
15
|
+
type Envir,
|
|
16
|
+
} from "./envir";
|
|
17
|
+
import {
|
|
18
|
+
allConst,
|
|
19
|
+
assumProblems,
|
|
20
|
+
countPrems,
|
|
21
|
+
flattenParams,
|
|
22
|
+
incrIndexes,
|
|
23
|
+
liftAbs,
|
|
24
|
+
liftAll,
|
|
25
|
+
listAll,
|
|
26
|
+
listImplies,
|
|
27
|
+
mkEquals,
|
|
28
|
+
mkImplies,
|
|
29
|
+
occs,
|
|
30
|
+
stripImpConcl,
|
|
31
|
+
stripImpPrems,
|
|
32
|
+
stripPrems,
|
|
33
|
+
stripAssumsConcl,
|
|
34
|
+
stripAssumsHyp,
|
|
35
|
+
} from "./logic";
|
|
36
|
+
import {
|
|
37
|
+
emptySeq,
|
|
38
|
+
flatSeq,
|
|
39
|
+
itRightSeq,
|
|
40
|
+
deferSeq,
|
|
41
|
+
makeSeq,
|
|
42
|
+
mappSeq,
|
|
43
|
+
chopSeq,
|
|
44
|
+
consSeq,
|
|
45
|
+
mapSeq,
|
|
46
|
+
type Seq,
|
|
47
|
+
} from "./seq";
|
|
48
|
+
import { substType, type TyEnv } from "./type";
|
|
49
|
+
import {
|
|
50
|
+
abstractOver,
|
|
51
|
+
aconv,
|
|
52
|
+
betapply,
|
|
53
|
+
couldUnify,
|
|
54
|
+
eqTyp,
|
|
55
|
+
existsSubterm,
|
|
56
|
+
fastypeOf,
|
|
57
|
+
maxidxOfTerm,
|
|
58
|
+
mkAbs,
|
|
59
|
+
mkApp,
|
|
60
|
+
mkConst,
|
|
61
|
+
mkFree,
|
|
62
|
+
mkVar,
|
|
63
|
+
propT,
|
|
64
|
+
stripAllBody,
|
|
65
|
+
stripAllVars,
|
|
66
|
+
substBound,
|
|
67
|
+
type Term,
|
|
68
|
+
type Var,
|
|
69
|
+
} from "./term";
|
|
70
|
+
import type { Limits } from "./interrupt";
|
|
71
|
+
import { smashUnifiers, unifiers, type Tpair } from "./unify";
|
|
72
|
+
import { normTermSkip, renameBvars, stripApply, stripAssums2, unifyVarTypes } from "./bicompose";
|
|
73
|
+
|
|
74
|
+
declare const kernel: unique symbol;
|
|
75
|
+
|
|
76
|
+
// A theorem. Only this module builds one, so every Thm follows from the axioms by the rules here.
|
|
77
|
+
export interface Thm {
|
|
78
|
+
readonly maxidx: number;
|
|
79
|
+
readonly hyps: readonly Term[];
|
|
80
|
+
readonly tpairs: readonly Tpair[];
|
|
81
|
+
readonly prop: Term;
|
|
82
|
+
readonly [kernel]: true;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const makeThm = (
|
|
86
|
+
maxidx: number,
|
|
87
|
+
hyps: readonly Term[],
|
|
88
|
+
tpairs: readonly Tpair[],
|
|
89
|
+
prop: Term,
|
|
90
|
+
): Thm => ({ maxidx, hyps, tpairs, prop }) as Thm;
|
|
91
|
+
|
|
92
|
+
const unionHyps = (left: readonly Term[], right: readonly Term[]) =>
|
|
93
|
+
right.length === 0
|
|
94
|
+
? left
|
|
95
|
+
: left.length === 0
|
|
96
|
+
? right
|
|
97
|
+
: [...left, ...right.filter((hyp) => !left.some((other) => aconv(hyp, other)))];
|
|
98
|
+
|
|
99
|
+
const unionTpairs = (left: readonly Tpair[], right: readonly Tpair[]) =>
|
|
100
|
+
right.length === 0
|
|
101
|
+
? left
|
|
102
|
+
: [
|
|
103
|
+
...left,
|
|
104
|
+
...right.filter(
|
|
105
|
+
(pair) => !left.some((other) => aconv(pair[0], other[0]) && aconv(pair[1], other[1])),
|
|
106
|
+
),
|
|
107
|
+
];
|
|
108
|
+
|
|
109
|
+
const maxidxTpairs = (tpairs: readonly Tpair[], maxidx: number) =>
|
|
110
|
+
tpairs.reduce((result, pair) => maxidxOfTerm(pair[1], maxidxOfTerm(pair[0], result)), maxidx);
|
|
111
|
+
|
|
112
|
+
// An axiom or a theorem that the reference theories prove, taken on trust.
|
|
113
|
+
export const axiomThm = (prop: Term): Thm => makeThm(maxidxOfTerm(prop), [], [], prop);
|
|
114
|
+
|
|
115
|
+
export const nprems = (thm: Thm) => countPrems(thm.prop);
|
|
116
|
+
export const premsOf = (thm: Thm) => stripImpPrems(thm.prop);
|
|
117
|
+
export const conclOf = (thm: Thm) => stripImpConcl(thm.prop);
|
|
118
|
+
|
|
119
|
+
export const majorPremOf = (thm: Thm) => {
|
|
120
|
+
const premise = premsOf(thm)[0];
|
|
121
|
+
if (premise === undefined)
|
|
122
|
+
throw new TlaIsabelleError("THM", "major_prem_of: rule with no premises");
|
|
123
|
+
return stripAssumsConcl(premise);
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
export const premOf = (thm: Thm, index: number) => {
|
|
127
|
+
const premise = premsOf(thm)[index - 1];
|
|
128
|
+
if (premise === undefined) throw new TlaIsabelleError("THM", `No subgoal ${index}`);
|
|
129
|
+
return premise;
|
|
130
|
+
};
|
|
131
|
+
|
|
132
|
+
export const assume = (prop: Term): Thm => {
|
|
133
|
+
if (!eqTyp(fastypeOf(prop), propT)) throw new TlaIsabelleError("THM", "assume: prop");
|
|
134
|
+
if (maxidxOfTerm(prop) !== -1) throw new TlaIsabelleError("THM", "assume: variables");
|
|
135
|
+
return makeThm(-1, [prop], [], prop);
|
|
136
|
+
};
|
|
137
|
+
|
|
138
|
+
export const impliesIntr = (premise: Term, thm: Thm): Thm => {
|
|
139
|
+
if (!eqTyp(fastypeOf(premise), propT))
|
|
140
|
+
throw new TlaIsabelleError("THM", "implies_intr: assumptions must have type prop");
|
|
141
|
+
return makeThm(
|
|
142
|
+
Math.max(maxidxOfTerm(premise), thm.maxidx),
|
|
143
|
+
thm.hyps.filter((hyp) => !aconv(hyp, premise)),
|
|
144
|
+
thm.tpairs,
|
|
145
|
+
mkImplies(premise, thm.prop),
|
|
146
|
+
);
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
export const impliesElim = (major: Thm, minor: Thm): Thm => {
|
|
150
|
+
const prop = major.prop;
|
|
151
|
+
if (
|
|
152
|
+
prop.kind !== "App" ||
|
|
153
|
+
prop.fun.kind !== "App" ||
|
|
154
|
+
prop.fun.fun.kind !== "Const" ||
|
|
155
|
+
prop.fun.fun.name !== "Pure.imp" ||
|
|
156
|
+
!aconv(prop.fun.arg, minor.prop)
|
|
157
|
+
)
|
|
158
|
+
throw new TlaIsabelleError("THM", "implies_elim: major premise");
|
|
159
|
+
return makeThm(
|
|
160
|
+
Math.max(major.maxidx, minor.maxidx),
|
|
161
|
+
unionHyps(minor.hyps, major.hyps),
|
|
162
|
+
unionTpairs(minor.tpairs, major.tpairs),
|
|
163
|
+
prop.arg,
|
|
164
|
+
);
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
const occursIn = (variable: Term, terms: readonly Term[], tpairs: readonly Tpair[]) => {
|
|
168
|
+
const occurs = (term: Term) => occs(variable, term);
|
|
169
|
+
return terms.some(occurs) || tpairs.some((pair) => occurs(pair[0]) || occurs(pair[1]));
|
|
170
|
+
};
|
|
171
|
+
|
|
172
|
+
export const forallIntr = (variable: Term, thm: Thm): Thm => {
|
|
173
|
+
if (variable.kind !== "Free" && variable.kind !== "Var")
|
|
174
|
+
throw new TlaIsabelleError("THM", "forall_intr: not a variable");
|
|
175
|
+
if (occursIn(variable, variable.kind === "Free" ? thm.hyps : [], thm.tpairs))
|
|
176
|
+
throw new TlaIsabelleError(
|
|
177
|
+
"THM",
|
|
178
|
+
`forall_intr: variable "${variable.name}" free in assumptions`,
|
|
179
|
+
);
|
|
180
|
+
return makeThm(
|
|
181
|
+
Math.max(maxidxOfTerm(variable), thm.maxidx),
|
|
182
|
+
thm.hyps,
|
|
183
|
+
thm.tpairs,
|
|
184
|
+
mkApp(
|
|
185
|
+
allConst(variable.type),
|
|
186
|
+
mkAbs(variable.name, variable.type, abstractOver(variable, thm.prop)),
|
|
187
|
+
),
|
|
188
|
+
);
|
|
189
|
+
};
|
|
190
|
+
|
|
191
|
+
export const forallElim = (term: Term, thm: Thm): Thm => {
|
|
192
|
+
const prop = thm.prop;
|
|
193
|
+
if (
|
|
194
|
+
prop.kind !== "App" ||
|
|
195
|
+
prop.fun.kind !== "Const" ||
|
|
196
|
+
prop.fun.name !== "Pure.all" ||
|
|
197
|
+
prop.fun.type.kind !== "Type" ||
|
|
198
|
+
prop.fun.type.args[0].kind !== "Type"
|
|
199
|
+
)
|
|
200
|
+
throw new TlaIsabelleError("THM", "forall_elim: not quantified");
|
|
201
|
+
if (!eqTyp(fastypeOf(term), prop.fun.type.args[0].args[0]))
|
|
202
|
+
throw new TlaIsabelleError("THM", "forall_elim: type mismatch");
|
|
203
|
+
return makeThm(
|
|
204
|
+
Math.max(maxidxOfTerm(term), thm.maxidx),
|
|
205
|
+
thm.hyps,
|
|
206
|
+
thm.tpairs,
|
|
207
|
+
betapply(prop.arg, term),
|
|
208
|
+
);
|
|
209
|
+
};
|
|
210
|
+
|
|
211
|
+
export const reflexive = (term: Term) => makeThm(maxidxOfTerm(term), [], [], mkEquals(term, term));
|
|
212
|
+
|
|
213
|
+
const destEq = (thm: Thm): [Term, Term, Term] | undefined => {
|
|
214
|
+
const prop = thm.prop;
|
|
215
|
+
return prop.kind === "App" &&
|
|
216
|
+
prop.fun.kind === "App" &&
|
|
217
|
+
prop.fun.fun.kind === "Const" &&
|
|
218
|
+
prop.fun.fun.name === "Pure.eq"
|
|
219
|
+
? [prop.fun.fun, prop.fun.arg, prop.arg]
|
|
220
|
+
: undefined;
|
|
221
|
+
};
|
|
222
|
+
|
|
223
|
+
export const symmetric = (thm: Thm): Thm => {
|
|
224
|
+
const parts = destEq(thm);
|
|
225
|
+
if (parts === undefined) throw new TlaIsabelleError("THM", "symmetric");
|
|
226
|
+
return makeThm(thm.maxidx, thm.hyps, thm.tpairs, mkApp(mkApp(parts[0], parts[2]), parts[1]));
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
export const transitive = (first: Thm, second: Thm): Thm => {
|
|
230
|
+
const left = destEq(first);
|
|
231
|
+
const right = destEq(second);
|
|
232
|
+
if (left === undefined || right === undefined)
|
|
233
|
+
throw new TlaIsabelleError("THM", "transitive: premises");
|
|
234
|
+
if (!aconv(left[2], right[1])) throw new TlaIsabelleError("THM", "transitive: middle term");
|
|
235
|
+
return makeThm(
|
|
236
|
+
Math.max(first.maxidx, second.maxidx),
|
|
237
|
+
unionHyps(first.hyps, second.hyps),
|
|
238
|
+
unionTpairs(first.tpairs, second.tpairs),
|
|
239
|
+
mkApp(mkApp(left[0], left[1]), right[2]),
|
|
240
|
+
);
|
|
241
|
+
};
|
|
242
|
+
|
|
243
|
+
export const betaConversion = (full: boolean, term: Term): Thm => {
|
|
244
|
+
if (!full && (term.kind !== "App" || term.fun.kind !== "Abs"))
|
|
245
|
+
throw new TlaIsabelleError("THM", "beta_conversion: not a redex");
|
|
246
|
+
const reduced =
|
|
247
|
+
full || term.kind !== "App" || term.fun.kind !== "Abs"
|
|
248
|
+
? betaNorm(term)
|
|
249
|
+
: substBound(term.arg, term.fun.body);
|
|
250
|
+
return makeThm(maxidxOfTerm(term), [], [], mkEquals(term, reduced));
|
|
251
|
+
};
|
|
252
|
+
|
|
253
|
+
export const etaConversion = (term: Term) =>
|
|
254
|
+
makeThm(maxidxOfTerm(term), [], [], mkEquals(term, etaContract(term)));
|
|
255
|
+
|
|
256
|
+
export const abstractRule = (name: string, variable: Term, thm: Thm): Thm => {
|
|
257
|
+
const parts = destEq(thm);
|
|
258
|
+
if (parts === undefined)
|
|
259
|
+
throw new TlaIsabelleError("THM", "abstract_rule: premise not an equality");
|
|
260
|
+
if (variable.kind !== "Free" && variable.kind !== "Var")
|
|
261
|
+
throw new TlaIsabelleError("THM", "abstract_rule: not a variable");
|
|
262
|
+
if (occursIn(variable, variable.kind === "Free" ? thm.hyps : [], thm.tpairs))
|
|
263
|
+
throw new TlaIsabelleError(
|
|
264
|
+
"THM",
|
|
265
|
+
`abstract_rule: variable "${variable.name}" free in assumptions`,
|
|
266
|
+
);
|
|
267
|
+
return makeThm(
|
|
268
|
+
thm.maxidx,
|
|
269
|
+
thm.hyps,
|
|
270
|
+
thm.tpairs,
|
|
271
|
+
mkEquals(
|
|
272
|
+
mkAbs(name, variable.type, abstractOver(variable, parts[1])),
|
|
273
|
+
mkAbs(name, variable.type, abstractOver(variable, parts[2])),
|
|
274
|
+
),
|
|
275
|
+
);
|
|
276
|
+
};
|
|
277
|
+
|
|
278
|
+
export const combination = (first: Thm, second: Thm): Thm => {
|
|
279
|
+
const left = destEq(first);
|
|
280
|
+
const right = destEq(second);
|
|
281
|
+
if (left === undefined || right === undefined)
|
|
282
|
+
throw new TlaIsabelleError("THM", "combination: premises");
|
|
283
|
+
const funType = fastypeOf(left[1]);
|
|
284
|
+
if (funType.kind !== "Type" || funType.name !== "fun")
|
|
285
|
+
throw new TlaIsabelleError("THM", "combination: not function type");
|
|
286
|
+
if (!eqTyp(funType.args[0], fastypeOf(right[1])))
|
|
287
|
+
throw new TlaIsabelleError("THM", "combination: types");
|
|
288
|
+
return makeThm(
|
|
289
|
+
Math.max(first.maxidx, second.maxidx),
|
|
290
|
+
unionHyps(first.hyps, second.hyps),
|
|
291
|
+
unionTpairs(first.tpairs, second.tpairs),
|
|
292
|
+
mkEquals(mkApp(left[1], right[1]), mkApp(left[2], right[2])),
|
|
293
|
+
);
|
|
294
|
+
};
|
|
295
|
+
|
|
296
|
+
const destImp = (prop: Term): [Term, Term] | undefined =>
|
|
297
|
+
prop.kind === "App" &&
|
|
298
|
+
prop.fun.kind === "App" &&
|
|
299
|
+
prop.fun.fun.kind === "Const" &&
|
|
300
|
+
prop.fun.fun.name === "Pure.imp"
|
|
301
|
+
? [prop.fun.arg, prop.arg]
|
|
302
|
+
: undefined;
|
|
303
|
+
|
|
304
|
+
export const equalIntr = (first: Thm, second: Thm): Thm => {
|
|
305
|
+
const left = destImp(first.prop);
|
|
306
|
+
const right = destImp(second.prop);
|
|
307
|
+
if (left === undefined || right === undefined)
|
|
308
|
+
throw new TlaIsabelleError("THM", "equal_intr: premises");
|
|
309
|
+
if (!aconv(left[0], right[1]) || !aconv(left[1], right[0]))
|
|
310
|
+
throw new TlaIsabelleError("THM", "equal_intr: not equal");
|
|
311
|
+
return makeThm(
|
|
312
|
+
Math.max(first.maxidx, second.maxidx),
|
|
313
|
+
unionHyps(first.hyps, second.hyps),
|
|
314
|
+
unionTpairs(first.tpairs, second.tpairs),
|
|
315
|
+
mkEquals(left[0], left[1]),
|
|
316
|
+
);
|
|
317
|
+
};
|
|
318
|
+
|
|
319
|
+
export const equalElim = (first: Thm, second: Thm): Thm => {
|
|
320
|
+
const parts = destEq(first);
|
|
321
|
+
if (parts === undefined) throw new TlaIsabelleError("THM", "equal_elim: major premise");
|
|
322
|
+
if (!aconv(second.prop, parts[1])) throw new TlaIsabelleError("THM", "equal_elim: not equal");
|
|
323
|
+
return makeThm(
|
|
324
|
+
Math.max(first.maxidx, second.maxidx),
|
|
325
|
+
unionHyps(first.hyps, second.hyps),
|
|
326
|
+
unionTpairs(first.tpairs, second.tpairs),
|
|
327
|
+
parts[2],
|
|
328
|
+
);
|
|
329
|
+
};
|
|
330
|
+
|
|
331
|
+
export const flexflexRule = (limits: Limits | undefined, thm: Thm): Seq<Thm> =>
|
|
332
|
+
mapSeq(
|
|
333
|
+
(envir: Envir) => {
|
|
334
|
+
if (isEmptyEnvir(envir)) return thm;
|
|
335
|
+
const tpairs = thm.tpairs
|
|
336
|
+
.map((pair): Tpair => [normTerm(envir, pair[0]), normTerm(envir, pair[1])])
|
|
337
|
+
.filter((pair) => !aconv(pair[0], pair[1]));
|
|
338
|
+
const prop = normTerm(envir, thm.prop);
|
|
339
|
+
return makeThm(maxidxTpairs(tpairs, maxidxOfTerm(prop)), thm.hyps, tpairs, prop);
|
|
340
|
+
},
|
|
341
|
+
smashUnifiers(limits, thm.tpairs, emptyEnvir(thm.maxidx)),
|
|
342
|
+
);
|
|
343
|
+
|
|
344
|
+
// Thm.generalize: turns the named free variables into schematic ones with the given index.
|
|
345
|
+
export const generalize = (frees: readonly string[], index: number, thm: Thm): Thm => {
|
|
346
|
+
if (frees.length === 0) return thm;
|
|
347
|
+
if (index <= thm.maxidx) throw new TlaIsabelleError("THM", "generalize: bad index");
|
|
348
|
+
if (
|
|
349
|
+
thm.hyps.some((hyp) =>
|
|
350
|
+
existsSubterm((sub) => sub.kind === "Free" && frees.includes(sub.name), hyp),
|
|
351
|
+
)
|
|
352
|
+
)
|
|
353
|
+
throw new TlaIsabelleError("THM", "generalize: variable free in assumptions");
|
|
354
|
+
const generalizeTerm = (term: Term): Term => {
|
|
355
|
+
switch (term.kind) {
|
|
356
|
+
case "Free":
|
|
357
|
+
return frees.includes(term.name) ? mkVar(term.name, index, term.type) : term;
|
|
358
|
+
case "Abs":
|
|
359
|
+
return mkAbs(term.name, term.type, generalizeTerm(term.body));
|
|
360
|
+
case "App":
|
|
361
|
+
return mkApp(generalizeTerm(term.fun), generalizeTerm(term.arg));
|
|
362
|
+
default:
|
|
363
|
+
return term;
|
|
364
|
+
}
|
|
365
|
+
};
|
|
366
|
+
const prop = generalizeTerm(thm.prop);
|
|
367
|
+
const tpairs = thm.tpairs.map((pair): Tpair => [
|
|
368
|
+
generalizeTerm(pair[0]),
|
|
369
|
+
generalizeTerm(pair[1]),
|
|
370
|
+
]);
|
|
371
|
+
return makeThm(maxidxTpairs(tpairs, maxidxOfTerm(prop)), thm.hyps, tpairs, prop);
|
|
372
|
+
};
|
|
373
|
+
|
|
374
|
+
export interface Instantiation {
|
|
375
|
+
readonly variable: Var;
|
|
376
|
+
readonly term: Term;
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
const instantiateTerm = (insts: readonly Instantiation[], term: Term): Term => {
|
|
380
|
+
const find = (variable: Var) =>
|
|
381
|
+
insts.find(
|
|
382
|
+
(inst) =>
|
|
383
|
+
inst.variable.name === variable.name &&
|
|
384
|
+
inst.variable.index === variable.index &&
|
|
385
|
+
eqTyp(inst.variable.type, variable.type),
|
|
386
|
+
)?.term;
|
|
387
|
+
const subst = (current: Term): Term => {
|
|
388
|
+
switch (current.kind) {
|
|
389
|
+
case "Var":
|
|
390
|
+
return find(current) ?? current;
|
|
391
|
+
case "Abs": {
|
|
392
|
+
const body = subst(current.body);
|
|
393
|
+
return body === current.body ? current : mkAbs(current.name, current.type, body);
|
|
394
|
+
}
|
|
395
|
+
case "App": {
|
|
396
|
+
const fun = subst(current.fun);
|
|
397
|
+
const arg = subst(current.arg);
|
|
398
|
+
return fun === current.fun && arg === current.arg ? current : mkApp(fun, arg);
|
|
399
|
+
}
|
|
400
|
+
default:
|
|
401
|
+
return current;
|
|
402
|
+
}
|
|
403
|
+
};
|
|
404
|
+
return subst(term);
|
|
405
|
+
};
|
|
406
|
+
|
|
407
|
+
// Thm.instantiate for term variables. Every instance must have the type of its variable.
|
|
408
|
+
export const instantiate = (insts: readonly Instantiation[], thm: Thm): Thm => {
|
|
409
|
+
if (insts.length === 0) return thm;
|
|
410
|
+
for (const inst of insts)
|
|
411
|
+
if (!eqTyp(inst.variable.type, fastypeOf(inst.term)))
|
|
412
|
+
throw new TlaIsabelleError("THM", "instantiate: type conflict");
|
|
413
|
+
const prop = instantiateTerm(insts, thm.prop);
|
|
414
|
+
const tpairs = thm.tpairs.map((pair): Tpair => [
|
|
415
|
+
instantiateTerm(insts, pair[0]),
|
|
416
|
+
instantiateTerm(insts, pair[1]),
|
|
417
|
+
]);
|
|
418
|
+
return makeThm(maxidxTpairs(tpairs, maxidxOfTerm(prop)), thm.hyps, tpairs, prop);
|
|
419
|
+
};
|
|
420
|
+
|
|
421
|
+
// Thm.instantiate for type variables.
|
|
422
|
+
const instantiateTypesTerm = (tyenv: TyEnv, term: Term): Term => {
|
|
423
|
+
if (maxidxOfTerm(term) < 0) return term;
|
|
424
|
+
switch (term.kind) {
|
|
425
|
+
case "Const":
|
|
426
|
+
return mkConst(term.name, substType(tyenv, term.type));
|
|
427
|
+
case "Free":
|
|
428
|
+
return mkFree(term.name, substType(tyenv, term.type));
|
|
429
|
+
case "Var":
|
|
430
|
+
return mkVar(term.name, term.index, substType(tyenv, term.type));
|
|
431
|
+
case "Bound":
|
|
432
|
+
return term;
|
|
433
|
+
case "Abs":
|
|
434
|
+
return mkAbs(term.name, substType(tyenv, term.type), instantiateTypesTerm(tyenv, term.body));
|
|
435
|
+
case "App":
|
|
436
|
+
return mkApp(instantiateTypesTerm(tyenv, term.fun), instantiateTypesTerm(tyenv, term.arg));
|
|
437
|
+
}
|
|
438
|
+
};
|
|
439
|
+
|
|
440
|
+
export const instantiateTypes = (tyenv: TyEnv, thm: Thm): Thm => {
|
|
441
|
+
const prop = instantiateTypesTerm(tyenv, thm.prop);
|
|
442
|
+
const tpairs = thm.tpairs.map((pair): Tpair => [
|
|
443
|
+
instantiateTypesTerm(tyenv, pair[0]),
|
|
444
|
+
instantiateTypesTerm(tyenv, pair[1]),
|
|
445
|
+
]);
|
|
446
|
+
return makeThm(maxidxTpairs(tpairs, maxidxOfTerm(prop)), thm.hyps, tpairs, prop);
|
|
447
|
+
};
|
|
448
|
+
|
|
449
|
+
// Thm.renamed_prop: the same theorem with an alpha-equivalent proposition.
|
|
450
|
+
export const renamedProp = (prop: Term, thm: Thm): Thm => {
|
|
451
|
+
if (!aconv(prop, thm.prop)) throw new TlaIsabelleError("TERM", "renamed_prop: props disagree");
|
|
452
|
+
return makeThm(thm.maxidx, thm.hyps, thm.tpairs, prop);
|
|
453
|
+
};
|
|
454
|
+
|
|
455
|
+
export const trivial = (prop: Term): Thm => {
|
|
456
|
+
if (!eqTyp(fastypeOf(prop), propT))
|
|
457
|
+
throw new TlaIsabelleError("THM", "trivial: the term must have type prop");
|
|
458
|
+
return makeThm(maxidxOfTerm(prop), [], [], mkImplies(prop, prop));
|
|
459
|
+
};
|
|
460
|
+
|
|
461
|
+
interface State {
|
|
462
|
+
readonly tpairs: readonly Tpair[];
|
|
463
|
+
readonly before: Term[];
|
|
464
|
+
readonly goal: Term;
|
|
465
|
+
readonly conclusion: Term;
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
export const destState = (state: Thm, index: number): State => {
|
|
469
|
+
const premises = stripImpPrems(state.prop);
|
|
470
|
+
if (index < 1 || index > premises.length)
|
|
471
|
+
throw new TlaIsabelleError("THM", `dest_state ${index}`);
|
|
472
|
+
return {
|
|
473
|
+
tpairs: state.tpairs,
|
|
474
|
+
before: premises.slice(0, index - 1),
|
|
475
|
+
goal: premises[index - 1],
|
|
476
|
+
conclusion: listImplies(premises.slice(index), stripImpConcl(state.prop)),
|
|
477
|
+
};
|
|
478
|
+
};
|
|
479
|
+
|
|
480
|
+
// Thm.lift_rule: lifts a rule over the parameters and premises of a goal of a state.
|
|
481
|
+
export const liftRule = (goal: Term, goalMaxidx: number, rule: Thm): Thm => {
|
|
482
|
+
const increment = goalMaxidx + 1;
|
|
483
|
+
const premises = stripImpPrems(rule.prop).map((premise) => liftAll(increment, goal, premise));
|
|
484
|
+
return makeThm(
|
|
485
|
+
rule.maxidx + increment,
|
|
486
|
+
rule.hyps,
|
|
487
|
+
rule.tpairs.map((pair): Tpair => [
|
|
488
|
+
liftAbs(increment, goal, pair[0]),
|
|
489
|
+
liftAbs(increment, goal, pair[1]),
|
|
490
|
+
]),
|
|
491
|
+
listImplies(premises, liftAll(increment, goal, stripImpConcl(rule.prop))),
|
|
492
|
+
);
|
|
493
|
+
};
|
|
494
|
+
|
|
495
|
+
export const incrIndexesThm = (increment: number, thm: Thm): Thm => {
|
|
496
|
+
if (increment < 0) throw new TlaIsabelleError("THM", "negative increment");
|
|
497
|
+
if (increment === 0) return thm;
|
|
498
|
+
return makeThm(
|
|
499
|
+
thm.maxidx + increment,
|
|
500
|
+
thm.hyps,
|
|
501
|
+
thm.tpairs.map((pair): Tpair => [
|
|
502
|
+
incrIndexes([], increment, pair[0]),
|
|
503
|
+
incrIndexes([], increment, pair[1]),
|
|
504
|
+
]),
|
|
505
|
+
incrIndexes([], increment, thm.prop),
|
|
506
|
+
);
|
|
507
|
+
};
|
|
508
|
+
|
|
509
|
+
// Thm.assumption: solves goal index by any of its assumptions, with unification.
|
|
510
|
+
export const assumption = (limits: Limits | undefined, index: number, state: Thm): Seq<Thm> => {
|
|
511
|
+
const parts = destState(state, index);
|
|
512
|
+
const newThm = (unifier: { envir: Envir; tpairs: readonly Tpair[] }): Thm => {
|
|
513
|
+
const envir = unifier.envir;
|
|
514
|
+
const isEmpty = isEmptyEnvir(envir);
|
|
515
|
+
const prop = listImplies(parts.before, parts.conclusion);
|
|
516
|
+
return makeThm(
|
|
517
|
+
envir.maxidx,
|
|
518
|
+
state.hyps,
|
|
519
|
+
isEmpty
|
|
520
|
+
? unifier.tpairs
|
|
521
|
+
: unifier.tpairs.map((pair): Tpair => [normTerm(envir, pair[0]), normTerm(envir, pair[1])]),
|
|
522
|
+
isEmpty ? prop : normTerm(envir, prop),
|
|
523
|
+
);
|
|
524
|
+
};
|
|
525
|
+
const problems = assumProblems(-1, parts.goal);
|
|
526
|
+
const conclusion = problems.abstract(problems.conclusion);
|
|
527
|
+
const addprfs = (position: number): Seq<Thm> =>
|
|
528
|
+
position >= problems.hyps.length
|
|
529
|
+
? emptySeq
|
|
530
|
+
: makeSeq(() => {
|
|
531
|
+
const hyp = problems.hyps[position];
|
|
532
|
+
return mappSeq(
|
|
533
|
+
newThm,
|
|
534
|
+
couldUnify(hyp, problems.conclusion)
|
|
535
|
+
? unifiers(limits, emptyEnvir(state.maxidx), [
|
|
536
|
+
[problems.abstract(hyp), conclusion],
|
|
537
|
+
...parts.tpairs,
|
|
538
|
+
])
|
|
539
|
+
: emptySeq,
|
|
540
|
+
addprfs(position + 1),
|
|
541
|
+
).pull();
|
|
542
|
+
});
|
|
543
|
+
return addprfs(0);
|
|
544
|
+
};
|
|
545
|
+
|
|
546
|
+
// Thm.eq_assumption: solves goal index by an assumption equal to its conclusion up to alpha and eta.
|
|
547
|
+
export const eqAssumption = (index: number, state: Thm): Thm => {
|
|
548
|
+
const parts = destState(state, index);
|
|
549
|
+
const problems = assumProblems(-1, parts.goal);
|
|
550
|
+
// Envir.aeconv against each assumption, contracting the conclusion only once.
|
|
551
|
+
const conclusion = etaContract(problems.conclusion);
|
|
552
|
+
const isFound = problems.hyps.some(
|
|
553
|
+
(hyp) => aconv(hyp, problems.conclusion) || aconv(etaContract(hyp), conclusion),
|
|
554
|
+
);
|
|
555
|
+
if (!isFound) throw new TlaIsabelleError("THM", "eq_assumption");
|
|
556
|
+
return makeThm(
|
|
557
|
+
state.maxidx,
|
|
558
|
+
state.hyps,
|
|
559
|
+
state.tpairs,
|
|
560
|
+
listImplies(parts.before, parts.conclusion),
|
|
561
|
+
);
|
|
562
|
+
};
|
|
563
|
+
|
|
564
|
+
export const rotateRule = (count: number, index: number, state: Thm): Thm => {
|
|
565
|
+
const parts = destState(state, index);
|
|
566
|
+
const params = stripAllVars(parts.goal);
|
|
567
|
+
const rest = stripAllBody(parts.goal);
|
|
568
|
+
const asms = stripImpPrems(rest);
|
|
569
|
+
const concl = stripImpConcl(rest);
|
|
570
|
+
const total = asms.length;
|
|
571
|
+
const shift = count < 0 ? total + count : count;
|
|
572
|
+
if (shift < 0 || shift > total) throw new TlaIsabelleError("THM", `rotate_rule ${count}`);
|
|
573
|
+
const goal =
|
|
574
|
+
shift === 0 || shift === total
|
|
575
|
+
? parts.goal
|
|
576
|
+
: listAll(params, listImplies([...asms.slice(shift), ...asms.slice(0, shift)], concl));
|
|
577
|
+
const premises = stripImpPrems(state.prop);
|
|
578
|
+
return makeThm(
|
|
579
|
+
state.maxidx,
|
|
580
|
+
state.hyps,
|
|
581
|
+
state.tpairs,
|
|
582
|
+
listImplies([...parts.before, goal, ...premises.slice(index)], stripImpConcl(state.prop)),
|
|
583
|
+
);
|
|
584
|
+
};
|
|
585
|
+
|
|
586
|
+
export const permutePrems = (fixed: number, count: number, rule: Thm): Thm => {
|
|
587
|
+
const premises = stripImpPrems(rule.prop);
|
|
588
|
+
const concl = stripImpConcl(rule.prop);
|
|
589
|
+
if (fixed > premises.length) throw new TlaIsabelleError("THM", `permute_prems: j ${fixed}`);
|
|
590
|
+
const moved = premises.slice(fixed);
|
|
591
|
+
const shift = count < 0 ? moved.length + count : count;
|
|
592
|
+
if (shift === 0 || shift === moved.length) return rule;
|
|
593
|
+
if (shift < 0 || shift > moved.length)
|
|
594
|
+
throw new TlaIsabelleError("THM", `permute_prems: k ${count}`);
|
|
595
|
+
return makeThm(
|
|
596
|
+
rule.maxidx,
|
|
597
|
+
rule.hyps,
|
|
598
|
+
rule.tpairs,
|
|
599
|
+
listImplies(
|
|
600
|
+
[...premises.slice(0, fixed), ...moved.slice(shift), ...moved.slice(0, shift)],
|
|
601
|
+
concl,
|
|
602
|
+
),
|
|
603
|
+
);
|
|
604
|
+
};
|
|
605
|
+
|
|
606
|
+
export interface ComposeFlags {
|
|
607
|
+
readonly flatten: boolean;
|
|
608
|
+
readonly match: boolean;
|
|
609
|
+
readonly incremented: boolean;
|
|
610
|
+
}
|
|
611
|
+
|
|
612
|
+
export interface ComposeRule {
|
|
613
|
+
readonly isElim: boolean;
|
|
614
|
+
readonly rule: Thm;
|
|
615
|
+
readonly subgoals: number;
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
class Compose {}
|
|
619
|
+
|
|
620
|
+
const bicomposeAux = (
|
|
621
|
+
limits: Limits | undefined,
|
|
622
|
+
flags: ComposeFlags,
|
|
623
|
+
state: Thm,
|
|
624
|
+
parts: State,
|
|
625
|
+
isLifted: boolean,
|
|
626
|
+
compose: ComposeRule,
|
|
627
|
+
): Seq<Thm> => {
|
|
628
|
+
const orule = compose.rule;
|
|
629
|
+
const lift = countPrems(stripAllBody(parts.goal)) + (compose.isElim ? -1 : 0);
|
|
630
|
+
const addth = (
|
|
631
|
+
newAs: { premises: Term[] },
|
|
632
|
+
unifier: { envir: Envir; tpairs: readonly Tpair[] },
|
|
633
|
+
rest: Seq<Thm>,
|
|
634
|
+
): Seq<Thm> => {
|
|
635
|
+
try {
|
|
636
|
+
const envir = unifier.envir;
|
|
637
|
+
const normt = (term: Term) => normTerm(envir, term);
|
|
638
|
+
const computed = (): [readonly Tpair[], Term[], Term] => {
|
|
639
|
+
if (isEmptyEnvir(envir))
|
|
640
|
+
return [unifier.tpairs, [...parts.before, ...newAs.premises], parts.conclusion];
|
|
641
|
+
const tpairs = unifier.tpairs.map((pair): Tpair => [normt(pair[0]), normt(pair[1])]);
|
|
642
|
+
if (above(envir, state.maxidx))
|
|
643
|
+
return isLifted
|
|
644
|
+
? [
|
|
645
|
+
tpairs,
|
|
646
|
+
[
|
|
647
|
+
...parts.before,
|
|
648
|
+
...newAs.premises.map((premise) => normTermSkip(envir, lift, premise)),
|
|
649
|
+
],
|
|
650
|
+
parts.conclusion,
|
|
651
|
+
]
|
|
652
|
+
: [tpairs, [...parts.before, ...newAs.premises.map(normt)], parts.conclusion];
|
|
653
|
+
if (flags.match) throw new Compose();
|
|
654
|
+
return [tpairs, [...parts.before, ...newAs.premises].map(normt), normt(parts.conclusion)];
|
|
655
|
+
};
|
|
656
|
+
const [tpairs, premises, conclusion] = computed();
|
|
657
|
+
return consSeq(
|
|
658
|
+
makeThm(
|
|
659
|
+
envir.maxidx,
|
|
660
|
+
unionHyps(orule.hyps, state.hyps),
|
|
661
|
+
tpairs,
|
|
662
|
+
listImplies(premises, conclusion),
|
|
663
|
+
),
|
|
664
|
+
rest,
|
|
665
|
+
);
|
|
666
|
+
} catch (error) {
|
|
667
|
+
if (error instanceof Compose) return rest;
|
|
668
|
+
throw error;
|
|
669
|
+
}
|
|
670
|
+
};
|
|
671
|
+
const stripped = (() => {
|
|
672
|
+
try {
|
|
673
|
+
return stripPrems(compose.subgoals, [], orule.prop);
|
|
674
|
+
} catch (error) {
|
|
675
|
+
if (error instanceof TlaIsabelleError && error.exception === "TERM")
|
|
676
|
+
throw new TlaIsabelleError("THM", "bicompose: rule");
|
|
677
|
+
throw error;
|
|
678
|
+
}
|
|
679
|
+
})();
|
|
680
|
+
const reversedAs = stripped[0];
|
|
681
|
+
const conclusion = stripped[1];
|
|
682
|
+
const newAs = (
|
|
683
|
+
premises: readonly Term[],
|
|
684
|
+
index: number,
|
|
685
|
+
dpairs: readonly Tpair[],
|
|
686
|
+
tpairs: readonly Tpair[],
|
|
687
|
+
) => {
|
|
688
|
+
const rename = isLifted ? renameBvars(dpairs, tpairs, conclusion, premises) : undefined;
|
|
689
|
+
const renamed =
|
|
690
|
+
rename === undefined
|
|
691
|
+
? [...premises]
|
|
692
|
+
: premises.map((premise) => stripApply(rename, conclusion, premise));
|
|
693
|
+
try {
|
|
694
|
+
return {
|
|
695
|
+
premises: flags.flatten ? renamed.map((premise) => flattenParams(index, premise)) : renamed,
|
|
696
|
+
};
|
|
697
|
+
} catch (error) {
|
|
698
|
+
if (error instanceof TlaIsabelleError && error.exception === "TERM")
|
|
699
|
+
throw new TlaIsabelleError("THM", "bicompose: 1st premise");
|
|
700
|
+
throw error;
|
|
701
|
+
}
|
|
702
|
+
};
|
|
703
|
+
const bbi = isLifted ? stripAssums2(conclusion, parts.goal) : ([conclusion, parts.goal] as const);
|
|
704
|
+
const dpairs: Tpair[] = [bbi, ...orule.tpairs, ...parts.tpairs];
|
|
705
|
+
const eres = (envir: Envir, premises: readonly Term[]): Seq<Thm> => {
|
|
706
|
+
if (premises.length === 0) throw new TlaIsabelleError("THM", "bicompose: no premises");
|
|
707
|
+
const first = premises[0];
|
|
708
|
+
const rest = premises.slice(1);
|
|
709
|
+
const problems = assumProblems(lift + 1, first);
|
|
710
|
+
const concl = problems.abstract(problems.conclusion);
|
|
711
|
+
const tryasms = (position: number): Seq<Thm> => {
|
|
712
|
+
for (let index = position; index < problems.hyps.length; index += 1) {
|
|
713
|
+
const asm = problems.hyps[index];
|
|
714
|
+
if (!couldUnify(asm, problems.conclusion)) continue;
|
|
715
|
+
const closed = problems.abstract(asm);
|
|
716
|
+
const cell = unifiers(limits, envir, [[closed, concl], ...dpairs]).pull();
|
|
717
|
+
if (cell === undefined) continue;
|
|
718
|
+
const prepared = newAs(rest, index + 1, [bbi, [concl, closed]], cell[0].tpairs);
|
|
719
|
+
return itRightSeq(
|
|
720
|
+
(unifier, tail: Seq<Thm>) => addth(prepared, unifier, tail),
|
|
721
|
+
makeSeq(() => cell),
|
|
722
|
+
deferSeq(() => tryasms(index + 1)),
|
|
723
|
+
);
|
|
724
|
+
}
|
|
725
|
+
return emptySeq;
|
|
726
|
+
};
|
|
727
|
+
return tryasms(0);
|
|
728
|
+
};
|
|
729
|
+
const res = (envir: Envir): Seq<Thm> => {
|
|
730
|
+
const cell = unifiers(limits, envir, dpairs).pull();
|
|
731
|
+
if (cell === undefined) return emptySeq;
|
|
732
|
+
const prepared = newAs([...reversedAs].reverse(), 0, [bbi], cell[0].tpairs);
|
|
733
|
+
return itRightSeq(
|
|
734
|
+
(unifier, tail: Seq<Thm>) => addth(prepared, unifier, tail),
|
|
735
|
+
makeSeq(() => cell),
|
|
736
|
+
emptySeq,
|
|
737
|
+
);
|
|
738
|
+
};
|
|
739
|
+
const initial = emptyEnvir(Math.max(orule.maxidx, state.maxidx));
|
|
740
|
+
const envir = flags.incremented ? initial : unifyVarTypes(state, orule, initial);
|
|
741
|
+
if (envir === undefined) return emptySeq;
|
|
742
|
+
return compose.isElim ? eres(envir, [...reversedAs].reverse()) : res(envir);
|
|
743
|
+
};
|
|
744
|
+
|
|
745
|
+
export const bicompose = (
|
|
746
|
+
limits: Limits | undefined,
|
|
747
|
+
flags: ComposeFlags,
|
|
748
|
+
compose: ComposeRule,
|
|
749
|
+
index: number,
|
|
750
|
+
state: Thm,
|
|
751
|
+
) => bicomposeAux(limits, flags, state, destState(state, index), false, compose);
|
|
752
|
+
|
|
753
|
+
export const couldBires = (hyps: readonly Term[], goal: Term, isElim: boolean, rule: Thm) => {
|
|
754
|
+
if (!couldUnify(conclOf(rule), goal)) return false;
|
|
755
|
+
if (!isElim) return true;
|
|
756
|
+
const first = premsOf(rule)[0];
|
|
757
|
+
return first !== undefined && hyps.some((hyp) => couldUnify(first, hyp));
|
|
758
|
+
};
|
|
759
|
+
|
|
760
|
+
export interface BiresRule {
|
|
761
|
+
readonly isElim: boolean;
|
|
762
|
+
readonly rule: Thm;
|
|
763
|
+
}
|
|
764
|
+
|
|
765
|
+
// Thm.biresolution: resolves goal index with each rule, the elimination rules also solving their
|
|
766
|
+
// first premise by an assumption.
|
|
767
|
+
export const biresolution = (
|
|
768
|
+
limits: Limits | undefined,
|
|
769
|
+
match: boolean,
|
|
770
|
+
rules: readonly BiresRule[],
|
|
771
|
+
index: number,
|
|
772
|
+
state: Thm,
|
|
773
|
+
): Seq<Thm> => {
|
|
774
|
+
const parts = destState(state, index);
|
|
775
|
+
const goal = stripAssumsConcl(parts.goal);
|
|
776
|
+
const hyps = stripAssumsHyp(parts.goal);
|
|
777
|
+
const res = (position: number): Seq<Seq<Thm>> => {
|
|
778
|
+
for (let current = position; current < rules.length; current += 1) {
|
|
779
|
+
const brule = rules[current];
|
|
780
|
+
if (!couldBires(hyps, goal, brule.isElim, brule.rule)) continue;
|
|
781
|
+
return makeSeq(() => [
|
|
782
|
+
bicomposeAux(limits, { flatten: true, match, incremented: true }, state, parts, true, {
|
|
783
|
+
isElim: brule.isElim,
|
|
784
|
+
rule: liftRule(parts.goal, state.maxidx, brule.rule),
|
|
785
|
+
subgoals: nprems(brule.rule),
|
|
786
|
+
}),
|
|
787
|
+
res(current + 1),
|
|
788
|
+
]);
|
|
789
|
+
}
|
|
790
|
+
return emptySeq;
|
|
791
|
+
};
|
|
792
|
+
return flatSeq(res(0));
|
|
793
|
+
};
|
|
794
|
+
|
|
795
|
+
// Thm.RSN: resolution that must produce exactly one resolvent.
|
|
796
|
+
export const rsn = (rule: Thm, index: number, state: Thm): Thm => {
|
|
797
|
+
const [results] = chopSeq(
|
|
798
|
+
2,
|
|
799
|
+
biresolution(undefined, false, [{ isElim: false, rule }], index, state),
|
|
800
|
+
);
|
|
801
|
+
if (results.length === 0) throw new TlaIsabelleError("THM", `RSN: no unifiers ${index}`);
|
|
802
|
+
if (results.length > 1) throw new TlaIsabelleError("THM", `RSN: multiple unifiers ${index}`);
|
|
803
|
+
return results[0];
|
|
804
|
+
};
|
|
805
|
+
|
|
806
|
+
export const rs = (rule: Thm, state: Thm) => rsn(rule, 1, state);
|