tla-ts 0.0.4-dev.0be9567 → 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 +33 -1
- package/dist/index.d.ts +33 -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/errors.ts +86 -0
- package/src/evaluate.ts +54 -19
- 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/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +47 -4
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,602 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/raw_simplifier.ML, the bottom-up rewriting of terms, and the
|
|
2
|
+
// goal conversions of Pure/conv.ML. Copyright (c) 1986-2025 University of Cambridge, Technische
|
|
3
|
+
// Universitaet Muenchen, and contributors, see LICENSE.
|
|
4
|
+
|
|
5
|
+
import { TlaIsabelleError } from "../../../errors";
|
|
6
|
+
import { gconvRule, impCongRule } from "./conv";
|
|
7
|
+
import { impCong, swapPremsEq } from "./drule";
|
|
8
|
+
import { emptyTEnv } from "./envir";
|
|
9
|
+
import {
|
|
10
|
+
destEquals,
|
|
11
|
+
destImplies,
|
|
12
|
+
incrIndexes,
|
|
13
|
+
isImplies,
|
|
14
|
+
listImplies,
|
|
15
|
+
mkImplies,
|
|
16
|
+
stripImpConcl,
|
|
17
|
+
stripImpPrems,
|
|
18
|
+
} from "./logic";
|
|
19
|
+
import { boundName } from "./name";
|
|
20
|
+
import { matchTermNet, type Net } from "./net";
|
|
21
|
+
import { firstOrderMatchPattern, matchPattern, matches, type MatchEnv } from "./pattern";
|
|
22
|
+
import {
|
|
23
|
+
addPrems,
|
|
24
|
+
congKey,
|
|
25
|
+
congName,
|
|
26
|
+
extractSafeRrules,
|
|
27
|
+
insertRrule,
|
|
28
|
+
mkProcrule,
|
|
29
|
+
SIMP_DEPTH_LIMIT,
|
|
30
|
+
type Procedure,
|
|
31
|
+
type Rrule,
|
|
32
|
+
type SimpContext,
|
|
33
|
+
} from "./raw-simplifier";
|
|
34
|
+
import { lookupTable, tableEntries } from "./table";
|
|
35
|
+
import { emptyTyEnv, substType } from "./type";
|
|
36
|
+
import {
|
|
37
|
+
aconv,
|
|
38
|
+
existsSubterm,
|
|
39
|
+
eqTyp,
|
|
40
|
+
foldVars,
|
|
41
|
+
listComb,
|
|
42
|
+
maxidxOfTerm,
|
|
43
|
+
mkBound,
|
|
44
|
+
mkFree,
|
|
45
|
+
mkVar,
|
|
46
|
+
propT,
|
|
47
|
+
renameAbs,
|
|
48
|
+
stripComb,
|
|
49
|
+
substBound,
|
|
50
|
+
dummyT,
|
|
51
|
+
type App,
|
|
52
|
+
type Term,
|
|
53
|
+
type Var,
|
|
54
|
+
} from "./term";
|
|
55
|
+
import { termOrd } from "./term-ord";
|
|
56
|
+
import {
|
|
57
|
+
abstractRule,
|
|
58
|
+
assume,
|
|
59
|
+
betaConversion,
|
|
60
|
+
combination,
|
|
61
|
+
etaConversion,
|
|
62
|
+
flexflexRule,
|
|
63
|
+
impliesElim,
|
|
64
|
+
impliesIntr,
|
|
65
|
+
incrIndexesThm,
|
|
66
|
+
instantiate,
|
|
67
|
+
instantiateTypes,
|
|
68
|
+
nprems,
|
|
69
|
+
reflexive,
|
|
70
|
+
renamedProp,
|
|
71
|
+
symmetric,
|
|
72
|
+
transitive,
|
|
73
|
+
type Instantiation,
|
|
74
|
+
type Thm,
|
|
75
|
+
} from "./thm";
|
|
76
|
+
import { checkInterrupt, type Limits } from "./interrupt";
|
|
77
|
+
import { resolveTac } from "./tactic";
|
|
78
|
+
import { listOfSeq, seqHead, singleSeq, emptySeq, type Seq } from "./seq";
|
|
79
|
+
import { allGoals, eqThm } from "./tactical";
|
|
80
|
+
|
|
81
|
+
export type Prover = (context: SimpContext, thm: Thm) => Thm | undefined;
|
|
82
|
+
|
|
83
|
+
// simple_prover: proves the premises of a rewrite rule with the premises of the simpset.
|
|
84
|
+
export const simpleProver: Prover = (context, thm) =>
|
|
85
|
+
seqHead(allGoals(resolveTac(context.limits, context.simpset.prems))(thm));
|
|
86
|
+
|
|
87
|
+
const isThmError = (error: unknown) =>
|
|
88
|
+
error instanceof TlaIsabelleError && error.exception === "THM";
|
|
89
|
+
|
|
90
|
+
const lhsOf = (thm: Thm) => destEquals(thm.prop)[0];
|
|
91
|
+
const rhsOf = (thm: Thm) => destEquals(thm.prop)[1];
|
|
92
|
+
|
|
93
|
+
const betaEtaConversion = (term: Term) => {
|
|
94
|
+
const beta = betaConversion(true, term);
|
|
95
|
+
return transitive(beta, etaConversion(rhsOf(beta)));
|
|
96
|
+
};
|
|
97
|
+
|
|
98
|
+
// Thm.match and Thm.instantiate: instantiates rule so that pattern becomes object.
|
|
99
|
+
const instantiateMatch = (env: MatchEnv, rule: Thm): Thm => {
|
|
100
|
+
const typed = instantiateTypes(env.tyenv, rule);
|
|
101
|
+
const insts: Instantiation[] = tableEntries(env.tenv).map(([key, binding]) => ({
|
|
102
|
+
variable: mkVar(key.name, key.index, substType(env.tyenv, binding.type)),
|
|
103
|
+
term: binding.term,
|
|
104
|
+
}));
|
|
105
|
+
return instantiate(insts, typed);
|
|
106
|
+
};
|
|
107
|
+
|
|
108
|
+
const renameBoundvars = (pattern: Term, object: Term, thm: Thm) => {
|
|
109
|
+
const renamed = renameAbs(pattern, object, thm.prop);
|
|
110
|
+
return renamed === undefined ? thm : renamedProp(renamed, thm);
|
|
111
|
+
};
|
|
112
|
+
|
|
113
|
+
// check_conv: joins thm and next, allowing for beta and eta differences in the middle term.
|
|
114
|
+
const checkConv = (thm: Thm, next: Thm): Thm | undefined => {
|
|
115
|
+
try {
|
|
116
|
+
return transitive(thm, next);
|
|
117
|
+
} catch (error) {
|
|
118
|
+
if (!isThmError(error)) throw error;
|
|
119
|
+
}
|
|
120
|
+
try {
|
|
121
|
+
const normalized = transitive(symmetric(betaEtaConversion(lhsOf(next))), next);
|
|
122
|
+
try {
|
|
123
|
+
return transitive(thm, normalized);
|
|
124
|
+
} catch (error) {
|
|
125
|
+
if (!isThmError(error)) throw error;
|
|
126
|
+
return transitive(transitive(thm, betaEtaConversion(rhsOf(thm))), normalized);
|
|
127
|
+
}
|
|
128
|
+
} catch (error) {
|
|
129
|
+
if (isThmError(error)) return undefined;
|
|
130
|
+
throw error;
|
|
131
|
+
}
|
|
132
|
+
};
|
|
133
|
+
|
|
134
|
+
const SKEL0 = mkBound(0);
|
|
135
|
+
const skelFun = (skel: Term) => (skel.kind === "App" ? skel.fun : SKEL0);
|
|
136
|
+
const skelArg = (skel: Term) => (skel.kind === "App" ? skel.arg : SKEL0);
|
|
137
|
+
const skelBody = (skel: Term) => (skel.kind === "Abs" ? skel.body : SKEL0);
|
|
138
|
+
|
|
139
|
+
const isWeakCong = (context: SimpContext, lhs: Term) => {
|
|
140
|
+
const weak = context.simpset.weakCongs;
|
|
141
|
+
if (weak.length === 0) return false;
|
|
142
|
+
return existsSubterm(
|
|
143
|
+
(sub) =>
|
|
144
|
+
(sub.kind === "Const" && weak.some((name) => name.isConst && name.name === sub.name)) ||
|
|
145
|
+
(sub.kind === "Free" && weak.some((name) => !name.isConst && name.name === sub.name)),
|
|
146
|
+
lhs,
|
|
147
|
+
);
|
|
148
|
+
};
|
|
149
|
+
|
|
150
|
+
const uncondSkel = (context: SimpContext, lhs: Term, rhs: Term) =>
|
|
151
|
+
isWeakCong(context, lhs) ? SKEL0 : rhs;
|
|
152
|
+
|
|
153
|
+
const varsOf = (term: Term) => foldVars((atom, result: Var[]) => [...result, atom], term, []);
|
|
154
|
+
|
|
155
|
+
const condSkel = (context: SimpContext, lhs: Term, rhs: Term) => {
|
|
156
|
+
const lhsVars = varsOf(lhs);
|
|
157
|
+
return varsOf(rhs).every((variable) =>
|
|
158
|
+
lhsVars.some(
|
|
159
|
+
(other) =>
|
|
160
|
+
other.name === variable.name &&
|
|
161
|
+
other.index === variable.index &&
|
|
162
|
+
eqTyp(other.type, variable.type),
|
|
163
|
+
),
|
|
164
|
+
)
|
|
165
|
+
? uncondSkel(context, lhs, rhs)
|
|
166
|
+
: SKEL0;
|
|
167
|
+
};
|
|
168
|
+
|
|
169
|
+
interface Rewritten {
|
|
170
|
+
readonly thm: Thm;
|
|
171
|
+
readonly skel: Term;
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
const sortRrules = (rrules: readonly Rrule[]) => {
|
|
175
|
+
const simple: Rrule[] = [];
|
|
176
|
+
const conditional: Rrule[] = [];
|
|
177
|
+
for (const rrule of rrules) {
|
|
178
|
+
const prop = rrule.thm.prop;
|
|
179
|
+
const isSimple =
|
|
180
|
+
prop.kind === "App" &&
|
|
181
|
+
prop.fun.kind === "App" &&
|
|
182
|
+
prop.fun.fun.kind === "Const" &&
|
|
183
|
+
prop.fun.fun.name === "Pure.eq";
|
|
184
|
+
if (isSimple) simple.unshift(rrule);
|
|
185
|
+
else conditional.unshift(rrule);
|
|
186
|
+
}
|
|
187
|
+
return [...simple, ...conditional];
|
|
188
|
+
};
|
|
189
|
+
|
|
190
|
+
// rewritec's rew: rewrites the eta-contracted term with one rule.
|
|
191
|
+
const rew = (
|
|
192
|
+
prover: Prover,
|
|
193
|
+
maxt: number,
|
|
194
|
+
context: SimpContext,
|
|
195
|
+
etaThm: Thm,
|
|
196
|
+
rrule: Rrule,
|
|
197
|
+
): Rewritten | undefined => {
|
|
198
|
+
const etaTerm = rhsOf(etaThm);
|
|
199
|
+
const [rthm, elhs] =
|
|
200
|
+
maxt === -1 || !rrule.extra
|
|
201
|
+
? [rrule.thm, rrule.elhs]
|
|
202
|
+
: [incrIndexesThm(maxt + 1, rrule.thm), incrementTerm(maxt + 1, rrule.elhs)];
|
|
203
|
+
const env = rrule.fo
|
|
204
|
+
? firstOrderMatchPattern(elhs, etaTerm, { tyenv: emptyTyEnv, tenv: emptyTEnv })
|
|
205
|
+
: matchPattern(elhs, etaTerm, { tyenv: emptyTyEnv, tenv: emptyTEnv });
|
|
206
|
+
if (env === undefined) return undefined;
|
|
207
|
+
const instantiated = instantiateMatch(env, renameBoundvars(rrule.lhs, etaTerm, rthm));
|
|
208
|
+
const prop = instantiated.prop;
|
|
209
|
+
const isUnconditional = !isImplies(prop);
|
|
210
|
+
const [lhs, rhs] = destEquals(stripImpConcl(prop));
|
|
211
|
+
if (rrule.perm && termOrd(rhs, lhs) >= 0) return undefined;
|
|
212
|
+
if (isUnconditional) {
|
|
213
|
+
const joined = checkConv(etaThm, instantiated);
|
|
214
|
+
if (joined === undefined) throw new TlaIsabelleError("ERROR", "check_conv");
|
|
215
|
+
const [ruleLhs, ruleRhs] = destEquals(rrule.thm.prop);
|
|
216
|
+
return { thm: joined, skel: uncondSkel(context, ruleLhs, ruleRhs) };
|
|
217
|
+
}
|
|
218
|
+
if (context.simpset.depth > SIMP_DEPTH_LIMIT) return undefined;
|
|
219
|
+
const proved = prover(context, instantiated);
|
|
220
|
+
if (proved === undefined) return undefined;
|
|
221
|
+
const joined = checkConv(etaThm, proved);
|
|
222
|
+
if (joined === undefined) return undefined;
|
|
223
|
+
const [ruleLhs, ruleRhs] = destEquals(stripImpConcl(rrule.thm.prop));
|
|
224
|
+
return { thm: joined, skel: condSkel(context, ruleLhs, ruleRhs) };
|
|
225
|
+
};
|
|
226
|
+
|
|
227
|
+
// rewritec's rews: the first rule that rewrites the term.
|
|
228
|
+
const rews = (
|
|
229
|
+
prover: Prover,
|
|
230
|
+
maxt: number,
|
|
231
|
+
context: SimpContext,
|
|
232
|
+
etaThm: Thm,
|
|
233
|
+
rrules: readonly Rrule[],
|
|
234
|
+
): Rewritten | undefined => {
|
|
235
|
+
for (const rrule of rrules) {
|
|
236
|
+
const result = rew(prover, maxt, context, etaThm, rrule);
|
|
237
|
+
if (result !== undefined) return result;
|
|
238
|
+
}
|
|
239
|
+
return undefined;
|
|
240
|
+
};
|
|
241
|
+
|
|
242
|
+
// rewritec: one rewrite step at the root of a term.
|
|
243
|
+
const rewritec = (
|
|
244
|
+
prover: Prover,
|
|
245
|
+
maxt: number,
|
|
246
|
+
context: SimpContext,
|
|
247
|
+
term: Term,
|
|
248
|
+
): Rewritten | undefined => {
|
|
249
|
+
checkInterrupt(context.limits);
|
|
250
|
+
const etaThm = etaConversion(term);
|
|
251
|
+
const etaTerm = rhsOf(etaThm);
|
|
252
|
+
if (etaTerm.kind === "App" && etaTerm.fun.kind === "Abs")
|
|
253
|
+
return { thm: transitive(etaThm, betaConversion(false, etaTerm)), skel: SKEL0 };
|
|
254
|
+
const rewritten = rews(
|
|
255
|
+
prover,
|
|
256
|
+
maxt,
|
|
257
|
+
context,
|
|
258
|
+
etaThm,
|
|
259
|
+
sortRrules(matchTermNet(context.simpset.rules, etaTerm)),
|
|
260
|
+
);
|
|
261
|
+
if (rewritten !== undefined) return rewritten;
|
|
262
|
+
for (const proc of matchTermNet(context.simpset.simprocs as Net<Procedure>, etaTerm)) {
|
|
263
|
+
if (!matches(proc.lhs, term, emptyTyEnv, emptyTEnv)) continue;
|
|
264
|
+
const raw = proc.proc(context, etaTerm);
|
|
265
|
+
if (raw === undefined) continue;
|
|
266
|
+
const result = rews(prover, maxt, context, etaThm, mkProcrule(raw));
|
|
267
|
+
if (result !== undefined) return result;
|
|
268
|
+
}
|
|
269
|
+
return undefined;
|
|
270
|
+
};
|
|
271
|
+
|
|
272
|
+
const incrementTerm = (increment: number, term: Term) => incrIndexes([], increment, term);
|
|
273
|
+
|
|
274
|
+
// congc: applies a congruence rule to a term.
|
|
275
|
+
const congc = (
|
|
276
|
+
prover: (thm: Thm) => Thm | undefined,
|
|
277
|
+
maxt: number,
|
|
278
|
+
cong: Thm,
|
|
279
|
+
term: Term,
|
|
280
|
+
): Thm | undefined => {
|
|
281
|
+
const rthm = incrIndexesThm(maxt + 1, cong);
|
|
282
|
+
const rlhs = destEquals(stripImpConcl(rthm.prop))[0];
|
|
283
|
+
const env = matchPattern(rlhs, term, { tyenv: emptyTyEnv, tenv: emptyTEnv });
|
|
284
|
+
if (env === undefined) throw new MatchFailure();
|
|
285
|
+
const instantiated = instantiateMatch(env, renameBoundvars(rlhs, term, rthm));
|
|
286
|
+
const proved = prover(instantiated);
|
|
287
|
+
if (proved === undefined) return undefined;
|
|
288
|
+
const joined = checkConv(betaEtaConversion(term), proved);
|
|
289
|
+
if (joined === undefined) return undefined;
|
|
290
|
+
const [lhs, rhs] = destEquals(joined.prop);
|
|
291
|
+
return aconv(lhs, rhs) ? undefined : joined;
|
|
292
|
+
};
|
|
293
|
+
|
|
294
|
+
class MatchFailure {}
|
|
295
|
+
|
|
296
|
+
const transitive1 = (first: Thm | undefined, second: Thm | undefined) =>
|
|
297
|
+
first === undefined ? second : second === undefined ? first : transitive(first, second);
|
|
298
|
+
|
|
299
|
+
const instantiateABC = (rule: Thm, termA: Term, termB: Term, termC: Term) =>
|
|
300
|
+
instantiate(
|
|
301
|
+
[
|
|
302
|
+
{ variable: mkVar("A", 0, propT), term: termA },
|
|
303
|
+
{ variable: mkVar("B", 0, propT), term: termB },
|
|
304
|
+
{ variable: mkVar("C", 0, propT), term: termC },
|
|
305
|
+
],
|
|
306
|
+
rule,
|
|
307
|
+
);
|
|
308
|
+
|
|
309
|
+
export interface RewriteMode {
|
|
310
|
+
readonly simprem: boolean;
|
|
311
|
+
readonly useprem: boolean;
|
|
312
|
+
readonly mutsimp: boolean;
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
interface PremRules {
|
|
316
|
+
readonly rules: ReturnType<typeof extractSafeRrules>;
|
|
317
|
+
readonly asm: Thm | undefined;
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
// bottomc: bottom-up rewriting with the simpset of the context.
|
|
321
|
+
const bottomc = (mode: RewriteMode, prover: Prover, maxidx: number) => {
|
|
322
|
+
// Isabelle's botc recurses after each rewrite at the top and chains the steps on the way back,
|
|
323
|
+
// so a simpset that rewrites forever keeps every step until Isabelle runs out of memory. This
|
|
324
|
+
// loops and chains each step as it goes, which gives the same theorem, so such a simpset runs
|
|
325
|
+
// into the time limit holding only the latest one.
|
|
326
|
+
const botc = (skel: Term, context: SimpContext, term: Term): Thm | undefined => {
|
|
327
|
+
let chained: Thm | undefined;
|
|
328
|
+
let currentSkel = skel;
|
|
329
|
+
let current = term;
|
|
330
|
+
for (;;) {
|
|
331
|
+
if (currentSkel.kind === "Var") return chained;
|
|
332
|
+
const sub = subc(currentSkel, context, current);
|
|
333
|
+
const step = rewritec(prover, maxidx, context, sub === undefined ? current : rhsOf(sub));
|
|
334
|
+
if (step === undefined) return transitive1(chained, sub);
|
|
335
|
+
chained = transitive1(transitive1(chained, sub), step.thm);
|
|
336
|
+
currentSkel = step.skel;
|
|
337
|
+
current = rhsOf(step.thm);
|
|
338
|
+
}
|
|
339
|
+
};
|
|
340
|
+
const tryBotc = (context: SimpContext, term: Term) =>
|
|
341
|
+
botc(SKEL0, context, term) ?? reflexive(term);
|
|
342
|
+
const appc = (skel: Term, context: SimpContext, term: App): Thm | undefined => {
|
|
343
|
+
const funThm = botc(skelFun(skel), context, term.fun);
|
|
344
|
+
const argThm = botc(skelArg(skel), context, term.arg);
|
|
345
|
+
if (funThm !== undefined) return combination(funThm, argThm ?? reflexive(term.arg));
|
|
346
|
+
return argThm === undefined ? undefined : combination(reflexive(term.fun), argThm);
|
|
347
|
+
};
|
|
348
|
+
const subc = (skel: Term, context: SimpContext, term: Term): Thm | undefined => {
|
|
349
|
+
if (term.kind === "Abs") {
|
|
350
|
+
const variable = mkFree(boundName(context.bounds), term.type);
|
|
351
|
+
const body = substBound(variable, term.body);
|
|
352
|
+
const inner = botc(skelBody(skel), { ...context, bounds: context.bounds + 1 }, body);
|
|
353
|
+
return inner === undefined ? undefined : abstractRule(term.name, variable, inner);
|
|
354
|
+
}
|
|
355
|
+
if (term.kind !== "App") return undefined;
|
|
356
|
+
const head = term.fun;
|
|
357
|
+
if (head.kind === "App" && head.fun.kind === "Const" && head.fun.name === "Pure.imp")
|
|
358
|
+
return impc(term, context);
|
|
359
|
+
if (head.kind === "Abs") {
|
|
360
|
+
const beta = betaConversion(false, term);
|
|
361
|
+
const rest = subc(SKEL0, context, rhsOf(beta));
|
|
362
|
+
return rest === undefined ? beta : transitive(beta, rest);
|
|
363
|
+
}
|
|
364
|
+
const [headTerm, args] = stripComb(head);
|
|
365
|
+
const name = congName(headTerm);
|
|
366
|
+
const cong = name === undefined ? undefined : lookupTable(context.simpset.congs, congKey(name));
|
|
367
|
+
if (cong === undefined) return appc(skel, context, term);
|
|
368
|
+
try {
|
|
369
|
+
const thm = congc((rule) => prover(context, rule), maxidx, cong, term);
|
|
370
|
+
const result = thm === undefined ? term : rhsOf(thm);
|
|
371
|
+
const [left, right] = result.kind === "App" ? [result.fun, result.arg] : [term.fun, term.arg];
|
|
372
|
+
const congSkel = listComb(
|
|
373
|
+
headTerm,
|
|
374
|
+
args.map(() => mkVar("", 0, dummyT)),
|
|
375
|
+
);
|
|
376
|
+
const inner = botc(congSkel, context, left);
|
|
377
|
+
return inner === undefined ? thm : transitive1(thm, combination(inner, reflexive(right)));
|
|
378
|
+
} catch (error) {
|
|
379
|
+
if (error instanceof MatchFailure) return appc(skel, context, term);
|
|
380
|
+
throw error;
|
|
381
|
+
}
|
|
382
|
+
};
|
|
383
|
+
const impc = (term: Term, context: SimpContext) =>
|
|
384
|
+
mode.mutsimp ? mutImpc0([], term, [], context) : nonmutImpc(term, context);
|
|
385
|
+
const rulesOfPrem = (prem: Term, context: SimpContext): [PremRules, SimpContext] => {
|
|
386
|
+
if (maxidxOfTerm(prem) !== -1) return [{ rules: [], asm: undefined }, context];
|
|
387
|
+
const asm = assume(prem);
|
|
388
|
+
return [{ rules: extractSafeRrules(context, asm), asm }, context];
|
|
389
|
+
};
|
|
390
|
+
const addRrules = (rules: readonly PremRules[], context: SimpContext): SimpContext => {
|
|
391
|
+
const simpset = rules.reduce(
|
|
392
|
+
(current, prem) => prem.rules.reduce((inner, raw) => insertRrule(raw, inner), current),
|
|
393
|
+
context.simpset,
|
|
394
|
+
);
|
|
395
|
+
return {
|
|
396
|
+
...context,
|
|
397
|
+
simpset: addPrems(
|
|
398
|
+
rules.flatMap((prem) => (prem.asm === undefined ? [] : [prem.asm])),
|
|
399
|
+
simpset,
|
|
400
|
+
),
|
|
401
|
+
};
|
|
402
|
+
};
|
|
403
|
+
const disch = (isReordered: boolean, prem: Term, eq: Thm): Thm => {
|
|
404
|
+
const [lhs, rhs] = destEquals(eq.prop);
|
|
405
|
+
const discharged = impliesElim(instantiateABC(impCong, prem, lhs, rhs), impliesIntr(prem, eq));
|
|
406
|
+
if (!isReordered) return discharged;
|
|
407
|
+
const [premA, concl] = destImplies(lhs);
|
|
408
|
+
const [premB] = destImplies(rhs);
|
|
409
|
+
return transitive(
|
|
410
|
+
transitive(instantiateABC(swapPremsEq, premA, prem, concl), discharged),
|
|
411
|
+
instantiateABC(swapPremsEq, prem, premB, concl),
|
|
412
|
+
);
|
|
413
|
+
};
|
|
414
|
+
const rebuild = (
|
|
415
|
+
prems: readonly Term[],
|
|
416
|
+
concl: Term,
|
|
417
|
+
rules: readonly PremRules[],
|
|
418
|
+
context: SimpContext,
|
|
419
|
+
eq: Thm | undefined,
|
|
420
|
+
): Thm | undefined => {
|
|
421
|
+
if (prems.length === 0) return eq;
|
|
422
|
+
const [prem, ...rest] = prems;
|
|
423
|
+
const inner = addRrules(rules.slice(1).reverse(), context);
|
|
424
|
+
const nextConcl = mkImplies(prem, eq === undefined ? concl : rhsOf(eq));
|
|
425
|
+
const dprem = eq === undefined ? undefined : disch(false, prem, eq);
|
|
426
|
+
const step = rewritec(prover, maxidx, inner, nextConcl);
|
|
427
|
+
if (step === undefined) return rebuild(rest, nextConcl, rules.slice(1), context, dprem);
|
|
428
|
+
const joined = transitive1(dprem, step.thm);
|
|
429
|
+
if (joined === undefined) throw new TlaIsabelleError("ERROR", "rebuild");
|
|
430
|
+
return transitive1(
|
|
431
|
+
rest.reduce((current, item) => disch(false, item, current), joined),
|
|
432
|
+
mutImpc0([...rest].reverse(), rhsOf(step.thm), rules.slice(1).reverse(), context),
|
|
433
|
+
);
|
|
434
|
+
};
|
|
435
|
+
const mutImpc0 = (
|
|
436
|
+
prems: readonly Term[],
|
|
437
|
+
concl: Term,
|
|
438
|
+
rules: readonly PremRules[],
|
|
439
|
+
context: SimpContext,
|
|
440
|
+
): Thm | undefined => {
|
|
441
|
+
const newPrems = stripImpPrems(concl);
|
|
442
|
+
let current = context;
|
|
443
|
+
const newRules: PremRules[] = [];
|
|
444
|
+
for (const prem of newPrems) {
|
|
445
|
+
const [rule, next] = rulesOfPrem(prem, current);
|
|
446
|
+
newRules.push(rule);
|
|
447
|
+
current = next;
|
|
448
|
+
}
|
|
449
|
+
return mutImpc(
|
|
450
|
+
[...prems, ...newPrems],
|
|
451
|
+
stripImpConcl(concl),
|
|
452
|
+
[...rules, ...newRules],
|
|
453
|
+
[],
|
|
454
|
+
[],
|
|
455
|
+
[],
|
|
456
|
+
current,
|
|
457
|
+
-1,
|
|
458
|
+
-1,
|
|
459
|
+
);
|
|
460
|
+
};
|
|
461
|
+
const mutImpc = (
|
|
462
|
+
prems: readonly Term[],
|
|
463
|
+
concl: Term,
|
|
464
|
+
rules: readonly PremRules[],
|
|
465
|
+
donePrems: readonly Term[],
|
|
466
|
+
doneRules: readonly PremRules[],
|
|
467
|
+
eqns: readonly (Thm | undefined)[],
|
|
468
|
+
context: SimpContext,
|
|
469
|
+
changed: number,
|
|
470
|
+
count: number,
|
|
471
|
+
): Thm | undefined => {
|
|
472
|
+
if (prems.length === 0) {
|
|
473
|
+
const folded = eqns.reduce<Thm | undefined>(
|
|
474
|
+
(eq2, eq1, index) =>
|
|
475
|
+
transitive1(eq1, eq2 === undefined ? undefined : disch(false, donePrems[index], eq2)),
|
|
476
|
+
undefined,
|
|
477
|
+
);
|
|
478
|
+
const rest =
|
|
479
|
+
changed > 0
|
|
480
|
+
? mutImpc(
|
|
481
|
+
[...donePrems].reverse(),
|
|
482
|
+
concl,
|
|
483
|
+
[...doneRules].reverse(),
|
|
484
|
+
[],
|
|
485
|
+
[],
|
|
486
|
+
[],
|
|
487
|
+
context,
|
|
488
|
+
-1,
|
|
489
|
+
changed,
|
|
490
|
+
)
|
|
491
|
+
: rebuild(
|
|
492
|
+
donePrems,
|
|
493
|
+
concl,
|
|
494
|
+
doneRules,
|
|
495
|
+
context,
|
|
496
|
+
botc(SKEL0, addRrules([...doneRules].reverse(), context), concl),
|
|
497
|
+
);
|
|
498
|
+
return transitive1(folded, rest);
|
|
499
|
+
}
|
|
500
|
+
const [prem, ...otherPrems] = prems;
|
|
501
|
+
const [rule, ...otherRules] = rules;
|
|
502
|
+
const simplified =
|
|
503
|
+
count === 0
|
|
504
|
+
? undefined
|
|
505
|
+
: botc(SKEL0, addRrules([...[...doneRules].reverse(), ...otherRules], context), prem);
|
|
506
|
+
if (simplified === undefined)
|
|
507
|
+
return mutImpc(
|
|
508
|
+
otherPrems,
|
|
509
|
+
concl,
|
|
510
|
+
otherRules,
|
|
511
|
+
[prem, ...donePrems],
|
|
512
|
+
[rule, ...doneRules],
|
|
513
|
+
[undefined, ...eqns],
|
|
514
|
+
context,
|
|
515
|
+
changed,
|
|
516
|
+
count === 0 ? 0 : count - 1,
|
|
517
|
+
);
|
|
518
|
+
const newPrem = rhsOf(simplified);
|
|
519
|
+
const index =
|
|
520
|
+
1 +
|
|
521
|
+
simplified.hyps.reduce(
|
|
522
|
+
(result, hyp) =>
|
|
523
|
+
Math.max(
|
|
524
|
+
result,
|
|
525
|
+
otherPrems.findIndex((other) => aconv(other, hyp)),
|
|
526
|
+
),
|
|
527
|
+
-1,
|
|
528
|
+
);
|
|
529
|
+
const [newRule, next] = rulesOfPrem(newPrem, context);
|
|
530
|
+
const eqn = otherPrems
|
|
531
|
+
.slice(0, index)
|
|
532
|
+
.reduceRight(
|
|
533
|
+
(current, item) => disch(true, item, current),
|
|
534
|
+
impCongRule(simplified, reflexive(listImplies(otherPrems.slice(index), concl))),
|
|
535
|
+
);
|
|
536
|
+
return mutImpc(
|
|
537
|
+
otherPrems,
|
|
538
|
+
concl,
|
|
539
|
+
otherRules,
|
|
540
|
+
[newPrem, ...donePrems],
|
|
541
|
+
[newRule, ...doneRules],
|
|
542
|
+
[eqn, ...eqns],
|
|
543
|
+
next,
|
|
544
|
+
donePrems.length,
|
|
545
|
+
-1,
|
|
546
|
+
);
|
|
547
|
+
};
|
|
548
|
+
const nonmutImpc = (term: Term, context: SimpContext): Thm | undefined => {
|
|
549
|
+
const [prem, conc] = destImplies(term);
|
|
550
|
+
const first = mode.simprem ? botc(SKEL0, context, prem) : undefined;
|
|
551
|
+
const simplifiedPrem = first === undefined ? prem : rhsOf(first);
|
|
552
|
+
const inner = mode.useprem
|
|
553
|
+
? addRrules([rulesOfPrem(simplifiedPrem, context)[0]], context)
|
|
554
|
+
: context;
|
|
555
|
+
const second = botc(SKEL0, inner, conc);
|
|
556
|
+
if (second === undefined)
|
|
557
|
+
return first === undefined ? undefined : impCongRule(first, reflexive(conc));
|
|
558
|
+
const discharged = disch(false, simplifiedPrem, second);
|
|
559
|
+
return first === undefined
|
|
560
|
+
? discharged
|
|
561
|
+
: transitive(impCongRule(first, reflexive(conc)), discharged);
|
|
562
|
+
};
|
|
563
|
+
return tryBotc;
|
|
564
|
+
};
|
|
565
|
+
|
|
566
|
+
// Drule.flexflex_unique
|
|
567
|
+
const flexflexUnique = (limits: Limits, thm: Thm): Thm => {
|
|
568
|
+
if (thm.tpairs.length === 0) return thm;
|
|
569
|
+
const results = listOfSeq(flexflexRule(limits, thm));
|
|
570
|
+
const distinct = results.filter(
|
|
571
|
+
(result, index) => results.findIndex((other) => eqThm(other, result)) === index,
|
|
572
|
+
);
|
|
573
|
+
if (distinct.length === 1) return distinct[0];
|
|
574
|
+
throw new TlaIsabelleError(
|
|
575
|
+
"THM",
|
|
576
|
+
distinct.length === 0
|
|
577
|
+
? "flexflex_unique: impossible constraints"
|
|
578
|
+
: "flexflex_unique: multiple unifiers",
|
|
579
|
+
);
|
|
580
|
+
};
|
|
581
|
+
|
|
582
|
+
// rewrite_cterm: proves term == term' by rewriting.
|
|
583
|
+
export const rewriteCterm = (
|
|
584
|
+
mode: RewriteMode,
|
|
585
|
+
prover: Prover,
|
|
586
|
+
context: SimpContext,
|
|
587
|
+
term: Term,
|
|
588
|
+
): Thm => {
|
|
589
|
+
const inner = { ...context, simpset: { ...context.simpset, depth: context.simpset.depth + 1 } };
|
|
590
|
+
const wrapped: Prover = (current, thm) => {
|
|
591
|
+
const result = prover(current, thm);
|
|
592
|
+
return result === undefined ? undefined : flexflexUnique(context.limits, result);
|
|
593
|
+
};
|
|
594
|
+
return bottomc(mode, wrapped, maxidxOfTerm(term))(inner, term);
|
|
595
|
+
};
|
|
596
|
+
|
|
597
|
+
export const genericRewriteGoalTac =
|
|
598
|
+
(mode: RewriteMode, prover: Prover, context: SimpContext, index: number) =>
|
|
599
|
+
(state: Thm): Seq<Thm> =>
|
|
600
|
+
index > 0 && index <= nprems(state)
|
|
601
|
+
? singleSeq(gconvRule((term) => rewriteCterm(mode, prover, context, term), index, state))
|
|
602
|
+
: emptySeq;
|
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
// Ported from Isabelle2025's Pure/search.ML, iterative deepening and best-first search.
|
|
2
|
+
// Copyright (c) 1986-2025 University of Cambridge, Technische Universitaet Muenchen, and
|
|
3
|
+
// contributors, see LICENSE.
|
|
4
|
+
|
|
5
|
+
import { listOfSeq, makeSeq, seqOfList } from "./seq";
|
|
6
|
+
import { eqThm, hasFewerPrems, noTac, orElse, type GoalTactic, type Tactic } from "./tactical";
|
|
7
|
+
import { termOrd } from "./term-ord";
|
|
8
|
+
import type { Thm } from "./thm";
|
|
9
|
+
|
|
10
|
+
// DEEPEN: tries the tactic with limits from start up to limit in steps of increment.
|
|
11
|
+
export const deepen =
|
|
12
|
+
(
|
|
13
|
+
increment: number,
|
|
14
|
+
limit: number,
|
|
15
|
+
tactic: (depth: number) => GoalTactic,
|
|
16
|
+
start: number,
|
|
17
|
+
): GoalTactic =>
|
|
18
|
+
(index) =>
|
|
19
|
+
(state) =>
|
|
20
|
+
hasFewerPrems(index)(state) || start > limit
|
|
21
|
+
? noTac(state)
|
|
22
|
+
: orElse(
|
|
23
|
+
tactic(start)(index),
|
|
24
|
+
deepen(increment, limit, tactic, start + increment)(index),
|
|
25
|
+
)(state);
|
|
26
|
+
|
|
27
|
+
interface Sized {
|
|
28
|
+
readonly size: number;
|
|
29
|
+
readonly thm: Thm;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
// Thm_Heap's order: by size, then by proposition.
|
|
33
|
+
const compareSized = (left: Sized, right: Sized) =>
|
|
34
|
+
left.size - right.size || termOrd(left.thm.prop, right.thm.prop);
|
|
35
|
+
|
|
36
|
+
// BEST_FIRST: searches the states the tactic produces, smallest first, for one that satisfies
|
|
37
|
+
// the predicate. A sorted list stands in for Thm_Heap: both yield the least state under the same
|
|
38
|
+
// total order.
|
|
39
|
+
export const bestFirst =
|
|
40
|
+
(isSatisfied: (state: Thm) => boolean, size: (state: Thm) => number, tactic: Tactic): Tactic =>
|
|
41
|
+
(state) => {
|
|
42
|
+
const insert = (heap: readonly Sized[], thm: Thm): Sized[] => {
|
|
43
|
+
const entry = { size: size(thm), thm };
|
|
44
|
+
const position = heap.findIndex((other) => compareSized(entry, other) < 0);
|
|
45
|
+
return position === -1
|
|
46
|
+
? [...heap, entry]
|
|
47
|
+
: [...heap.slice(0, position), entry, ...heap.slice(position)];
|
|
48
|
+
};
|
|
49
|
+
const search = (): Thm[] | undefined => {
|
|
50
|
+
let news: readonly Thm[] = [state];
|
|
51
|
+
let heap: readonly Sized[] = [];
|
|
52
|
+
for (;;) {
|
|
53
|
+
const satisfied = news.filter(isSatisfied);
|
|
54
|
+
if (satisfied.length > 0) return satisfied;
|
|
55
|
+
const next = [...news].reverse().reduce(insert, heap);
|
|
56
|
+
if (next.length === 0) return undefined;
|
|
57
|
+
const best = next[0].thm;
|
|
58
|
+
const rest = next.slice(1);
|
|
59
|
+
const firstOther = rest.findIndex((entry) => !eqThm(best, entry.thm));
|
|
60
|
+
news = listOfSeq(tactic(best));
|
|
61
|
+
heap = firstOther === -1 ? [] : rest.slice(firstOther);
|
|
62
|
+
}
|
|
63
|
+
};
|
|
64
|
+
return makeSeq(() => {
|
|
65
|
+
const results = search();
|
|
66
|
+
return results === undefined ? undefined : seqOfList(results).pull();
|
|
67
|
+
});
|
|
68
|
+
};
|