tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.c4929d7
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 +27 -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 +996 -0
- package/dist/prove.js +996 -0
- package/dist/run-cli.cjs +37 -47
- package/dist/run-cli.js +37 -47
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +38 -44
- package/dist/transfer.js +38 -44
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +21 -12
- package/src/check.ts +1 -0
- package/src/codegen.ts +5 -3
- 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} +265 -55
- package/src/{obligation-anon.ts → obligations/anon.ts} +47 -37
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +38 -61
- package/src/{obligation-expression.ts → obligations/expression.ts} +78 -45
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +147 -74
- package/src/{obligations.ts → obligations/index.ts} +29 -13
- package/src/{obligation-levels.ts → obligations/levels.ts} +14 -5
- package/src/{obligation-module.ts → obligations/module.ts} +56 -33
- package/src/obligations/pickle.ts +98 -0
- package/src/obligations/pragma.ts +189 -0
- package/src/{obligation-printer.ts → obligations/printer.ts} +22 -80
- package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
- package/src/{obligation-source.ts → obligations/source.ts} +159 -97
- package/src/obligations/temporal.ts +319 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +2 -18
- package/src/parallel.ts +10 -43
- package/src/prove/decide-pool.ts +100 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/isabelle/LICENSE +36 -0
- package/src/prove/isabelle/LICENSE-tlapm +26 -0
- package/src/prove/isabelle/decide.ts +47 -0
- package/src/prove/isabelle/encode.ts +503 -0
- package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
- package/src/prove/isabelle/isar/method.ts +367 -0
- package/src/prove/isabelle/isar/proof.ts +28 -0
- package/src/prove/isabelle/isar/statement.ts +57 -0
- package/src/prove/isabelle/isar/theory.ts +192 -0
- package/src/prove/isabelle/isar/type-check.ts +278 -0
- package/src/prove/isabelle/provers/blast/blast.ts +258 -0
- package/src/prove/isabelle/provers/blast/branch.ts +322 -0
- package/src/prove/isabelle/provers/blast/prove.ts +347 -0
- package/src/prove/isabelle/provers/blast/rules.ts +330 -0
- package/src/prove/isabelle/provers/blast/state.ts +180 -0
- package/src/prove/isabelle/provers/blast/term.ts +547 -0
- package/src/prove/isabelle/provers/clasimp.ts +150 -0
- package/src/prove/isabelle/provers/classical.ts +389 -0
- package/src/prove/isabelle/provers/hypsubst.ts +441 -0
- package/src/prove/isabelle/pure/bicompose.ts +174 -0
- package/src/prove/isabelle/pure/consts.ts +32 -0
- package/src/prove/isabelle/pure/conv.ts +79 -0
- package/src/prove/isabelle/pure/drule.ts +264 -0
- package/src/prove/isabelle/pure/envir.ts +363 -0
- package/src/prove/isabelle/pure/goal.ts +53 -0
- package/src/prove/isabelle/pure/interrupt.ts +16 -0
- package/src/prove/isabelle/pure/list.ts +12 -0
- package/src/prove/isabelle/pure/logic.ts +402 -0
- package/src/prove/isabelle/pure/name.ts +110 -0
- package/src/prove/isabelle/pure/net.ts +262 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +650 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
- package/src/prove/isabelle/pure/rewriter.ts +602 -0
- package/src/prove/isabelle/pure/search.ts +68 -0
- package/src/prove/isabelle/pure/seq.ts +156 -0
- package/src/prove/isabelle/pure/simplifier.ts +112 -0
- package/src/prove/isabelle/pure/table.ts +208 -0
- package/src/prove/isabelle/pure/tactic.ts +276 -0
- package/src/prove/isabelle/pure/tactical.ts +347 -0
- package/src/prove/isabelle/pure/term-ord.ts +159 -0
- package/src/prove/isabelle/pure/term.ts +808 -0
- package/src/prove/isabelle/pure/thm.ts +806 -0
- package/src/prove/isabelle/pure/type.ts +133 -0
- package/src/prove/isabelle/pure/unify.ts +753 -0
- package/src/prove/isabelle/pure/variable.ts +25 -0
- package/src/prove/isabelle/tla/classical-setup.ts +101 -0
- package/src/prove/isabelle/tla/context.ts +74 -0
- package/src/prove/isabelle/tla/logic-data.ts +5 -0
- package/src/prove/isabelle/tla/logic.ts +215 -0
- package/src/prove/isabelle/tla/simpdata.ts +241 -0
- package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
- package/src/prove/ocaml.ts +22 -0
- package/src/prove/prep/action.ts +521 -0
- package/src/prove/prep/defs.ts +33 -0
- package/src/prove/prep/elab.ts +156 -0
- package/src/prove/prep/enabled-axioms.ts +189 -0
- package/src/prove/prep/enabled.ts +43 -0
- package/src/prove/prep/fingerprint.ts +388 -0
- package/src/prove/prep/flatten.ts +70 -0
- package/src/prove/prep/level-comparison.ts +557 -0
- package/src/prove/prep/md5.ts +67 -0
- package/src/prove/prep/pragma.ts +221 -0
- package/src/prove/prep/trivial.ts +22 -0
- package/src/prove/prove-worker.ts +25 -0
- package/src/prove/prove.ts +505 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +256 -0
- package/src/prove/ptl/sat.ts +151 -0
- package/src/prove/ptl/tableau.ts +276 -0
- package/src/prove/smt/axiomatize.ts +69 -0
- package/src/prove/smt/axioms.ts +222 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +166 -0
- package/src/prove/smt/extensionality.ts +65 -0
- package/src/prove/smt/flatten.ts +112 -0
- package/src/prove/smt/format.ts +154 -0
- package/src/prove/smt/instances.ts +182 -0
- package/src/prove/smt/rewrite.ts +773 -0
- package/src/prove/smt/simplify.ts +57 -0
- package/src/prove/smt/solver/act-cache.ts +265 -0
- package/src/prove/smt/solver/arith-rewriter.ts +962 -0
- package/src/prove/smt/solver/array.ts +22 -0
- package/src/prove/smt/solver/asserted-formulas.ts +469 -0
- package/src/prove/smt/solver/ast-lt.ts +157 -0
- package/src/prove/smt/solver/ast-util.ts +147 -0
- package/src/prove/smt/solver/ast.ts +1315 -0
- package/src/prove/smt/solver/auf-solver.ts +572 -0
- package/src/prove/smt/solver/case-split-queue.ts +178 -0
- package/src/prove/smt/solver/cg-table.ts +175 -0
- package/src/prove/smt/solver/clause.ts +276 -0
- package/src/prove/smt/solver/conflict-resolution.ts +343 -0
- package/src/prove/smt/solver/context.ts +1292 -0
- package/src/prove/smt/solver/ctx-simplify.ts +334 -0
- package/src/prove/smt/solver/der.ts +224 -0
- package/src/prove/smt/solver/dyn-ack.ts +141 -0
- package/src/prove/smt/solver/e-matching.ts +659 -0
- package/src/prove/smt/solver/enode.ts +259 -0
- package/src/prove/smt/solver/expr-ref.ts +21 -0
- package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
- package/src/prove/smt/solver/fingerprints.ts +92 -0
- package/src/prove/smt/solver/flat-literals.ts +51 -0
- package/src/prove/smt/solver/goal.ts +138 -0
- package/src/prove/smt/solver/hash.ts +173 -0
- package/src/prove/smt/solver/hashtable.ts +166 -0
- package/src/prove/smt/solver/internalizer.ts +1381 -0
- package/src/prove/smt/solver/lbool.ts +5 -0
- package/src/prove/smt/solver/literal.ts +24 -0
- package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
- package/src/prove/smt/solver/lp/constraints.ts +78 -0
- package/src/prove/smt/solver/lp/containers.ts +296 -0
- package/src/prove/smt/solver/lp/core-solver.ts +504 -0
- package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
- package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
- package/src/prove/smt/solver/lp/dependency.ts +51 -0
- package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
- package/src/prove/smt/solver/lp/explanation.ts +46 -0
- package/src/prove/smt/solver/lp/gomory.ts +255 -0
- package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
- package/src/prove/smt/solver/lp/hnf.ts +281 -0
- package/src/prove/smt/solver/lp/int-cube.ts +295 -0
- package/src/prove/smt/solver/lp/int-solver.ts +514 -0
- package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
- package/src/prove/smt/solver/lp/lar-term.ts +62 -0
- package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
- package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
- package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
- package/src/prove/smt/solver/lp/nex.ts +120 -0
- package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
- package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
- package/src/prove/smt/solver/lp/nla-core.ts +968 -0
- package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
- package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
- package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
- package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
- package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
- package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
- package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
- package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
- package/src/prove/smt/solver/lp/nla-order.ts +307 -0
- package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
- package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
- package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
- package/src/prove/smt/solver/lp/nla-types.ts +124 -0
- package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
- package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
- package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
- package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
- package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
- package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
- package/src/prove/smt/solver/lp/pdd.ts +971 -0
- package/src/prove/smt/solver/lp/random-updater.ts +138 -0
- package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
- package/src/prove/smt/solver/lp/union-find.ts +96 -0
- package/src/prove/smt/solver/mam-compiler.ts +847 -0
- package/src/prove/smt/solver/mam-interpreter.ts +400 -0
- package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
- package/src/prove/smt/solver/model-checker.ts +347 -0
- package/src/prove/smt/solver/model-evaluator.ts +262 -0
- package/src/prove/smt/solver/model-finder.ts +155 -0
- package/src/prove/smt/solver/model-generator.ts +97 -0
- package/src/prove/smt/solver/model-macro-solver.ts +728 -0
- package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
- package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
- package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
- package/src/prove/smt/solver/nlsat/explain.ts +607 -0
- package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
- package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
- package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
- package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
- package/src/prove/smt/solver/nlsat/solver.ts +911 -0
- package/src/prove/smt/solver/nlsat/types.ts +43 -0
- package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
- package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
- package/src/prove/smt/solver/nnf.ts +469 -0
- package/src/prove/smt/solver/pattern-inference.ts +351 -0
- package/src/prove/smt/solver/poly-rewriter.ts +477 -0
- package/src/prove/smt/solver/propagate-values.ts +83 -0
- package/src/prove/smt/solver/proto-model.ts +551 -0
- package/src/prove/smt/solver/pull-quant.ts +139 -0
- package/src/prove/smt/solver/qe-lite-der.ts +526 -0
- package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
- package/src/prove/smt/solver/qe-lite.ts +381 -0
- package/src/prove/smt/solver/qi-queue.ts +362 -0
- package/src/prove/smt/solver/quant-tactics.ts +117 -0
- package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
- package/src/prove/smt/solver/quantifier-manager.ts +186 -0
- package/src/prove/smt/solver/random-gen.ts +10 -0
- package/src/prove/smt/solver/rational.ts +165 -0
- package/src/prove/smt/solver/ref-vector.ts +62 -0
- package/src/prove/smt/solver/relevancy.ts +247 -0
- package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
- package/src/prove/smt/solver/rewriter.ts +843 -0
- package/src/prove/smt/solver/rlimit.ts +79 -0
- package/src/prove/smt/solver/smtlib-parser.ts +526 -0
- package/src/prove/smt/solver/solver.ts +71 -0
- package/src/prove/smt/solver/sort.ts +35 -0
- package/src/prove/smt/solver/sticky-generations.ts +69 -0
- package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
- package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
- package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
- package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
- package/src/prove/smt/solver/theory-lra-model.ts +243 -0
- package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
- package/src/prove/smt/solver/theory-lra-state.ts +43 -0
- package/src/prove/smt/solver/theory-lra.ts +56 -0
- package/src/prove/smt/solver/var-subst.ts +258 -0
- package/src/prove/smt/solver/z3-license.txt +10 -0
- package/src/prove/smt/table.ts +170 -0
- package/src/prove/tlapm/tlapm.ts +96 -0
- package/src/prove/tlaps-module.ts +510 -0
- package/src/prove/verdict.ts +18 -0
- package/src/prove/zenon/LICENSE +32 -0
- package/src/prove/zenon/check/check.ts +105 -0
- package/src/prove/zenon/check/definitions.ts +144 -0
- package/src/prove/zenon/check/equality.ts +182 -0
- package/src/prove/zenon/check/functions.ts +62 -0
- package/src/prove/zenon/check/keys.ts +125 -0
- package/src/prove/zenon/check/propositional.ts +104 -0
- package/src/prove/zenon/check/records.ts +188 -0
- package/src/prove/zenon/check/relations.ts +121 -0
- package/src/prove/zenon/check/rewrites.ts +224 -0
- package/src/prove/zenon/check/sets.ts +302 -0
- package/src/prove/zenon/check/terms.ts +127 -0
- package/src/prove/zenon/check/tla.ts +126 -0
- package/src/prove/zenon/decide.ts +113 -0
- package/src/prove/zenon/encode.ts +437 -0
- package/src/prove/zenon/eqrel.ts +300 -0
- package/src/prove/zenon/equality-rules.ts +435 -0
- package/src/prove/zenon/expr.ts +551 -0
- package/src/prove/zenon/index-table.ts +350 -0
- package/src/prove/zenon/isar-case.ts +513 -0
- package/src/prove/zenon/isar.ts +1249 -0
- package/src/prove/zenon/limits.ts +15 -0
- package/src/prove/zenon/llproof.ts +173 -0
- package/src/prove/zenon/mltoll.ts +1566 -0
- package/src/prove/zenon/node.ts +297 -0
- package/src/prove/zenon/ocaml.ts +169 -0
- package/src/prove/zenon/parse.ts +247 -0
- package/src/prove/zenon/phrase.ts +191 -0
- package/src/prove/zenon/proof.ts +198 -0
- package/src/prove/zenon/propositional-rules.ts +387 -0
- package/src/prove/zenon/rules.ts +94 -0
- package/src/prove/zenon/search.ts +288 -0
- package/src/prove/zenon/tla/functions.ts +151 -0
- package/src/prove/zenon/tla/llproof.ts +480 -0
- package/src/prove/zenon/tla/records.ts +225 -0
- package/src/prove/zenon/tla/rewrites.ts +447 -0
- package/src/prove/zenon/tla/sets.ts +304 -0
- package/src/prove/zenon/tla/terms.ts +181 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/run-cli.ts +334 -75
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +80 -35
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,551 @@
|
|
|
1
|
+
// Ported from Zenon's expr.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
|
|
2
|
+
//
|
|
3
|
+
// Formulas and terms, hash-consed so that equal expressions are the same object. Like Zenon,
|
|
4
|
+
// equality treats bound variables up to renaming, and a hash ignores the names of bound variables.
|
|
5
|
+
// Each run builds its expressions in its own store, so that fresh names and hashes start over.
|
|
6
|
+
|
|
7
|
+
import { TlaZenonError } from "../../errors";
|
|
8
|
+
import { combine, createHasher, toInt63, type Int63 } from "./ocaml";
|
|
9
|
+
|
|
10
|
+
// What every expression caches about itself.
|
|
11
|
+
interface ExprData {
|
|
12
|
+
id: number;
|
|
13
|
+
hash: number;
|
|
14
|
+
skeleton: Int63;
|
|
15
|
+
freeVars: string[];
|
|
16
|
+
size: number;
|
|
17
|
+
taus: number;
|
|
18
|
+
metas: Expr[];
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export interface VarExpr extends ExprData {
|
|
22
|
+
kind: "var";
|
|
23
|
+
symbol: string;
|
|
24
|
+
args: [];
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
// A metavariable stands for a term that instantiates its quantifier.
|
|
28
|
+
export interface MetaExpr extends ExprData {
|
|
29
|
+
kind: "meta";
|
|
30
|
+
symbol: "";
|
|
31
|
+
args: [Expr];
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
export interface AppExpr extends ExprData {
|
|
35
|
+
kind: "app";
|
|
36
|
+
symbol: string;
|
|
37
|
+
args: Expr[];
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
export interface NotExpr extends ExprData {
|
|
41
|
+
kind: "not";
|
|
42
|
+
symbol: "";
|
|
43
|
+
args: [Expr];
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export interface BinaryExpr extends ExprData {
|
|
47
|
+
kind: "and" | "or" | "imply" | "equiv";
|
|
48
|
+
symbol: "";
|
|
49
|
+
args: [Expr, Expr];
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
export interface ConstantExpr extends ExprData {
|
|
53
|
+
kind: "true" | "false";
|
|
54
|
+
symbol: "";
|
|
55
|
+
args: [];
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
// `symbol` is the type of the bound variable.
|
|
59
|
+
export interface BinderExpr extends ExprData {
|
|
60
|
+
kind: "all" | "ex" | "tau" | "lam";
|
|
61
|
+
symbol: string;
|
|
62
|
+
args: [VarExpr, Expr];
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
export type Expr = VarExpr | MetaExpr | AppExpr | NotExpr | BinaryExpr | ConstantExpr | BinderExpr;
|
|
66
|
+
|
|
67
|
+
export type ExprKind = Expr["kind"];
|
|
68
|
+
|
|
69
|
+
// An application to two arguments, such as an equality or another relation between two terms.
|
|
70
|
+
export type RelationExpr = AppExpr & { args: [Expr, Expr] };
|
|
71
|
+
|
|
72
|
+
export type NegatedRelationExpr = NotExpr & { args: [RelationExpr] };
|
|
73
|
+
|
|
74
|
+
const VAR_PREFIX = "zenon_V";
|
|
75
|
+
export const UNIVERSE = "zenon_U";
|
|
76
|
+
export const GOAL_NAME = "zenon_G";
|
|
77
|
+
|
|
78
|
+
const SKELETONS = {
|
|
79
|
+
true: toInt63(0xb063cd7),
|
|
80
|
+
false: toInt63(0xd5ab9f0),
|
|
81
|
+
meta: toInt63(0x33d092c),
|
|
82
|
+
app: toInt63(0x33b9c25),
|
|
83
|
+
not: toInt63(0x7c3e7d2),
|
|
84
|
+
and: toInt63(0xccdc15b),
|
|
85
|
+
or: toInt63(0x49b55b9),
|
|
86
|
+
imply: toInt63(0x7ebfa6f),
|
|
87
|
+
equiv: toInt63(0xb0f18f7),
|
|
88
|
+
all: toInt63(0xfb437ff),
|
|
89
|
+
ex: toInt63(0x0716b52),
|
|
90
|
+
tau: toInt63(0x4ae7fad),
|
|
91
|
+
lam: toInt63(0x24adcb3),
|
|
92
|
+
};
|
|
93
|
+
|
|
94
|
+
const ZERO = toInt63(0);
|
|
95
|
+
|
|
96
|
+
const makeConstant = (kind: "true" | "false", id: number, skeleton: Int63): ConstantExpr => ({
|
|
97
|
+
id,
|
|
98
|
+
kind,
|
|
99
|
+
symbol: "",
|
|
100
|
+
args: [],
|
|
101
|
+
hash: createHasher().hashIntAndStrings(skeleton.high, skeleton.low, []),
|
|
102
|
+
skeleton,
|
|
103
|
+
freeVars: [],
|
|
104
|
+
size: 1,
|
|
105
|
+
taus: 0,
|
|
106
|
+
metas: [],
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
export const TRUE = makeConstant("true", 0, SKELETONS.true);
|
|
110
|
+
export const FALSE = makeConstant("false", 1, SKELETONS.false);
|
|
111
|
+
|
|
112
|
+
const isBinary = (expression: Expr): expression is BinaryExpr =>
|
|
113
|
+
expression.kind === "and" ||
|
|
114
|
+
expression.kind === "or" ||
|
|
115
|
+
expression.kind === "imply" ||
|
|
116
|
+
expression.kind === "equiv";
|
|
117
|
+
|
|
118
|
+
export const isBinder = (expression: Expr): expression is BinderExpr =>
|
|
119
|
+
expression.kind === "all" ||
|
|
120
|
+
expression.kind === "ex" ||
|
|
121
|
+
expression.kind === "tau" ||
|
|
122
|
+
expression.kind === "lam";
|
|
123
|
+
|
|
124
|
+
// Zenon's str_union: the names of the first list missing from the second, in reverse, then the
|
|
125
|
+
// second. Hashes depend on this order.
|
|
126
|
+
const unionNames = (left: string[], right: string[]) => {
|
|
127
|
+
if (left.length === 0) return right;
|
|
128
|
+
if (right.length === 0) return left;
|
|
129
|
+
const result = [...right];
|
|
130
|
+
for (const name of left) if (!result.includes(name)) result.unshift(name);
|
|
131
|
+
return result;
|
|
132
|
+
};
|
|
133
|
+
|
|
134
|
+
const removeName = (name: string, names: string[]) => {
|
|
135
|
+
const index = names.indexOf(name);
|
|
136
|
+
return index === -1 ? names : [...names.slice(0, index), ...names.slice(index + 1)];
|
|
137
|
+
};
|
|
138
|
+
|
|
139
|
+
export const difference = (left: Expr[], right: Expr[]) =>
|
|
140
|
+
left.filter((inner) => !right.includes(inner));
|
|
141
|
+
|
|
142
|
+
// Zenon's union on small sets: the first list's new elements in reverse, then the second list.
|
|
143
|
+
export const union = (left: Expr[], right: Expr[]) => {
|
|
144
|
+
const added = difference(left, right);
|
|
145
|
+
return added.length === 0 ? right : [...added.reverse(), ...right];
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
export const isDisjoint = (left: Expr[], right: Expr[]) =>
|
|
149
|
+
!left.some((inner) => right.includes(inner));
|
|
150
|
+
|
|
151
|
+
const intersects = (env: Expr[], names: string[]) =>
|
|
152
|
+
names.some((name) => env.some((variable) => variable.symbol === name));
|
|
153
|
+
|
|
154
|
+
const isSameBinding = (leftEnv: Expr[], left: Expr, rightEnv: Expr[], right: Expr) => {
|
|
155
|
+
const leftIndex = leftEnv.indexOf(left);
|
|
156
|
+
const rightIndex = rightEnv.indexOf(right);
|
|
157
|
+
return leftIndex === -1 ? rightIndex === -1 && left === right : leftIndex === rightIndex;
|
|
158
|
+
};
|
|
159
|
+
|
|
160
|
+
const isEqualInEnv = (leftEnv: Expr[], rightEnv: Expr[], left: Expr, right: Expr): boolean => {
|
|
161
|
+
const isLeftBound = intersects(leftEnv, left.freeVars);
|
|
162
|
+
const isRightBound = intersects(rightEnv, right.freeVars);
|
|
163
|
+
if (!isLeftBound && !isRightBound) return left === right;
|
|
164
|
+
if (!isLeftBound || !isRightBound || left.kind !== right.kind) return false;
|
|
165
|
+
switch (left.kind) {
|
|
166
|
+
case "var":
|
|
167
|
+
return isSameBinding(leftEnv, left, rightEnv, right);
|
|
168
|
+
case "meta":
|
|
169
|
+
return right.kind === "meta" && left.args[0] === right.args[0];
|
|
170
|
+
case "app":
|
|
171
|
+
return (
|
|
172
|
+
right.kind === "app" &&
|
|
173
|
+
left.symbol === right.symbol &&
|
|
174
|
+
left.args.length === right.args.length &&
|
|
175
|
+
left.args.every((inner, index) => isEqualInEnv(leftEnv, rightEnv, inner, right.args[index]))
|
|
176
|
+
);
|
|
177
|
+
case "not":
|
|
178
|
+
return right.kind === "not" && isEqualInEnv(leftEnv, rightEnv, left.args[0], right.args[0]);
|
|
179
|
+
case "and":
|
|
180
|
+
case "or":
|
|
181
|
+
case "imply":
|
|
182
|
+
case "equiv":
|
|
183
|
+
return (
|
|
184
|
+
isBinary(right) &&
|
|
185
|
+
isEqualInEnv(leftEnv, rightEnv, left.args[0], right.args[0]) &&
|
|
186
|
+
isEqualInEnv(leftEnv, rightEnv, left.args[1], right.args[1])
|
|
187
|
+
);
|
|
188
|
+
case "true":
|
|
189
|
+
case "false":
|
|
190
|
+
return true;
|
|
191
|
+
default:
|
|
192
|
+
return (
|
|
193
|
+
isBinder(right) &&
|
|
194
|
+
left.args[1].freeVars.includes(left.args[0].symbol) ===
|
|
195
|
+
right.args[1].freeVars.includes(right.args[0].symbol) &&
|
|
196
|
+
isEqualInEnv(
|
|
197
|
+
[left.args[0], ...leftEnv],
|
|
198
|
+
[right.args[0], ...rightEnv],
|
|
199
|
+
left.args[1],
|
|
200
|
+
right.args[1],
|
|
201
|
+
)
|
|
202
|
+
);
|
|
203
|
+
}
|
|
204
|
+
};
|
|
205
|
+
|
|
206
|
+
const isEqualBody = (leftVar: Expr, rightVar: Expr, left: Expr, right: Expr) => {
|
|
207
|
+
const isLeftBound = left.freeVars.includes(leftVar.symbol);
|
|
208
|
+
const isRightBound = right.freeVars.includes(rightVar.symbol);
|
|
209
|
+
return (
|
|
210
|
+
(!isLeftBound && !isRightBound && left === right) ||
|
|
211
|
+
(isLeftBound && isRightBound && isEqualInEnv([leftVar], [rightVar], left, right))
|
|
212
|
+
);
|
|
213
|
+
};
|
|
214
|
+
|
|
215
|
+
// Zenon's HashedExpr.equal on two binders whose children are already hash-consed.
|
|
216
|
+
const isSameBinder = (left: BinderExpr, right: BinderExpr) =>
|
|
217
|
+
left.kind === right.kind &&
|
|
218
|
+
left.symbol === right.symbol &&
|
|
219
|
+
(left.args[0] === right.args[0]
|
|
220
|
+
? left.args[1] === right.args[1]
|
|
221
|
+
: isEqualBody(left.args[0], right.args[0], left.args[1], right.args[1]));
|
|
222
|
+
|
|
223
|
+
// The symbol is part of the narrowed type, so a failed test for one symbol keeps the expression an
|
|
224
|
+
// application for the next test.
|
|
225
|
+
export const isApp = <Symbol extends string>(
|
|
226
|
+
expression: Expr,
|
|
227
|
+
symbol: Symbol,
|
|
228
|
+
arity?: number,
|
|
229
|
+
): expression is AppExpr & { symbol: Symbol } =>
|
|
230
|
+
expression.kind === "app" &&
|
|
231
|
+
expression.symbol === symbol &&
|
|
232
|
+
(arity === undefined || expression.args.length === arity);
|
|
233
|
+
|
|
234
|
+
export const isMeta = (expression: Expr): expression is MetaExpr => expression.kind === "meta";
|
|
235
|
+
|
|
236
|
+
export const isRelation = (expression: Expr): expression is RelationExpr =>
|
|
237
|
+
expression.kind === "app" && expression.args.length === 2;
|
|
238
|
+
|
|
239
|
+
export const isNegatedRelation = (expression: Expr): expression is NegatedRelationExpr =>
|
|
240
|
+
expression.kind === "not" && isRelation(expression.args[0]);
|
|
241
|
+
|
|
242
|
+
// Zenon orders by hash, and only breaks ties structurally.
|
|
243
|
+
export const compareExprs = (left: Expr, right: Expr): number => {
|
|
244
|
+
if (left.hash !== right.hash) return left.hash < right.hash ? -1 : 1;
|
|
245
|
+
if (left === right) return 0;
|
|
246
|
+
if (left.kind !== right.kind) return left.kind < right.kind ? -1 : 1;
|
|
247
|
+
if (left.symbol !== right.symbol) return left.symbol < right.symbol ? -1 : 1;
|
|
248
|
+
if (left.args.length !== right.args.length) return left.args.length - right.args.length;
|
|
249
|
+
for (let index = 0; index < left.args.length; index++) {
|
|
250
|
+
const order = compareExprs(left.args[index], right.args[index]);
|
|
251
|
+
if (order !== 0) return order;
|
|
252
|
+
}
|
|
253
|
+
return 0;
|
|
254
|
+
};
|
|
255
|
+
|
|
256
|
+
export type Substitution = [Expr, Expr][];
|
|
257
|
+
|
|
258
|
+
const lookup = (map: Substitution, variable: Expr) => map.find((pair) => pair[0] === variable)?.[1];
|
|
259
|
+
|
|
260
|
+
const isIrrelevant = (names: string[], map: Substitution) =>
|
|
261
|
+
names.every((name) => map.every((pair) => pair[0].symbol !== name));
|
|
262
|
+
|
|
263
|
+
const hasConflict = (variable: Expr, map: Substitution) =>
|
|
264
|
+
map.some((pair) => pair[1].freeVars.includes(variable.symbol));
|
|
265
|
+
|
|
266
|
+
// The store of one run's expressions, and the operations that build expressions in it.
|
|
267
|
+
export const createExpressions = () => {
|
|
268
|
+
const hasher = createHasher();
|
|
269
|
+
// Binders are hash-consed by hash, since they're equal up to the names of their variables. Other
|
|
270
|
+
// expressions are equal exactly when their kind, symbol and children are, so they're found by
|
|
271
|
+
// those before their hash is computed.
|
|
272
|
+
const binders = new Map<number, BinderExpr[]>();
|
|
273
|
+
const interned = new Map<number, Expr[]>();
|
|
274
|
+
// Numbers for the symbols, so an expression hashes by its symbol and children without strings.
|
|
275
|
+
const symbolIds = new Map<string, number>();
|
|
276
|
+
let nextId = FALSE.id + 1;
|
|
277
|
+
let createdCount = 0;
|
|
278
|
+
// Zenon's Ext_focal takes the first five fresh names when the program starts, for its built-in
|
|
279
|
+
// definitions, so the first name Zenon gives out is zenon_Vf.
|
|
280
|
+
let nameCounter = "e";
|
|
281
|
+
|
|
282
|
+
const create = <Shape extends Pick<Expr, "kind" | "symbol" | "args">>(
|
|
283
|
+
shape: Shape,
|
|
284
|
+
skeleton: Int63,
|
|
285
|
+
freeVars: string[],
|
|
286
|
+
size: number,
|
|
287
|
+
taus: number,
|
|
288
|
+
metas: Expr[],
|
|
289
|
+
) => ({
|
|
290
|
+
...shape,
|
|
291
|
+
id: nextId++,
|
|
292
|
+
hash: hasher.hashIntAndStrings(skeleton.high, skeleton.low, freeVars),
|
|
293
|
+
skeleton,
|
|
294
|
+
freeVars,
|
|
295
|
+
size,
|
|
296
|
+
taus,
|
|
297
|
+
metas,
|
|
298
|
+
});
|
|
299
|
+
|
|
300
|
+
const mergeBinder = (candidate: BinderExpr) => {
|
|
301
|
+
const bucket = binders.get(candidate.hash);
|
|
302
|
+
const existing = bucket?.find((inner) => isSameBinder(inner, candidate));
|
|
303
|
+
if (existing !== undefined) return existing;
|
|
304
|
+
if (bucket === undefined) binders.set(candidate.hash, [candidate]);
|
|
305
|
+
else bucket.push(candidate);
|
|
306
|
+
createdCount++;
|
|
307
|
+
return candidate;
|
|
308
|
+
};
|
|
309
|
+
|
|
310
|
+
const getSymbolId = (symbol: string) => {
|
|
311
|
+
const cached = symbolIds.get(symbol);
|
|
312
|
+
if (cached !== undefined) return cached;
|
|
313
|
+
symbolIds.set(symbol, symbolIds.size);
|
|
314
|
+
return symbolIds.size - 1;
|
|
315
|
+
};
|
|
316
|
+
|
|
317
|
+
const intern = <Result extends Expr>(
|
|
318
|
+
kind: ExprKind,
|
|
319
|
+
symbol: string,
|
|
320
|
+
args: Expr[],
|
|
321
|
+
build: () => Result,
|
|
322
|
+
): Result => {
|
|
323
|
+
let key = getSymbolId(symbol);
|
|
324
|
+
for (const arg of args) key = Math.imul(key, 0x01000193) ^ arg.id;
|
|
325
|
+
const bucket = interned.get(key);
|
|
326
|
+
const existing = bucket?.find(
|
|
327
|
+
(inner): inner is Result =>
|
|
328
|
+
inner.kind === kind &&
|
|
329
|
+
inner.symbol === symbol &&
|
|
330
|
+
inner.args.length === args.length &&
|
|
331
|
+
inner.args.every((child, index) => child === args[index]),
|
|
332
|
+
);
|
|
333
|
+
if (existing !== undefined) return existing;
|
|
334
|
+
const result = build();
|
|
335
|
+
if (bucket === undefined) interned.set(key, [result]);
|
|
336
|
+
else bucket.push(result);
|
|
337
|
+
createdCount++;
|
|
338
|
+
return result;
|
|
339
|
+
};
|
|
340
|
+
|
|
341
|
+
const evar = (name: string) =>
|
|
342
|
+
intern("var", name, [], (): VarExpr =>
|
|
343
|
+
create({ kind: "var", symbol: name, args: [] }, ZERO, [name], 1, 0, []),
|
|
344
|
+
);
|
|
345
|
+
|
|
346
|
+
const emeta = (quantified: Expr) =>
|
|
347
|
+
intern("meta", "", [quantified], (): MetaExpr =>
|
|
348
|
+
create(
|
|
349
|
+
{ kind: "meta", symbol: "", args: [quantified] },
|
|
350
|
+
combine(SKELETONS.meta, quantified.skeleton),
|
|
351
|
+
[],
|
|
352
|
+
1,
|
|
353
|
+
0,
|
|
354
|
+
[quantified],
|
|
355
|
+
),
|
|
356
|
+
);
|
|
357
|
+
|
|
358
|
+
const eapp = (symbol: string, args: Expr[]) =>
|
|
359
|
+
intern("app", symbol, args, (): AppExpr => {
|
|
360
|
+
let skeleton = toInt63(hasher.hashString(symbol));
|
|
361
|
+
let freeVars: string[] = [];
|
|
362
|
+
let size = 1;
|
|
363
|
+
let taus = 0;
|
|
364
|
+
let metas: Expr[] = [];
|
|
365
|
+
for (const arg of args) {
|
|
366
|
+
skeleton = combine(arg.skeleton, skeleton);
|
|
367
|
+
freeVars = unionNames(freeVars, arg.freeVars);
|
|
368
|
+
size += arg.size;
|
|
369
|
+
taus = Math.max(arg.taus, taus);
|
|
370
|
+
metas = union(arg.metas, metas);
|
|
371
|
+
}
|
|
372
|
+
return create(
|
|
373
|
+
{ kind: "app", symbol, args },
|
|
374
|
+
combine(SKELETONS.app, skeleton),
|
|
375
|
+
freeVars,
|
|
376
|
+
size,
|
|
377
|
+
taus,
|
|
378
|
+
metas,
|
|
379
|
+
);
|
|
380
|
+
});
|
|
381
|
+
|
|
382
|
+
const enot = (operand: Expr) =>
|
|
383
|
+
intern("not", "", [operand], (): NotExpr =>
|
|
384
|
+
create(
|
|
385
|
+
{ kind: "not", symbol: "", args: [operand] },
|
|
386
|
+
combine(SKELETONS.not, operand.skeleton),
|
|
387
|
+
operand.freeVars,
|
|
388
|
+
operand.size + 1,
|
|
389
|
+
operand.taus,
|
|
390
|
+
operand.metas,
|
|
391
|
+
),
|
|
392
|
+
);
|
|
393
|
+
|
|
394
|
+
const binary = (kind: "and" | "or" | "imply" | "equiv", left: Expr, right: Expr) =>
|
|
395
|
+
intern(kind, "", [left, right], (): BinaryExpr =>
|
|
396
|
+
create(
|
|
397
|
+
{ kind, symbol: "", args: [left, right] },
|
|
398
|
+
combine(SKELETONS[kind], combine(left.skeleton, right.skeleton)),
|
|
399
|
+
unionNames(left.freeVars, right.freeVars),
|
|
400
|
+
left.size + right.size + 1,
|
|
401
|
+
Math.max(left.taus, right.taus),
|
|
402
|
+
union(left.metas, right.metas),
|
|
403
|
+
),
|
|
404
|
+
);
|
|
405
|
+
|
|
406
|
+
const binder = (
|
|
407
|
+
kind: "all" | "ex" | "tau" | "lam",
|
|
408
|
+
variable: VarExpr,
|
|
409
|
+
type: string,
|
|
410
|
+
body: Expr,
|
|
411
|
+
) =>
|
|
412
|
+
mergeBinder(
|
|
413
|
+
create(
|
|
414
|
+
{ kind, symbol: type, args: [variable, body] },
|
|
415
|
+
combine(SKELETONS[kind], combine(toInt63(hasher.hashString(type)), body.skeleton)),
|
|
416
|
+
removeName(variable.symbol, body.freeVars),
|
|
417
|
+
kind === "tau" || kind === "lam" ? 1 : body.size + 1,
|
|
418
|
+
kind === "tau" ? body.taus + 1 : body.taus,
|
|
419
|
+
body.metas,
|
|
420
|
+
),
|
|
421
|
+
);
|
|
422
|
+
|
|
423
|
+
const rebuild = (expression: AppExpr | NotExpr | BinaryExpr, args: Expr[]): Expr =>
|
|
424
|
+
expression.kind === "app"
|
|
425
|
+
? eapp(expression.symbol, args)
|
|
426
|
+
: expression.kind === "not"
|
|
427
|
+
? enot(args[0])
|
|
428
|
+
: binary(expression.kind, args[0], args[1]);
|
|
429
|
+
|
|
430
|
+
const newVar = () => {
|
|
431
|
+
const letters = [...nameCounter];
|
|
432
|
+
let position = 0;
|
|
433
|
+
while (position < letters.length && letters[position] === "z") letters[position++] = "a";
|
|
434
|
+
if (position === letters.length) letters.push("a");
|
|
435
|
+
else letters[position] = String.fromCharCode(letters[position].charCodeAt(0) + 1);
|
|
436
|
+
nameCounter = letters.join("");
|
|
437
|
+
return evar(VAR_PREFIX + nameCounter);
|
|
438
|
+
};
|
|
439
|
+
|
|
440
|
+
// A binder's variable for a substitution, renamed when the substituted values capture it, and
|
|
441
|
+
// the substitution to apply to its body.
|
|
442
|
+
const enterBinder = (expression: BinderExpr, map: Substitution): [VarExpr, Substitution] => {
|
|
443
|
+
const variable = expression.args[0];
|
|
444
|
+
const rest = map.filter((pair) => pair[0] !== variable);
|
|
445
|
+
if (!hasConflict(variable, rest)) return [variable, rest];
|
|
446
|
+
const fresh = newVar();
|
|
447
|
+
return [fresh, [[variable, fresh], ...rest]];
|
|
448
|
+
};
|
|
449
|
+
|
|
450
|
+
const substitute = (map: Substitution, expression: Expr): Expr => {
|
|
451
|
+
if (isIrrelevant(expression.freeVars, map)) return expression;
|
|
452
|
+
switch (expression.kind) {
|
|
453
|
+
case "var":
|
|
454
|
+
return lookup(map, expression) ?? expression;
|
|
455
|
+
case "meta":
|
|
456
|
+
case "true":
|
|
457
|
+
case "false":
|
|
458
|
+
return expression;
|
|
459
|
+
case "all":
|
|
460
|
+
case "ex":
|
|
461
|
+
case "tau":
|
|
462
|
+
case "lam": {
|
|
463
|
+
const entered = enterBinder(expression, map);
|
|
464
|
+
return binder(
|
|
465
|
+
expression.kind,
|
|
466
|
+
entered[0],
|
|
467
|
+
expression.symbol,
|
|
468
|
+
substitute(entered[1], expression.args[1]),
|
|
469
|
+
);
|
|
470
|
+
}
|
|
471
|
+
default:
|
|
472
|
+
return rebuild(
|
|
473
|
+
expression,
|
|
474
|
+
expression.args.map((inner) => substitute(map, inner)),
|
|
475
|
+
);
|
|
476
|
+
}
|
|
477
|
+
};
|
|
478
|
+
|
|
479
|
+
const substituteAll = (map: Substitution, expressions: Expr[]) => {
|
|
480
|
+
const results: Expr[] = [];
|
|
481
|
+
for (const inner of expressions) {
|
|
482
|
+
const result = substituteSecondOrder(map, inner);
|
|
483
|
+
if (result === undefined) return undefined;
|
|
484
|
+
results.push(result);
|
|
485
|
+
}
|
|
486
|
+
return results;
|
|
487
|
+
};
|
|
488
|
+
|
|
489
|
+
// Zenon's substitute_2nd: also replaces applied symbols bound in the map, for definitions with
|
|
490
|
+
// operator parameters. Undefined stands for Zenon's Higher_order exception.
|
|
491
|
+
const substituteSecondOrder = (map: Substitution, expression: Expr): Expr | undefined => {
|
|
492
|
+
switch (expression.kind) {
|
|
493
|
+
case "var":
|
|
494
|
+
return lookup(map, expression) ?? expression;
|
|
495
|
+
case "meta":
|
|
496
|
+
case "true":
|
|
497
|
+
case "false":
|
|
498
|
+
return expression;
|
|
499
|
+
case "app": {
|
|
500
|
+
const actuals = substituteAll(map, expression.args);
|
|
501
|
+
if (actuals === undefined) return undefined;
|
|
502
|
+
const operator = lookup(map, evar(expression.symbol));
|
|
503
|
+
if (operator === undefined) return eapp(expression.symbol, actuals);
|
|
504
|
+
if (operator.kind === "lam" && actuals.length === 1)
|
|
505
|
+
return substitute([[operator.args[0], actuals[0]]], operator.args[1]);
|
|
506
|
+
if (operator.kind === "var") return eapp(operator.symbol, actuals);
|
|
507
|
+
if (operator.kind === "app") return eapp(operator.symbol, [...operator.args, ...actuals]);
|
|
508
|
+
return undefined;
|
|
509
|
+
}
|
|
510
|
+
case "all":
|
|
511
|
+
case "ex":
|
|
512
|
+
case "tau":
|
|
513
|
+
case "lam": {
|
|
514
|
+
const entered = enterBinder(expression, map);
|
|
515
|
+
const body = substituteSecondOrder(entered[1], expression.args[1]);
|
|
516
|
+
return body === undefined
|
|
517
|
+
? undefined
|
|
518
|
+
: binder(expression.kind, entered[0], expression.symbol, body);
|
|
519
|
+
}
|
|
520
|
+
default: {
|
|
521
|
+
const args = substituteAll(map, expression.args);
|
|
522
|
+
return args === undefined ? undefined : rebuild(expression, args);
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
};
|
|
526
|
+
|
|
527
|
+
return {
|
|
528
|
+
evar,
|
|
529
|
+
emeta,
|
|
530
|
+
eapp,
|
|
531
|
+
enot,
|
|
532
|
+
eand: (left: Expr, right: Expr) => binary("and", left, right),
|
|
533
|
+
eor: (left: Expr, right: Expr) => binary("or", left, right),
|
|
534
|
+
eimply: (left: Expr, right: Expr) => binary("imply", left, right),
|
|
535
|
+
eequiv: (left: Expr, right: Expr) => binary("equiv", left, right),
|
|
536
|
+
eall: (variable: VarExpr, type: string, body: Expr) => binder("all", variable, type, body),
|
|
537
|
+
eex: (variable: VarExpr, type: string, body: Expr) => binder("ex", variable, type, body),
|
|
538
|
+
etau: (variable: VarExpr, type: string, body: Expr) => binder("tau", variable, type, body),
|
|
539
|
+
elam: (variable: VarExpr, type: string, body: Expr) => binder("lam", variable, type, body),
|
|
540
|
+
newVar,
|
|
541
|
+
substitute,
|
|
542
|
+
substituteSecondOrder,
|
|
543
|
+
apply: (lambda: Expr, argument: Expr) => {
|
|
544
|
+
if (lambda.kind !== "lam") throw new TlaZenonError("Zenon: higher-order application");
|
|
545
|
+
return substitute([[lambda.args[0], argument]], lambda.args[1]);
|
|
546
|
+
},
|
|
547
|
+
getCreatedCount: () => createdCount,
|
|
548
|
+
};
|
|
549
|
+
};
|
|
550
|
+
|
|
551
|
+
export type Expressions = ReturnType<typeof createExpressions>;
|