tla-ts 0.0.4-dev.6dec595 → 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 +35 -1
- package/dist/index.d.ts +35 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +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/errors.ts +86 -0
- package/src/evaluate.ts +28 -7
- 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 +68 -25
- package/src/values.ts +8 -3
- 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,144 @@
|
|
|
1
|
+
// The check of unfolding a definition: a real definition from the input, or a pseudo-definition
|
|
2
|
+
// that Zenon reads off a hypothesis.
|
|
3
|
+
|
|
4
|
+
import type { Definition } from "../parse";
|
|
5
|
+
import {
|
|
6
|
+
app,
|
|
7
|
+
ensure,
|
|
8
|
+
isApp,
|
|
9
|
+
variable,
|
|
10
|
+
type Checker,
|
|
11
|
+
type Env,
|
|
12
|
+
type Operators,
|
|
13
|
+
type RuleSpec,
|
|
14
|
+
type Term,
|
|
15
|
+
} from "./terms";
|
|
16
|
+
|
|
17
|
+
// Checks that `unfolded` is `folded` with occurrences of the defined symbol replaced by its body,
|
|
18
|
+
// going through applications and negations as Zenon does.
|
|
19
|
+
const isUnfolding = (
|
|
20
|
+
checker: Checker,
|
|
21
|
+
definition: Definition,
|
|
22
|
+
folded: Term,
|
|
23
|
+
unfolded: Term,
|
|
24
|
+
isFormulaOnly: boolean,
|
|
25
|
+
isInTerm = false,
|
|
26
|
+
): boolean => {
|
|
27
|
+
if (checker.isSame(folded, unfolded)) return true;
|
|
28
|
+
const isApplication = folded.kind === "app" && folded.symbol === definition.symbol;
|
|
29
|
+
const isConstant = folded.kind === "var" && folded.symbol === definition.symbol;
|
|
30
|
+
if (isApplication || isConstant) {
|
|
31
|
+
if (isFormulaOnly && isInTerm) return false;
|
|
32
|
+
const actuals = folded.args;
|
|
33
|
+
const body = definition.body;
|
|
34
|
+
if (definition.params.length === 0 && isApplication && body.kind === "var")
|
|
35
|
+
return definition.kind === "real" && checker.isSame(unfolded, app(body.symbol, actuals));
|
|
36
|
+
if (definition.params.length !== actuals.length) return false;
|
|
37
|
+
const env: Env = new Map();
|
|
38
|
+
const operators: Operators = new Map();
|
|
39
|
+
definition.params.forEach((param, index) => {
|
|
40
|
+
env.set(param.symbol, { formula: actuals[index], env: new Map() });
|
|
41
|
+
operators.set(param.symbol, actuals[index]);
|
|
42
|
+
});
|
|
43
|
+
return checker.getKey(body, env, 0, operators) === checker.getTopKey(unfolded);
|
|
44
|
+
}
|
|
45
|
+
if (folded.kind !== unfolded.kind || folded.symbol !== unfolded.symbol) return false;
|
|
46
|
+
if (folded.kind !== "app" && folded.kind !== "not") return false;
|
|
47
|
+
if (folded.args.length !== unfolded.args.length) return false;
|
|
48
|
+
return folded.args.every((inner, index) =>
|
|
49
|
+
isUnfolding(
|
|
50
|
+
checker,
|
|
51
|
+
definition,
|
|
52
|
+
inner,
|
|
53
|
+
unfolded.args[index],
|
|
54
|
+
isFormulaOnly,
|
|
55
|
+
isInTerm || folded.kind === "app",
|
|
56
|
+
),
|
|
57
|
+
);
|
|
58
|
+
};
|
|
59
|
+
|
|
60
|
+
const getBound = (origin: Term) => {
|
|
61
|
+
const bound: string[] = [];
|
|
62
|
+
let matrix = origin;
|
|
63
|
+
while (matrix.kind === "all") {
|
|
64
|
+
bound.push(matrix.args[0].symbol);
|
|
65
|
+
matrix = matrix.args[1];
|
|
66
|
+
}
|
|
67
|
+
return { bound, matrix };
|
|
68
|
+
};
|
|
69
|
+
|
|
70
|
+
// A pseudo-definition stands for its hypothesis, \A params : f(params) = body or <=> body.
|
|
71
|
+
const isDefinedBy = (checker: Checker, definition: Definition, origin: Term) => {
|
|
72
|
+
const quantified = getBound(origin);
|
|
73
|
+
const bound = quantified.bound;
|
|
74
|
+
const matrix = quantified.matrix;
|
|
75
|
+
if (!isApp(matrix, "=", 2) && matrix.kind !== "equiv") return false;
|
|
76
|
+
const names = definition.params.map((param) => param.symbol);
|
|
77
|
+
if (new Set(names).size !== names.length || new Set(bound).size !== bound.length) return false;
|
|
78
|
+
if (names.length !== bound.length || names.some((name) => !bound.includes(name))) return false;
|
|
79
|
+
const params = definition.params;
|
|
80
|
+
const heads = [
|
|
81
|
+
app(
|
|
82
|
+
definition.symbol,
|
|
83
|
+
params.map((param) => variable(param.symbol)),
|
|
84
|
+
),
|
|
85
|
+
];
|
|
86
|
+
if (params.length === 0) heads.push(variable(definition.symbol));
|
|
87
|
+
const sides = matrix.args;
|
|
88
|
+
// The parameters are free in the head and the body, so compare them under the same names.
|
|
89
|
+
const env: Env = new Map(bound.map((name, index) => [name, index]));
|
|
90
|
+
const keyOf = (formula: Term) => checker.getKey(formula, env, bound.length);
|
|
91
|
+
const headKeys = heads.map(keyOf);
|
|
92
|
+
const bodyKey = keyOf(definition.body);
|
|
93
|
+
return (
|
|
94
|
+
(headKeys.includes(keyOf(sides[0])) && keyOf(sides[1]) === bodyKey) ||
|
|
95
|
+
(headKeys.includes(keyOf(sides[1])) && keyOf(sides[0]) === bodyKey)
|
|
96
|
+
);
|
|
97
|
+
};
|
|
98
|
+
|
|
99
|
+
const getFreeSymbols = (formula: Term, symbols: Set<string>) => {
|
|
100
|
+
if (formula.kind === "var" || formula.kind === "app") symbols.add(formula.symbol);
|
|
101
|
+
for (const inner of formula.args) getFreeSymbols(inner, symbols);
|
|
102
|
+
return symbols;
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
// Real definitions are sound when each symbol has one and they don't refer to themselves.
|
|
106
|
+
const isWellFounded = (definition: Definition, definitions: Definition[]) => {
|
|
107
|
+
const reals = definitions.filter((candidate) => candidate.kind === "real");
|
|
108
|
+
const bySymbol = new Map(reals.map((candidate) => [candidate.symbol, candidate]));
|
|
109
|
+
if (reals.filter((candidate) => candidate.symbol === definition.symbol).length !== 1)
|
|
110
|
+
return false;
|
|
111
|
+
const visiting = new Set<string>();
|
|
112
|
+
const visit = (current: Definition): boolean => {
|
|
113
|
+
if (visiting.has(current.symbol)) return false;
|
|
114
|
+
visiting.add(current.symbol);
|
|
115
|
+
const params = new Set(current.params.map((param) => param.symbol));
|
|
116
|
+
for (const symbol of getFreeSymbols(current.body, new Set())) {
|
|
117
|
+
const next = bySymbol.get(symbol);
|
|
118
|
+
if (!params.has(symbol) && next !== undefined && !visit(next)) return false;
|
|
119
|
+
}
|
|
120
|
+
visiting.delete(current.symbol);
|
|
121
|
+
return true;
|
|
122
|
+
};
|
|
123
|
+
return visit(definition);
|
|
124
|
+
};
|
|
125
|
+
|
|
126
|
+
export const getDefinitionSpec = (
|
|
127
|
+
definition: Definition,
|
|
128
|
+
args: [Term, Term],
|
|
129
|
+
checker: Checker,
|
|
130
|
+
): RuleSpec => {
|
|
131
|
+
const definitions = checker.context.definitions;
|
|
132
|
+
ensure(definitions.includes(definition));
|
|
133
|
+
// An equivalence only says the two sides have the same truth value, so it unfolds where a
|
|
134
|
+
// formula is expected, not inside a term.
|
|
135
|
+
const isEquivalence =
|
|
136
|
+
definition.kind === "pseudo" && getBound(definition.origin).matrix.kind === "equiv";
|
|
137
|
+
ensure(isUnfolding(checker, definition, args[0], args[1], isEquivalence));
|
|
138
|
+
if (definition.kind === "real") {
|
|
139
|
+
ensure(isWellFounded(definition, definitions));
|
|
140
|
+
return { premises: [args[0]], branches: [[args[1]]] };
|
|
141
|
+
}
|
|
142
|
+
ensure(isDefinedBy(checker, definition, definition.origin));
|
|
143
|
+
return { premises: [args[0], definition.origin], branches: [[args[1]]] };
|
|
144
|
+
};
|
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
// The checks of Zenon's rules for equality, strings and the relations that the hypotheses make
|
|
2
|
+
// reflexive, symmetric or transitive.
|
|
3
|
+
|
|
4
|
+
import type { PlainRuleName, Rule, RelationRuleName } from "../proof";
|
|
5
|
+
import {
|
|
6
|
+
app,
|
|
7
|
+
ensure,
|
|
8
|
+
equal,
|
|
9
|
+
expectApp,
|
|
10
|
+
expectKind,
|
|
11
|
+
expectNot,
|
|
12
|
+
getStringText,
|
|
13
|
+
instantiate,
|
|
14
|
+
not,
|
|
15
|
+
type Checker,
|
|
16
|
+
type RuleSpec,
|
|
17
|
+
type SpecTable,
|
|
18
|
+
type Term,
|
|
19
|
+
} from "./terms";
|
|
20
|
+
|
|
21
|
+
const relate = (symbol: string, left: Term, right: Term) => app(symbol, [left, right]);
|
|
22
|
+
|
|
23
|
+
// The two branches that the relation fails to link and the ends differ. The ends come from
|
|
24
|
+
// r(a, b) and ~r(c, d) in the order that Zenon's Trans or Trans_sym takes them.
|
|
25
|
+
const getTransitivitySpec = (
|
|
26
|
+
checker: Checker,
|
|
27
|
+
args: [Term, Term],
|
|
28
|
+
isSymmetric: boolean,
|
|
29
|
+
): RuleSpec => {
|
|
30
|
+
const negated = expectNot(args[1]);
|
|
31
|
+
const symbol = negated.symbol;
|
|
32
|
+
const positive = expectApp(args[0], symbol, 2);
|
|
33
|
+
const negative = expectApp(negated, symbol, 2);
|
|
34
|
+
checker.ensureRelation(symbol, isSymmetric ? ["transitive", "symmetric"] : ["transitive"]);
|
|
35
|
+
const left = positive[0];
|
|
36
|
+
const right = positive[1];
|
|
37
|
+
const negatedLeft = negative[0];
|
|
38
|
+
const negatedRight = negative[1];
|
|
39
|
+
const ends = isSymmetric
|
|
40
|
+
? [negatedRight, left, right, negatedLeft]
|
|
41
|
+
: [negatedLeft, left, right, negatedRight];
|
|
42
|
+
return {
|
|
43
|
+
premises: [args[0], args[1]],
|
|
44
|
+
branches: [
|
|
45
|
+
[not(equal(ends[0], ends[1])), not(relate(symbol, ends[0], ends[1]))],
|
|
46
|
+
[not(equal(ends[2], ends[3])), not(relate(symbol, ends[2], ends[3]))],
|
|
47
|
+
],
|
|
48
|
+
};
|
|
49
|
+
};
|
|
50
|
+
|
|
51
|
+
// a = b against ~r(c, d), in the order of Zenon's TransEq, TransEq_sym or TransEq2.
|
|
52
|
+
const getTransitiveEqualitySpec = (
|
|
53
|
+
checker: Checker,
|
|
54
|
+
args: [Term, Term, Term],
|
|
55
|
+
order: "trans_eq" | "trans_eq_sym" | "trans_eq2",
|
|
56
|
+
): RuleSpec => {
|
|
57
|
+
const left = args[0];
|
|
58
|
+
const right = args[1];
|
|
59
|
+
const negated = expectNot(args[2]);
|
|
60
|
+
const symbol = negated.symbol;
|
|
61
|
+
const negative = expectApp(negated, symbol, 2);
|
|
62
|
+
checker.ensureRelation(
|
|
63
|
+
symbol,
|
|
64
|
+
order === "trans_eq_sym" ? ["transitive", "symmetric"] : ["transitive"],
|
|
65
|
+
);
|
|
66
|
+
const negatedLeft = negative[0];
|
|
67
|
+
const negatedRight = negative[1];
|
|
68
|
+
const ends =
|
|
69
|
+
order === "trans_eq"
|
|
70
|
+
? [negatedLeft, left, right, negatedRight]
|
|
71
|
+
: order === "trans_eq_sym"
|
|
72
|
+
? [negatedRight, left, right, negatedLeft]
|
|
73
|
+
: [negatedLeft, right, left, negatedRight];
|
|
74
|
+
const first = not(relate(symbol, ends[0], ends[1]));
|
|
75
|
+
const second = not(relate(symbol, ends[2], ends[3]));
|
|
76
|
+
return {
|
|
77
|
+
premises: [equal(left, right), args[2]],
|
|
78
|
+
branches: [
|
|
79
|
+
[not(equal(ends[0], ends[1])), first],
|
|
80
|
+
[first, second],
|
|
81
|
+
[not(equal(ends[2], ends[3])), second],
|
|
82
|
+
],
|
|
83
|
+
};
|
|
84
|
+
};
|
|
85
|
+
|
|
86
|
+
// Of t1 = s1 and t2 = s2 with distinct strings s1 and s2, in the order of the rule's sides.
|
|
87
|
+
const getStringDifferenceSpec = (args: Term[], sides: "ll" | "lr" | "rl" | "rr"): RuleSpec => {
|
|
88
|
+
const term1 = args[0];
|
|
89
|
+
const string1 = args[1];
|
|
90
|
+
const term2 = args[2];
|
|
91
|
+
const string2 = args[3];
|
|
92
|
+
ensure(getStringText(string1) !== getStringText(string2));
|
|
93
|
+
return {
|
|
94
|
+
premises: [
|
|
95
|
+
sides[0] === "l" ? equal(term1, string1) : equal(string1, term1),
|
|
96
|
+
sides[1] === "l" ? equal(term2, string2) : equal(string2, term2),
|
|
97
|
+
],
|
|
98
|
+
branches: [[not(equal(term1, term2))]],
|
|
99
|
+
};
|
|
100
|
+
};
|
|
101
|
+
|
|
102
|
+
// Of f(a1, ..., an) and ~g(b1, ..., bn) with f and g the same: some argument differs.
|
|
103
|
+
const getArgumentsDifferSpec = (premises: Term[], left: Term, right: Term): RuleSpec => {
|
|
104
|
+
const leftArgs = expectKind(left, "app");
|
|
105
|
+
const rightArgs = expectKind(right, "app");
|
|
106
|
+
ensure(left.symbol === right.symbol && leftArgs.length === rightArgs.length);
|
|
107
|
+
return {
|
|
108
|
+
premises,
|
|
109
|
+
branches: leftArgs.map((inner, index) => [not(equal(inner, rightArgs[index]))]),
|
|
110
|
+
};
|
|
111
|
+
};
|
|
112
|
+
|
|
113
|
+
export const EQUALITY_RULES = {
|
|
114
|
+
not_equal: (args) => getArgumentsDifferSpec([not(equal(args[0], args[1]))], args[0], args[1]),
|
|
115
|
+
p_not_p: (args) => getArgumentsDifferSpec([args[0], args[1]], args[0], expectNot(args[1])),
|
|
116
|
+
trans: (args, checker) => getTransitivitySpec(checker, args, false),
|
|
117
|
+
trans_sym: (args, checker) => getTransitivitySpec(checker, args, true),
|
|
118
|
+
trans_eq: (args, checker) => getTransitiveEqualitySpec(checker, args, "trans_eq"),
|
|
119
|
+
trans_eq_sym: (args, checker) => getTransitiveEqualitySpec(checker, args, "trans_eq_sym"),
|
|
120
|
+
trans_eq2: (args, checker) => getTransitiveEqualitySpec(checker, args, "trans_eq2"),
|
|
121
|
+
congruence_lr: (args) => {
|
|
122
|
+
ensure(args[0].kind === "lam");
|
|
123
|
+
return {
|
|
124
|
+
premises: [instantiate(args[0], args[1]), equal(args[1], args[2])],
|
|
125
|
+
branches: [[instantiate(args[0], args[2])]],
|
|
126
|
+
};
|
|
127
|
+
},
|
|
128
|
+
congruence_rl: (args) => {
|
|
129
|
+
ensure(args[0].kind === "lam");
|
|
130
|
+
return {
|
|
131
|
+
premises: [instantiate(args[0], args[1]), equal(args[2], args[1])],
|
|
132
|
+
branches: [[instantiate(args[0], args[2])]],
|
|
133
|
+
};
|
|
134
|
+
},
|
|
135
|
+
stringequal: (args) => {
|
|
136
|
+
ensure(getStringText(app("$string", [args[0]])) !== getStringText(app("$string", [args[1]])));
|
|
137
|
+
return {
|
|
138
|
+
premises: [equal(app("$string", [args[0]]), app("$string", [args[1]]))],
|
|
139
|
+
branches: [],
|
|
140
|
+
};
|
|
141
|
+
},
|
|
142
|
+
stringdiffll: (args) => getStringDifferenceSpec(args, "ll"),
|
|
143
|
+
stringdifflr: (args) => getStringDifferenceSpec(args, "lr"),
|
|
144
|
+
stringdiffrl: (args) => getStringDifferenceSpec(args, "rl"),
|
|
145
|
+
stringdiffrr: (args) => getStringDifferenceSpec(args, "rr"),
|
|
146
|
+
} satisfies Partial<SpecTable<PlainRuleName>>;
|
|
147
|
+
|
|
148
|
+
export const getRelationRuleSpec = (
|
|
149
|
+
rule: Extract<Rule<Term>, { name: RelationRuleName }>,
|
|
150
|
+
checker: Checker,
|
|
151
|
+
): RuleSpec => {
|
|
152
|
+
const symbol = rule.relation;
|
|
153
|
+
switch (rule.name) {
|
|
154
|
+
case "close_refl":
|
|
155
|
+
checker.ensureRelation(symbol, ["reflexive"]);
|
|
156
|
+
return { premises: [not(relate(symbol, rule.args[0], rule.args[0]))], branches: [] };
|
|
157
|
+
case "close_sym":
|
|
158
|
+
checker.ensureRelation(symbol, ["symmetric"]);
|
|
159
|
+
return {
|
|
160
|
+
premises: [
|
|
161
|
+
relate(symbol, rule.args[0], rule.args[1]),
|
|
162
|
+
not(relate(symbol, rule.args[1], rule.args[0])),
|
|
163
|
+
],
|
|
164
|
+
branches: [],
|
|
165
|
+
};
|
|
166
|
+
case "refl":
|
|
167
|
+
checker.ensureRelation(symbol, ["reflexive"]);
|
|
168
|
+
return {
|
|
169
|
+
premises: [not(relate(symbol, rule.args[0], rule.args[1]))],
|
|
170
|
+
branches: [[not(equal(rule.args[0], rule.args[1]))]],
|
|
171
|
+
};
|
|
172
|
+
case "p_not_p_sym": {
|
|
173
|
+
checker.ensureRelation(symbol, ["symmetric"]);
|
|
174
|
+
const left = expectApp(rule.args[0], symbol, 2);
|
|
175
|
+
const right = expectApp(expectNot(rule.args[1]), symbol, 2);
|
|
176
|
+
return {
|
|
177
|
+
premises: [rule.args[0], rule.args[1]],
|
|
178
|
+
branches: [[not(equal(left[1], right[0]))], [not(equal(left[0], right[1]))]],
|
|
179
|
+
};
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
};
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
// The checks of the TLA+ extension's rules for functions, after the lemmas in Zenon.thy that justify
|
|
2
|
+
// them.
|
|
3
|
+
|
|
4
|
+
import type { PlainRuleName } from "../proof";
|
|
5
|
+
import {
|
|
6
|
+
and,
|
|
7
|
+
app,
|
|
8
|
+
domain,
|
|
9
|
+
equal,
|
|
10
|
+
equiv,
|
|
11
|
+
expectApp,
|
|
12
|
+
expectNot,
|
|
13
|
+
fapply,
|
|
14
|
+
imply,
|
|
15
|
+
member,
|
|
16
|
+
not,
|
|
17
|
+
type SpecTable,
|
|
18
|
+
type Term,
|
|
19
|
+
} from "./terms";
|
|
20
|
+
|
|
21
|
+
// ~isAFcn(f) where f is built by a function constructor closes the branch.
|
|
22
|
+
const getNotFunctionSpec = (formula: Term, constructor: string, arity: number) => {
|
|
23
|
+
expectApp(expectApp(expectNot(formula), "TLA.isAFcn", 1)[0], constructor, arity);
|
|
24
|
+
return { premises: [formula], branches: [] };
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
export const FUNCTION_RULES = {
|
|
28
|
+
notisafcn_fcn: (args) => getNotFunctionSpec(args[0], "TLA.Fcn", 2),
|
|
29
|
+
notisafcn_except: (args) => getNotFunctionSpec(args[0], "TLA.except", 3),
|
|
30
|
+
notisafcn_onearg: (args) => getNotFunctionSpec(args[0], "TLA.oneArg", 2),
|
|
31
|
+
notisafcn_extend: (args) => getNotFunctionSpec(args[0], "TLA.extend", 2),
|
|
32
|
+
funequal: (args, checker) => {
|
|
33
|
+
const sides = expectApp(args[0], "=", 2);
|
|
34
|
+
const left = sides[0];
|
|
35
|
+
const right = sides[1];
|
|
36
|
+
const result = and(
|
|
37
|
+
and(
|
|
38
|
+
equiv(app("TLA.isAFcn", [left]), app("TLA.isAFcn", [right])),
|
|
39
|
+
equal(domain(left), domain(right)),
|
|
40
|
+
),
|
|
41
|
+
checker.bind("all", "", (bound) => equal(fapply(left, bound), fapply(right, bound))),
|
|
42
|
+
);
|
|
43
|
+
return { premises: [args[0]], branches: [[result]] };
|
|
44
|
+
},
|
|
45
|
+
notfunequal: (args, checker) => {
|
|
46
|
+
const sides = expectApp(expectNot(args[0]), "=", 2);
|
|
47
|
+
const left = sides[0];
|
|
48
|
+
const right = sides[1];
|
|
49
|
+
const result = not(
|
|
50
|
+
and(
|
|
51
|
+
and(
|
|
52
|
+
and(app("TLA.isAFcn", [left]), app("TLA.isAFcn", [right])),
|
|
53
|
+
equal(domain(left), domain(right)),
|
|
54
|
+
),
|
|
55
|
+
checker.bind("all", "", (bound) =>
|
|
56
|
+
imply(member(bound, domain(right)), equal(fapply(left, bound), fapply(right, bound))),
|
|
57
|
+
),
|
|
58
|
+
),
|
|
59
|
+
);
|
|
60
|
+
return { premises: [args[0]], branches: [[result]] };
|
|
61
|
+
},
|
|
62
|
+
} satisfies Partial<SpecTable<PlainRuleName>>;
|
|
@@ -0,0 +1,125 @@
|
|
|
1
|
+
// Comparing formulas by their own alpha-equivalence: each formula prints to a key in which a bound
|
|
2
|
+
// variable is the number of binders between it and its own.
|
|
3
|
+
|
|
4
|
+
import { term, UncheckedError, variable, type Env, type Operators, type Term } from "./terms";
|
|
5
|
+
|
|
6
|
+
export const createKeys = () => {
|
|
7
|
+
const freeNames = new WeakMap<Term, Set<string>>();
|
|
8
|
+
const topKeys = new WeakMap<Term, string>();
|
|
9
|
+
let freshCount = 0;
|
|
10
|
+
|
|
11
|
+
// The variables and applied symbols that a formula doesn't bind, which are the names an
|
|
12
|
+
// environment can change.
|
|
13
|
+
const getFreeNames = (formula: Term): Set<string> => {
|
|
14
|
+
const cached = freeNames.get(formula);
|
|
15
|
+
if (cached !== undefined) return cached;
|
|
16
|
+
const names = new Set<string>();
|
|
17
|
+
const bound =
|
|
18
|
+
formula.kind === "subst"
|
|
19
|
+
? formula.symbol
|
|
20
|
+
: formula.kind === "all" ||
|
|
21
|
+
formula.kind === "ex" ||
|
|
22
|
+
formula.kind === "tau" ||
|
|
23
|
+
formula.kind === "lam"
|
|
24
|
+
? formula.args[0].symbol
|
|
25
|
+
: undefined;
|
|
26
|
+
if (formula.kind === "var" || formula.kind === "app") names.add(formula.symbol);
|
|
27
|
+
if (formula.kind !== "meta")
|
|
28
|
+
formula.args.forEach((inner, index) => {
|
|
29
|
+
for (const name of getFreeNames(inner))
|
|
30
|
+
if (name !== bound || (formula.kind === "subst" && index === 1)) names.add(name);
|
|
31
|
+
});
|
|
32
|
+
freeNames.set(formula, names);
|
|
33
|
+
return names;
|
|
34
|
+
};
|
|
35
|
+
|
|
36
|
+
// `operators` replaces applied symbols, for definitions whose parameters are operators.
|
|
37
|
+
const getKey = (formula: Term, env: Env, depth: number, operators?: Operators): string => {
|
|
38
|
+
for (const name of getFreeNames(formula))
|
|
39
|
+
if (env.has(name) || operators?.has(name) === true)
|
|
40
|
+
return getEnvKey(formula, env, depth, operators);
|
|
41
|
+
return getTopKey(formula);
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
const getEnvKey = (formula: Term, env: Env, depth: number, operators?: Operators): string => {
|
|
45
|
+
const recurse = (inner: Term) => getKey(inner, env, depth, operators);
|
|
46
|
+
const named = (tag: string, name: string) => `${tag}${name.length}:${name}`;
|
|
47
|
+
const without = (name: string) => {
|
|
48
|
+
if (operators === undefined || !operators.has(name)) return operators;
|
|
49
|
+
const inner = new Map(operators);
|
|
50
|
+
inner.delete(name);
|
|
51
|
+
return inner;
|
|
52
|
+
};
|
|
53
|
+
switch (formula.kind) {
|
|
54
|
+
case "var": {
|
|
55
|
+
const binding = env.get(formula.symbol);
|
|
56
|
+
if (binding === undefined) return named("v", formula.symbol);
|
|
57
|
+
if (typeof binding === "number") return `#${depth - binding}`;
|
|
58
|
+
return getKey(binding.formula, binding.env, depth, binding.operators);
|
|
59
|
+
}
|
|
60
|
+
case "meta":
|
|
61
|
+
return `m(${getTopKey(formula.args[0])})`;
|
|
62
|
+
case "true":
|
|
63
|
+
return "T";
|
|
64
|
+
case "false":
|
|
65
|
+
return "F";
|
|
66
|
+
case "subst": {
|
|
67
|
+
const inner = new Map(env);
|
|
68
|
+
inner.set(formula.symbol, { formula: formula.args[1], env, operators });
|
|
69
|
+
return getKey(formula.args[0], inner, depth, without(formula.symbol));
|
|
70
|
+
}
|
|
71
|
+
case "app": {
|
|
72
|
+
const args = formula.args.map(recurse);
|
|
73
|
+
if (formula.symbol === "$notequiv" && args.length === 2)
|
|
74
|
+
return `~(equiv(${args[0]},${args[1]}))`;
|
|
75
|
+
const operator = operators?.get(formula.symbol);
|
|
76
|
+
if (operator === undefined) return `${named("a", formula.symbol)}(${args.join(",")})`;
|
|
77
|
+
if (operator.kind === "lam" && args.length === 1) {
|
|
78
|
+
const inner: Env = new Map([
|
|
79
|
+
[operator.args[0].symbol, { formula: formula.args[0], env, operators }],
|
|
80
|
+
]);
|
|
81
|
+
return getKey(operator.args[1], inner, depth);
|
|
82
|
+
}
|
|
83
|
+
if (operator.kind === "var") return `${named("a", operator.symbol)}(${args.join(",")})`;
|
|
84
|
+
if (operator.kind === "app")
|
|
85
|
+
return `${named("a", operator.symbol)}(${[
|
|
86
|
+
...operator.args.map((inner) => getKey(inner, new Map(), depth)),
|
|
87
|
+
...args,
|
|
88
|
+
].join(",")})`;
|
|
89
|
+
throw new UncheckedError();
|
|
90
|
+
}
|
|
91
|
+
case "not":
|
|
92
|
+
return `~(${recurse(formula.args[0])})`;
|
|
93
|
+
case "and":
|
|
94
|
+
case "or":
|
|
95
|
+
case "imply":
|
|
96
|
+
case "equiv":
|
|
97
|
+
return `${formula.kind}(${recurse(formula.args[0])},${recurse(formula.args[1])})`;
|
|
98
|
+
default: {
|
|
99
|
+
const inner = new Map(env);
|
|
100
|
+
inner.set(formula.args[0].symbol, depth);
|
|
101
|
+
const body = getKey(formula.args[1], inner, depth + 1, without(formula.args[0].symbol));
|
|
102
|
+
return `${formula.kind}${named("", formula.symbol)}{${body}}`;
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
};
|
|
106
|
+
|
|
107
|
+
const getTopKey = (formula: Term) => {
|
|
108
|
+
const cached = topKeys.get(formula);
|
|
109
|
+
if (cached !== undefined) return cached;
|
|
110
|
+
// Keys count binders from the variable, so a formula's key doesn't depend on where it sits.
|
|
111
|
+
const key = getEnvKey(formula, new Map(), 0);
|
|
112
|
+
topKeys.set(formula, key);
|
|
113
|
+
return key;
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
return {
|
|
117
|
+
getKey,
|
|
118
|
+
getTopKey,
|
|
119
|
+
isSame: (left: Term, right: Term) => getTopKey(left) === getTopKey(right),
|
|
120
|
+
bind: (kind: "all" | "ex", type: string, build: (bound: Term) => Term) => {
|
|
121
|
+
const bound = variable(`\u0000${freshCount++}`);
|
|
122
|
+
return term(kind, type, [bound, build(bound)]);
|
|
123
|
+
},
|
|
124
|
+
};
|
|
125
|
+
};
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
// The checks of Zenon's rules for connectives, quantifiers and the cut.
|
|
2
|
+
|
|
3
|
+
import type { PlainRuleName } from "../proof";
|
|
4
|
+
import {
|
|
5
|
+
and,
|
|
6
|
+
equiv,
|
|
7
|
+
expectKind,
|
|
8
|
+
expectNot,
|
|
9
|
+
FALSE,
|
|
10
|
+
imply,
|
|
11
|
+
instantiate,
|
|
12
|
+
not,
|
|
13
|
+
or,
|
|
14
|
+
term,
|
|
15
|
+
TRUE,
|
|
16
|
+
type SpecTable,
|
|
17
|
+
type Term,
|
|
18
|
+
} from "./terms";
|
|
19
|
+
|
|
20
|
+
const getConjuncts = (formula: Term): Term[] => {
|
|
21
|
+
if (formula.kind === "and") return formula.args.flatMap(getConjuncts);
|
|
22
|
+
if (formula.kind !== "not") return [formula];
|
|
23
|
+
const operand = formula.args[0];
|
|
24
|
+
if (operand.kind === "or") return operand.args.flatMap((inner) => getConjuncts(not(inner)));
|
|
25
|
+
if (operand.kind === "imply")
|
|
26
|
+
return [...getConjuncts(operand.args[0]), ...getConjuncts(not(operand.args[1]))];
|
|
27
|
+
if (operand.kind === "not") return getConjuncts(operand.args[0]);
|
|
28
|
+
return [formula];
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
const getDisjuncts = (formula: Term): Term[] => {
|
|
32
|
+
if (formula.kind === "or") return formula.args.flatMap(getDisjuncts);
|
|
33
|
+
if (formula.kind === "imply")
|
|
34
|
+
return [...getDisjuncts(not(formula.args[0])), ...getDisjuncts(formula.args[1])];
|
|
35
|
+
if (formula.kind !== "not") return [formula];
|
|
36
|
+
const operand = formula.args[0];
|
|
37
|
+
if (operand.kind === "and") return operand.args.flatMap((inner) => getDisjuncts(not(inner)));
|
|
38
|
+
if (operand.kind === "not") return getDisjuncts(operand.args[0]);
|
|
39
|
+
return [formula];
|
|
40
|
+
};
|
|
41
|
+
|
|
42
|
+
// The witness of an existential: Hilbert's epsilon of its body.
|
|
43
|
+
const getWitness = (exists: Term) => instantiate(exists, term("tau", exists.symbol, exists.args));
|
|
44
|
+
|
|
45
|
+
export const PROPOSITIONAL_RULES = {
|
|
46
|
+
close: (args) => ({ premises: [args[0], not(args[0])], branches: [] }),
|
|
47
|
+
false: () => ({ premises: [FALSE], branches: [] }),
|
|
48
|
+
not_true: () => ({ premises: [not(TRUE)], branches: [] }),
|
|
49
|
+
conj_tree: (args) => ({ premises: [args[0]], branches: [getConjuncts(args[0])] }),
|
|
50
|
+
disj_tree: (args) => ({
|
|
51
|
+
premises: [args[0]],
|
|
52
|
+
branches: getDisjuncts(args[0]).map((inner) => [inner]),
|
|
53
|
+
}),
|
|
54
|
+
and: (args) => ({ premises: [and(args[0], args[1])], branches: [[args[0], args[1]]] }),
|
|
55
|
+
not_not: (args) => ({ premises: [not(not(args[0]))], branches: [[args[0]]] }),
|
|
56
|
+
not_or: (args) => ({
|
|
57
|
+
premises: [not(or(args[0], args[1]))],
|
|
58
|
+
branches: [[not(args[0]), not(args[1])]],
|
|
59
|
+
}),
|
|
60
|
+
not_impl: (args) => ({
|
|
61
|
+
premises: [not(imply(args[0], args[1]))],
|
|
62
|
+
branches: [[args[0], not(args[1])]],
|
|
63
|
+
}),
|
|
64
|
+
or: (args) => ({ premises: [or(args[0], args[1])], branches: [[args[0]], [args[1]]] }),
|
|
65
|
+
impl: (args) => ({ premises: [imply(args[0], args[1])], branches: [[not(args[0])], [args[1]]] }),
|
|
66
|
+
equiv: (args) => ({
|
|
67
|
+
premises: [equiv(args[0], args[1])],
|
|
68
|
+
branches: [
|
|
69
|
+
[not(args[0]), not(args[1])],
|
|
70
|
+
[args[0], args[1]],
|
|
71
|
+
],
|
|
72
|
+
}),
|
|
73
|
+
not_and: (args) => ({
|
|
74
|
+
premises: [not(and(args[0], args[1]))],
|
|
75
|
+
branches: [[not(args[0])], [not(args[1])]],
|
|
76
|
+
}),
|
|
77
|
+
not_equiv: (args) => ({
|
|
78
|
+
premises: [not(equiv(args[0], args[1]))],
|
|
79
|
+
branches: [
|
|
80
|
+
[not(args[0]), args[1]],
|
|
81
|
+
[args[0], not(args[1])],
|
|
82
|
+
],
|
|
83
|
+
}),
|
|
84
|
+
ex: (args) => {
|
|
85
|
+
expectKind(args[0], "ex");
|
|
86
|
+
return { premises: [args[0]], branches: [[getWitness(args[0])]] };
|
|
87
|
+
},
|
|
88
|
+
not_all_ex: (args) => {
|
|
89
|
+
const forAll = expectNot(args[0]);
|
|
90
|
+
expectKind(forAll, "all");
|
|
91
|
+
const negated = term("ex", forAll.symbol, [forAll.args[0], not(forAll.args[1])]);
|
|
92
|
+
return { premises: [args[0]], branches: [[getWitness(negated), negated]] };
|
|
93
|
+
},
|
|
94
|
+
all: (args) => {
|
|
95
|
+
expectKind(args[0], "all");
|
|
96
|
+
return { premises: [args[0]], branches: [[instantiate(args[0], args[1])]] };
|
|
97
|
+
},
|
|
98
|
+
not_ex: (args) => {
|
|
99
|
+
const exists = expectNot(args[0]);
|
|
100
|
+
expectKind(exists, "ex");
|
|
101
|
+
return { premises: [args[0]], branches: [[not(instantiate(exists, args[1]))]] };
|
|
102
|
+
},
|
|
103
|
+
cut: (args) => ({ premises: [], branches: [[args[0]], [not(args[0])]] }),
|
|
104
|
+
} satisfies Partial<SpecTable<PlainRuleName>>;
|