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,506 @@
|
|
|
1
|
+
// Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
|
|
2
|
+
//
|
|
3
|
+
// The TLA+ extension: rules for set theory, functions, records, tuples, CHOOSE, IF and CASE, and
|
|
4
|
+
// rewriting a subterm with an equality on the branch.
|
|
5
|
+
|
|
6
|
+
import {
|
|
7
|
+
FALSE,
|
|
8
|
+
isApp,
|
|
9
|
+
TRUE,
|
|
10
|
+
type Expr,
|
|
11
|
+
type Expressions,
|
|
12
|
+
type NegatedRelationExpr,
|
|
13
|
+
type RelationExpr,
|
|
14
|
+
} from "../expr";
|
|
15
|
+
import type { Node, Priority } from "../node";
|
|
16
|
+
import type { Phrase } from "../parse";
|
|
17
|
+
import { makeRule, type Rule } from "../proof";
|
|
18
|
+
import { getFunctionNodes, getFunctionSetNodes } from "./functions";
|
|
19
|
+
import { getRecordNodes, getTupleNodes } from "./records";
|
|
20
|
+
import { getRewriteNodes } from "./rewrites";
|
|
21
|
+
import {
|
|
22
|
+
getMembershipNodes,
|
|
23
|
+
getMetaMembershipNodes,
|
|
24
|
+
getSetEqualityNodes,
|
|
25
|
+
getSubsetNodes,
|
|
26
|
+
} from "./sets";
|
|
27
|
+
import {
|
|
28
|
+
equal,
|
|
29
|
+
FUNCTION_CONSTRUCTORS,
|
|
30
|
+
getLiteral,
|
|
31
|
+
isNotEquiv,
|
|
32
|
+
isVariable,
|
|
33
|
+
makeExtensionNode,
|
|
34
|
+
makeInstanceNode,
|
|
35
|
+
member,
|
|
36
|
+
SET_CONSTRUCTORS,
|
|
37
|
+
type Item,
|
|
38
|
+
type Literal,
|
|
39
|
+
type TlaContext,
|
|
40
|
+
} from "./terms";
|
|
41
|
+
|
|
42
|
+
const OTHER_SYMBOLS = [
|
|
43
|
+
"TLA.in",
|
|
44
|
+
"TLA.isAFcn",
|
|
45
|
+
"TLA.cond",
|
|
46
|
+
"TLA.CASE",
|
|
47
|
+
"TLA.tuple",
|
|
48
|
+
"TLA.record",
|
|
49
|
+
"TLA.fapply",
|
|
50
|
+
"TLA.box",
|
|
51
|
+
];
|
|
52
|
+
|
|
53
|
+
// The symbols that hypotheses can't define, as Zenon's predef with the tla extension.
|
|
54
|
+
export const PREDEFINED_SYMBOLS = [
|
|
55
|
+
"=",
|
|
56
|
+
...SET_CONSTRUCTORS,
|
|
57
|
+
...FUNCTION_CONSTRUCTORS,
|
|
58
|
+
...OTHER_SYMBOLS,
|
|
59
|
+
];
|
|
60
|
+
|
|
61
|
+
const definition = (
|
|
62
|
+
exprs: Expressions,
|
|
63
|
+
name: string,
|
|
64
|
+
symbol: string,
|
|
65
|
+
params: string[],
|
|
66
|
+
body: Expr,
|
|
67
|
+
): Phrase => ({
|
|
68
|
+
kind: "def",
|
|
69
|
+
definition: {
|
|
70
|
+
kind: "real",
|
|
71
|
+
name,
|
|
72
|
+
symbol,
|
|
73
|
+
params: params.map((param) => exprs.evar(param)),
|
|
74
|
+
body,
|
|
75
|
+
},
|
|
76
|
+
});
|
|
77
|
+
|
|
78
|
+
// Zenon's built_in_defs. Expressions belong to one run of the prover, so each run builds them.
|
|
79
|
+
export const getBuiltInDefinitions = (exprs: Expressions): Phrase[] => {
|
|
80
|
+
const bound = exprs.evar("x");
|
|
81
|
+
const isInSet = exprs.eapp("TLA.in", [bound, exprs.evar("S")]);
|
|
82
|
+
const holds = exprs.eapp("P", [bound]);
|
|
83
|
+
return [
|
|
84
|
+
definition(
|
|
85
|
+
exprs,
|
|
86
|
+
"subset_def",
|
|
87
|
+
"TLA.subseteq",
|
|
88
|
+
["A", "B"],
|
|
89
|
+
exprs.eapp("TLA.bAll", [
|
|
90
|
+
exprs.evar("A"),
|
|
91
|
+
exprs.elam(bound, "", exprs.eapp("TLA.in", [bound, exprs.evar("B")])),
|
|
92
|
+
]),
|
|
93
|
+
),
|
|
94
|
+
definition(
|
|
95
|
+
exprs,
|
|
96
|
+
"bAll_def",
|
|
97
|
+
"TLA.bAll",
|
|
98
|
+
["S", "P"],
|
|
99
|
+
exprs.eall(bound, "", exprs.eimply(isInSet, holds)),
|
|
100
|
+
),
|
|
101
|
+
definition(
|
|
102
|
+
exprs,
|
|
103
|
+
"bEx_def",
|
|
104
|
+
"TLA.bEx",
|
|
105
|
+
["S", "P"],
|
|
106
|
+
exprs.eex(bound, "", exprs.eand(isInSet, holds)),
|
|
107
|
+
),
|
|
108
|
+
definition(
|
|
109
|
+
exprs,
|
|
110
|
+
"bChoose_def",
|
|
111
|
+
"TLA.bChoice",
|
|
112
|
+
["S", "P"],
|
|
113
|
+
exprs.etau(bound, "", exprs.eand(isInSet, holds)),
|
|
114
|
+
),
|
|
115
|
+
definition(
|
|
116
|
+
exprs,
|
|
117
|
+
"prod_def",
|
|
118
|
+
"TLA.prod",
|
|
119
|
+
["A", "B"],
|
|
120
|
+
exprs.eapp("TLA.Product", [exprs.eapp("TLA.tuple", [exprs.evar("A"), exprs.evar("B")])]),
|
|
121
|
+
),
|
|
122
|
+
];
|
|
123
|
+
};
|
|
124
|
+
|
|
125
|
+
// The elements of a set given by enumeration, and whether it may hold more.
|
|
126
|
+
const getSetValues = (set: Expr): [Expr[], boolean] => {
|
|
127
|
+
if (isVariable(set, "TLA.emptyset")) return [[], false];
|
|
128
|
+
if (isApp(set, "TLA.upair", 2)) return [set.args, false];
|
|
129
|
+
if (isApp(set, "TLA.set")) return [set.args, false];
|
|
130
|
+
if (isApp(set, "TLA.addElt", 2)) {
|
|
131
|
+
const rest = getSetValues(set.args[1]);
|
|
132
|
+
return [[set.args[0], ...rest[0]], rest[1]];
|
|
133
|
+
}
|
|
134
|
+
if (isApp(set, "TLA.union", 2)) {
|
|
135
|
+
const left = getSetValues(set.args[0]);
|
|
136
|
+
const right = getSetValues(set.args[1]);
|
|
137
|
+
return [[...left[0], ...right[0]], left[1] || right[1]];
|
|
138
|
+
}
|
|
139
|
+
return [[], true];
|
|
140
|
+
};
|
|
141
|
+
|
|
142
|
+
const getBooleanNodes = (literal: Literal): Item[] | undefined => {
|
|
143
|
+
const exprs = literal.context.exprs;
|
|
144
|
+
const formula = literal.formula;
|
|
145
|
+
const isNegated = literal.isNegated;
|
|
146
|
+
const atom = literal.atom;
|
|
147
|
+
const relation = literal.relation;
|
|
148
|
+
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
149
|
+
makeExtensionNode(literal, priority, rule, branches);
|
|
150
|
+
const instance = (priority: Priority, quantified: Expr, term: Expr) =>
|
|
151
|
+
makeInstanceNode(literal, priority, quantified, term);
|
|
152
|
+
if (atom.kind === "meta") return instance("arity", atom.args[0], isNegated ? TRUE : FALSE);
|
|
153
|
+
if (relation?.symbol !== "=") return undefined;
|
|
154
|
+
const left = relation.args[0];
|
|
155
|
+
const right = relation.args[1];
|
|
156
|
+
if (right.kind === "true")
|
|
157
|
+
return isNegated
|
|
158
|
+
? node("prop", makeRule("noteq_x_true", [formula, exprs.enot(left), left]), [
|
|
159
|
+
[exprs.enot(left)],
|
|
160
|
+
])
|
|
161
|
+
: node("prop", makeRule("eq_x_true", [formula, left, left]), [[left]]);
|
|
162
|
+
if (left.kind === "true")
|
|
163
|
+
return isNegated
|
|
164
|
+
? node("prop", makeRule("noteq_true_x", [formula, exprs.enot(right), right]), [
|
|
165
|
+
[exprs.enot(right)],
|
|
166
|
+
])
|
|
167
|
+
: node("prop", makeRule("eq_true_x", [formula, right, right]), [[right]]);
|
|
168
|
+
if (!isNegated && right.kind === "false")
|
|
169
|
+
return node("prop", makeRule("eq_x_false", [formula, exprs.enot(left), left]), [
|
|
170
|
+
[exprs.enot(left)],
|
|
171
|
+
]);
|
|
172
|
+
if (!isNegated && left.kind === "false")
|
|
173
|
+
return node("prop", makeRule("eq_false_x", [formula, exprs.enot(right), right]), [
|
|
174
|
+
[exprs.enot(right)],
|
|
175
|
+
]);
|
|
176
|
+
return undefined;
|
|
177
|
+
};
|
|
178
|
+
|
|
179
|
+
const getChoiceNodes = (literal: Literal): Item[] | undefined => {
|
|
180
|
+
const exprs = literal.context.exprs;
|
|
181
|
+
const formula = literal.formula;
|
|
182
|
+
const goalness = literal.goalness;
|
|
183
|
+
const isNegated = literal.isNegated;
|
|
184
|
+
const relation = literal.relation;
|
|
185
|
+
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
186
|
+
makeExtensionNode(literal, priority, rule, branches);
|
|
187
|
+
if (relation === undefined) return undefined;
|
|
188
|
+
const left = relation.args[0];
|
|
189
|
+
const right = relation.args[1];
|
|
190
|
+
const isEquality = relation.symbol === "=";
|
|
191
|
+
if (
|
|
192
|
+
isNegated &&
|
|
193
|
+
isEquality &&
|
|
194
|
+
left.kind === "tau" &&
|
|
195
|
+
right.kind === "tau" &&
|
|
196
|
+
!isNotEquiv(left.args[1]) &&
|
|
197
|
+
!isNotEquiv(right.args[1])
|
|
198
|
+
) {
|
|
199
|
+
const bound = exprs.newVar();
|
|
200
|
+
const leftBody = exprs.substitute([[left.args[0], bound]], left.args[1]);
|
|
201
|
+
const rightBody = exprs.substitute([[right.args[0], bound]], right.args[1]);
|
|
202
|
+
const differ = exprs.eex(bound, left.symbol, exprs.eapp("$notequiv", [leftBody, rightBody]));
|
|
203
|
+
return node(
|
|
204
|
+
{ instance: differ },
|
|
205
|
+
makeRule("choose_diff_choose", [
|
|
206
|
+
formula,
|
|
207
|
+
differ,
|
|
208
|
+
exprs.elam(left.args[0], left.symbol, left.args[1]),
|
|
209
|
+
exprs.elam(right.args[0], right.symbol, right.args[1]),
|
|
210
|
+
]),
|
|
211
|
+
[[differ]],
|
|
212
|
+
);
|
|
213
|
+
}
|
|
214
|
+
if (!isNegated && relation.symbol === "$notequiv")
|
|
215
|
+
return node("arity", makeRule("notequivdef", []), [[exprs.enot(exprs.eequiv(left, right))]]);
|
|
216
|
+
const choice = right.kind === "tau" ? right : left.kind === "tau" ? left : undefined;
|
|
217
|
+
if (isNegated && isEquality && choice !== undefined) {
|
|
218
|
+
const term = right.kind === "tau" ? left : right;
|
|
219
|
+
const exists = exprs.eex(choice.args[0], choice.symbol, choice.args[1]);
|
|
220
|
+
const notExists = exprs.enot(exists);
|
|
221
|
+
const notHolds = exprs.enot(exprs.substitute([[choice.args[0], term]], choice.args[1]));
|
|
222
|
+
return [
|
|
223
|
+
{
|
|
224
|
+
conclusions: [],
|
|
225
|
+
rule: makeRule("notequalchoose", [
|
|
226
|
+
exists,
|
|
227
|
+
notExists,
|
|
228
|
+
notHolds,
|
|
229
|
+
exprs.elam(choice.args[0], choice.symbol, choice.args[1]),
|
|
230
|
+
term,
|
|
231
|
+
]),
|
|
232
|
+
priority: { instance: notExists },
|
|
233
|
+
goalness,
|
|
234
|
+
branches: [[exists], [notExists, notHolds]],
|
|
235
|
+
},
|
|
236
|
+
];
|
|
237
|
+
}
|
|
238
|
+
return undefined;
|
|
239
|
+
};
|
|
240
|
+
|
|
241
|
+
// The bounded quantifier over an enumerated set in \A x : x \in S => P or ~\E x : x \in S /\ P.
|
|
242
|
+
const getEnumeratedQuantifier = (formula: Expr) => {
|
|
243
|
+
const isEnumerated = (set: Expr) =>
|
|
244
|
+
isVariable(set, "TLA.emptyset") ||
|
|
245
|
+
(set.kind === "app" &&
|
|
246
|
+
["TLA.addElt", "TLA.upair", "TLA.set", "TLA.union"].includes(set.symbol));
|
|
247
|
+
if (formula.kind === "all") {
|
|
248
|
+
const body = formula.args[1];
|
|
249
|
+
if (
|
|
250
|
+
body.kind === "imply" &&
|
|
251
|
+
isApp(body.args[0], "TLA.in", 2) &&
|
|
252
|
+
isEnumerated(body.args[0].args[1])
|
|
253
|
+
)
|
|
254
|
+
return { quantified: formula, set: body.args[0].args[1] };
|
|
255
|
+
}
|
|
256
|
+
if (formula.kind === "not" && formula.args[0].kind === "ex") {
|
|
257
|
+
const body = formula.args[0].args[1];
|
|
258
|
+
if (
|
|
259
|
+
body.kind === "and" &&
|
|
260
|
+
isApp(body.args[0], "TLA.in", 2) &&
|
|
261
|
+
isEnumerated(body.args[0].args[1])
|
|
262
|
+
)
|
|
263
|
+
return { quantified: formula.args[0], set: body.args[0].args[1] };
|
|
264
|
+
}
|
|
265
|
+
return undefined;
|
|
266
|
+
};
|
|
267
|
+
|
|
268
|
+
const getEnumeratedNodes = (literal: Literal): Item[] | undefined => {
|
|
269
|
+
const formula = literal.formula;
|
|
270
|
+
const instance = (priority: Priority, quantified: Expr, term: Expr) =>
|
|
271
|
+
makeInstanceNode(literal, priority, quantified, term);
|
|
272
|
+
const enumerated = getEnumeratedQuantifier(formula);
|
|
273
|
+
if (enumerated !== undefined) {
|
|
274
|
+
const values = getSetValues(enumerated.set);
|
|
275
|
+
const nodes: Item[] = values[0].flatMap((value) =>
|
|
276
|
+
instance("arity", enumerated.quantified, value),
|
|
277
|
+
);
|
|
278
|
+
return values[1] ? nodes : [...nodes, "stop"];
|
|
279
|
+
}
|
|
280
|
+
return undefined;
|
|
281
|
+
};
|
|
282
|
+
|
|
283
|
+
const getNaturalNodes = (literal: Literal): Item[] | undefined => {
|
|
284
|
+
const exprs = literal.context.exprs;
|
|
285
|
+
const formula = literal.formula;
|
|
286
|
+
const isNegated = literal.isNegated;
|
|
287
|
+
const relation = literal.relation;
|
|
288
|
+
const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
|
|
289
|
+
makeExtensionNode(literal, priority, rule, branches);
|
|
290
|
+
const instance = (priority: Priority, quantified: Expr, term: Expr) =>
|
|
291
|
+
makeInstanceNode(literal, priority, quantified, term);
|
|
292
|
+
if (isNegated && relation?.symbol === "TLA.in" && isVariable(relation.args[1], "arith.N")) {
|
|
293
|
+
const left = relation.args[0];
|
|
294
|
+
if (isVariable(left, "0")) return node("prop", makeRule("in_nat_0", [formula]), []);
|
|
295
|
+
if (isApp(left, "TLA.fapply", 2) && isVariable(left.args[0], "TLA.Succ")) {
|
|
296
|
+
const previous = exprs.enot(member(exprs, left.args[1], exprs.evar("arith.N")));
|
|
297
|
+
return node("prop", makeRule("in_nat_succ", [formula, previous, left.args[1]]), [[previous]]);
|
|
298
|
+
}
|
|
299
|
+
if (left.kind === "meta")
|
|
300
|
+
return instance({ instance: left.args[0] }, left.args[0], exprs.evar("0"));
|
|
301
|
+
}
|
|
302
|
+
return undefined;
|
|
303
|
+
};
|
|
304
|
+
|
|
305
|
+
const getPropNodes = (context: TlaContext, formula: Expr, goalness: number): Item[] => {
|
|
306
|
+
const literal = getLiteral(context, formula, goalness);
|
|
307
|
+
return (
|
|
308
|
+
getBooleanNodes(literal) ??
|
|
309
|
+
getMembershipNodes(literal) ??
|
|
310
|
+
getFunctionSetNodes(literal) ??
|
|
311
|
+
getSetEqualityNodes(literal) ??
|
|
312
|
+
getFunctionNodes(literal) ??
|
|
313
|
+
getChoiceNodes(literal) ??
|
|
314
|
+
getEnumeratedNodes(literal) ??
|
|
315
|
+
getNaturalNodes(literal) ??
|
|
316
|
+
getMetaMembershipNodes(literal) ??
|
|
317
|
+
(!literal.isNegated && isApp(literal.atom, "TLA.box", 1)
|
|
318
|
+
? makeExtensionNode(literal, "prop", makeRule("box_p", [formula, literal.atom.args[0]]), [
|
|
319
|
+
[literal.atom.args[0]],
|
|
320
|
+
])
|
|
321
|
+
: undefined) ??
|
|
322
|
+
getTupleNodes(literal) ??
|
|
323
|
+
getRecordNodes(literal) ??
|
|
324
|
+
getSubsetNodes(literal) ??
|
|
325
|
+
[]
|
|
326
|
+
);
|
|
327
|
+
};
|
|
328
|
+
|
|
329
|
+
// Zenon's newnodes_inst_bounded: instantiates \A x \in S : P and ~\E x \in S : P with the terms
|
|
330
|
+
// known to be in S.
|
|
331
|
+
const getBoundedInstances = (context: TlaContext, formula: Expr, goalness: number): Node[] => {
|
|
332
|
+
const exprs = context.exprs;
|
|
333
|
+
const index = context.index;
|
|
334
|
+
const makeNode = (
|
|
335
|
+
name: "all_in" | "notex_in",
|
|
336
|
+
bounded: Expr,
|
|
337
|
+
membership: Expr,
|
|
338
|
+
set: Expr,
|
|
339
|
+
predicate: Expr,
|
|
340
|
+
term: Expr,
|
|
341
|
+
): Node => {
|
|
342
|
+
const instance =
|
|
343
|
+
name === "all_in" ? exprs.apply(predicate, term) : exprs.enot(exprs.apply(predicate, term));
|
|
344
|
+
return {
|
|
345
|
+
conclusions: bounded === formula ? [membership, formula] : [formula, bounded],
|
|
346
|
+
rule: makeRule(name, [bounded, membership, instance, set, predicate]),
|
|
347
|
+
priority: { instance: formula },
|
|
348
|
+
goalness,
|
|
349
|
+
branches: [[instance]],
|
|
350
|
+
};
|
|
351
|
+
};
|
|
352
|
+
const getTermsIn = (set: Expr) =>
|
|
353
|
+
index
|
|
354
|
+
.findPositive("TLA.in")
|
|
355
|
+
.map((entry) => entry[0])
|
|
356
|
+
.filter(
|
|
357
|
+
(membership): membership is RelationExpr =>
|
|
358
|
+
isApp(membership, "TLA.in", 2) &&
|
|
359
|
+
membership.args[0].metas.length === 0 &&
|
|
360
|
+
membership.args[1] === set,
|
|
361
|
+
);
|
|
362
|
+
if (isApp(formula, "TLA.in", 2) && formula.args[0].metas.length === 0) {
|
|
363
|
+
const term = formula.args[0];
|
|
364
|
+
const set = formula.args[1];
|
|
365
|
+
const universals = index
|
|
366
|
+
.findPositive("TLA.bAll")
|
|
367
|
+
.map((entry) => entry[0])
|
|
368
|
+
.filter(
|
|
369
|
+
(bounded): bounded is RelationExpr =>
|
|
370
|
+
isApp(bounded, "TLA.bAll", 2) && bounded.args[0] === set,
|
|
371
|
+
);
|
|
372
|
+
const existentials = index
|
|
373
|
+
.findNegative("TLA.bEx")
|
|
374
|
+
.map((entry) => entry[0])
|
|
375
|
+
.filter(
|
|
376
|
+
(bounded): bounded is NegatedRelationExpr =>
|
|
377
|
+
bounded.kind === "not" &&
|
|
378
|
+
isApp(bounded.args[0], "TLA.bEx", 2) &&
|
|
379
|
+
bounded.args[0].args[0] === set,
|
|
380
|
+
);
|
|
381
|
+
const notExists = existentials.map((bounded) =>
|
|
382
|
+
makeNode("notex_in", bounded, formula, set, bounded.args[0].args[1], term),
|
|
383
|
+
);
|
|
384
|
+
const forAll = universals.map((bounded) =>
|
|
385
|
+
makeNode("all_in", bounded, formula, set, bounded.args[1], term),
|
|
386
|
+
);
|
|
387
|
+
return [...forAll.reverse(), ...notExists];
|
|
388
|
+
}
|
|
389
|
+
if (isApp(formula, "TLA.bAll", 2))
|
|
390
|
+
return getTermsIn(formula.args[0]).map((membership) =>
|
|
391
|
+
makeNode("all_in", formula, membership, formula.args[0], formula.args[1], membership.args[0]),
|
|
392
|
+
);
|
|
393
|
+
if (formula.kind === "not" && isApp(formula.args[0], "TLA.bEx", 2)) {
|
|
394
|
+
const bounded = formula.args[0];
|
|
395
|
+
return getTermsIn(bounded.args[0]).map((membership) =>
|
|
396
|
+
makeNode(
|
|
397
|
+
"notex_in",
|
|
398
|
+
formula,
|
|
399
|
+
membership,
|
|
400
|
+
bounded.args[0],
|
|
401
|
+
bounded.args[1],
|
|
402
|
+
membership.args[0],
|
|
403
|
+
),
|
|
404
|
+
);
|
|
405
|
+
}
|
|
406
|
+
return [];
|
|
407
|
+
};
|
|
408
|
+
|
|
409
|
+
const makePropositionEqualityNode = (
|
|
410
|
+
exprs: Expressions,
|
|
411
|
+
name: "p_eq_l" | "p_eq_r" | "np_eq_l" | "np_eq_r",
|
|
412
|
+
formula: Expr,
|
|
413
|
+
left: Expr,
|
|
414
|
+
right: Expr,
|
|
415
|
+
goalness: number,
|
|
416
|
+
): Node => {
|
|
417
|
+
const isNegated = name === "np_eq_l" || name === "np_eq_r";
|
|
418
|
+
const isLeft = name === "p_eq_l" || name === "np_eq_l";
|
|
419
|
+
const proposition = isNegated && formula.kind === "not" ? formula.args[0] : formula;
|
|
420
|
+
const equality = equal(exprs, left, right);
|
|
421
|
+
const differ = exprs.enot(equal(exprs, proposition, isLeft ? left : right));
|
|
422
|
+
const other = isLeft ? right : left;
|
|
423
|
+
const rest = isNegated ? exprs.enot(other) : other;
|
|
424
|
+
return {
|
|
425
|
+
conclusions: [formula, equality],
|
|
426
|
+
rule: makeRule(
|
|
427
|
+
name,
|
|
428
|
+
isNegated
|
|
429
|
+
? [formula, equality, differ, rest, proposition, left, right]
|
|
430
|
+
: [formula, equality, differ, other, formula, left, right],
|
|
431
|
+
),
|
|
432
|
+
priority: "arity_eq",
|
|
433
|
+
goalness,
|
|
434
|
+
branches: [[differ], [rest]],
|
|
435
|
+
};
|
|
436
|
+
};
|
|
437
|
+
|
|
438
|
+
const getPropositionEqualityNodes = (context: TlaContext, formula: Expr, goalness: number) => {
|
|
439
|
+
const exprs = context.exprs;
|
|
440
|
+
const index = context.index;
|
|
441
|
+
const atom = formula.kind === "not" ? formula.args[0] : formula;
|
|
442
|
+
if (atom.kind !== "app") return [];
|
|
443
|
+
const isNegated = formula.kind === "not";
|
|
444
|
+
const make = (isLeft: boolean) => (entry: [RelationExpr, number]) =>
|
|
445
|
+
makePropositionEqualityNode(
|
|
446
|
+
exprs,
|
|
447
|
+
isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
|
|
448
|
+
formula,
|
|
449
|
+
entry[0].args[0],
|
|
450
|
+
entry[0].args[1],
|
|
451
|
+
goalness,
|
|
452
|
+
);
|
|
453
|
+
return [
|
|
454
|
+
...index.findTransLeft("=", atom.symbol).map(make(true)),
|
|
455
|
+
...index.findTransRight("=", atom.symbol).map(make(false)),
|
|
456
|
+
];
|
|
457
|
+
};
|
|
458
|
+
|
|
459
|
+
const getEqualityPropositionNodes = (
|
|
460
|
+
context: TlaContext,
|
|
461
|
+
formula: Expr,
|
|
462
|
+
isLeft: boolean,
|
|
463
|
+
): Node[] => {
|
|
464
|
+
const exprs = context.exprs;
|
|
465
|
+
if (!isApp(formula, "=", 2)) return [];
|
|
466
|
+
const term = formula.args[isLeft ? 0 : 1];
|
|
467
|
+
if (term.kind !== "app") return [];
|
|
468
|
+
const index = context.index;
|
|
469
|
+
const make = (isNegated: boolean) => (entry: [Expr, number]) =>
|
|
470
|
+
makePropositionEqualityNode(
|
|
471
|
+
exprs,
|
|
472
|
+
isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
|
|
473
|
+
entry[0],
|
|
474
|
+
formula.args[0],
|
|
475
|
+
formula.args[1],
|
|
476
|
+
entry[1],
|
|
477
|
+
);
|
|
478
|
+
return [
|
|
479
|
+
...index.findPositive(term.symbol).map(make(false)),
|
|
480
|
+
...index.findNegative(term.symbol).map(make(true)),
|
|
481
|
+
];
|
|
482
|
+
};
|
|
483
|
+
|
|
484
|
+
export interface ExtensionNodes {
|
|
485
|
+
nodes: Node[];
|
|
486
|
+
isStopped: boolean;
|
|
487
|
+
}
|
|
488
|
+
|
|
489
|
+
export const getExtensionNodes = (
|
|
490
|
+
context: TlaContext,
|
|
491
|
+
formula: Expr,
|
|
492
|
+
goalness: number,
|
|
493
|
+
): ExtensionNodes => {
|
|
494
|
+
// OCaml evaluates the operands of @ right to left, so the last rules run first. The order
|
|
495
|
+
// decides the names of fresh variables.
|
|
496
|
+
const bounded = getBoundedInstances(context, formula, goalness);
|
|
497
|
+
const right = getEqualityPropositionNodes(context, formula, false);
|
|
498
|
+
const left = getEqualityPropositionNodes(context, formula, true);
|
|
499
|
+
const propositions = getPropositionEqualityNodes(context, formula, goalness);
|
|
500
|
+
const rewrites = getRewriteNodes(context, formula, goalness);
|
|
501
|
+
const props = getPropNodes(context, formula, goalness);
|
|
502
|
+
const items = [...props, ...rewrites, ...propositions, ...left, ...right, ...bounded];
|
|
503
|
+
const stop = items.indexOf("stop");
|
|
504
|
+
const kept = stop === -1 ? items : items.slice(0, stop);
|
|
505
|
+
return { nodes: kept.filter((item): item is Node => item !== "stop"), isStopped: stop !== -1 };
|
|
506
|
+
};
|
package/src/run-cli.ts
CHANGED
|
@@ -7,7 +7,6 @@ import {
|
|
|
7
7
|
realpathSync,
|
|
8
8
|
writeFileSync,
|
|
9
9
|
} from "node:fs";
|
|
10
|
-
import { spawnSync } from "node:child_process";
|
|
11
10
|
import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
|
|
12
11
|
import { arch, availableParallelism, release, tmpdir, type } from "node:os";
|
|
13
12
|
import { pathToFileURL } from "node:url";
|
|
@@ -42,11 +41,12 @@ import {
|
|
|
42
41
|
TlaUnsupportedError,
|
|
43
42
|
} from "./errors";
|
|
44
43
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
45
|
-
import type { LineRange } from "./
|
|
46
|
-
import { getAtPrefix, getLocusText } from "./
|
|
44
|
+
import type { LineRange } from "./obligations/generate";
|
|
45
|
+
import { getAtPrefix, getLocusText } from "./obligations/expression";
|
|
47
46
|
import { formatSummary, getObligations, WHOLE_MODULE, type ModuleObligations } from "./obligations";
|
|
48
47
|
import { check } from "./parallel";
|
|
49
48
|
import { parseModule } from "./parser";
|
|
49
|
+
import { isProveBackend, prove, PROVE_BACKENDS, type ProofStatus } from "./prove/prove";
|
|
50
50
|
import type { StateDump } from "./state-graph";
|
|
51
51
|
import {
|
|
52
52
|
formatProbability,
|
|
@@ -54,6 +54,7 @@ import {
|
|
|
54
54
|
getOptimisticProbability,
|
|
55
55
|
getOutDegreeSummary,
|
|
56
56
|
} from "./tlc-summary";
|
|
57
|
+
import { getTlapmPaths } from "./prove/tlapm/tlapm";
|
|
57
58
|
import type { SanySpecification } from "./sany-generator";
|
|
58
59
|
import { SANY_174_STANDARD_MODULES, SANY_STANDARD_MODULES } from "./sany-modules";
|
|
59
60
|
import { getSanyModuleName, getSanyReport, type SanyModuleOrigin } from "./sany-report";
|
|
@@ -101,7 +102,7 @@ const CHECK_COMMAND = defineCommand("tla-ts <Spec.tla|Spec.cfg|glob>... {options
|
|
|
101
102
|
{ flag: "-workers <count|auto>" },
|
|
102
103
|
]);
|
|
103
104
|
|
|
104
|
-
const
|
|
105
|
+
const OBLIGATIONS_COMMAND = defineCommand("tla-ts prove {options} <Module.tla|glob>...", [
|
|
105
106
|
{ flag: "-N", isRequired: true },
|
|
106
107
|
{ flag: "--toolbox <start> <end>" },
|
|
107
108
|
{ flag: "--line <num>" },
|
|
@@ -111,6 +112,12 @@ const PROVE_COMMAND = defineCommand("tla-ts prove {options} <Module.tla|glob>...
|
|
|
111
112
|
{ flag: "-I <directory>", isRepeatable: true },
|
|
112
113
|
]);
|
|
113
114
|
|
|
115
|
+
const PROVE_COMMAND = defineCommand("tla-ts prove {options} <Module.tla|glob>...", [
|
|
116
|
+
{ flag: `--backend <${PROVE_BACKENDS.join("|")}>` },
|
|
117
|
+
{ flag: "-I <directory>", isRepeatable: true },
|
|
118
|
+
{ flag: "-workers <count|auto>" },
|
|
119
|
+
]);
|
|
120
|
+
|
|
114
121
|
const XML_EXPORT_FLAGS = new Set(["-o", "-t", "-r", "-u"]);
|
|
115
122
|
|
|
116
123
|
const XML_EXPORT_174_FLAGS = new Set(["-o"]);
|
|
@@ -166,7 +173,7 @@ const XML_EXPORT_USAGE = (() => {
|
|
|
166
173
|
const USAGE = [
|
|
167
174
|
`Usage: ${CHECK_COMMAND.usage}`,
|
|
168
175
|
` ${PROVE_COMMAND.usage}`,
|
|
169
|
-
|
|
176
|
+
` ${OBLIGATIONS_COMMAND.usage}`,
|
|
170
177
|
" tla-ts [<JVM option>]... tlc2.TLC <TLC option>... <Spec>",
|
|
171
178
|
" (-cp tla2tools.jar or -Dtla-ts.tlc=1.7.4 picks the TLC to reproduce)",
|
|
172
179
|
" tla-ts [<JVM option>]... tla2sany.xml.XMLExporter [-I <directory>]... [-o] [-t] [-r] [-u] <Module.tla>",
|
|
@@ -1043,12 +1050,6 @@ const runEach = async (
|
|
|
1043
1050
|
|
|
1044
1051
|
// tlapm installs its standard library, with modules such as TLAPS, at lib/tlapm/stdlib beside
|
|
1045
1052
|
// bin/tlapm.
|
|
1046
|
-
const getTlapmPaths = () =>
|
|
1047
|
-
(process.env.PATH ?? "")
|
|
1048
|
-
.split(delimiter)
|
|
1049
|
-
.map((directory) => join(directory, "tlapm"))
|
|
1050
|
-
.filter((path) => existsSync(path));
|
|
1051
|
-
|
|
1052
1053
|
const getTlapmLibrary = () =>
|
|
1053
1054
|
getTlapmPaths()
|
|
1054
1055
|
.map((path) => join(dirname(dirname(realpathSync(path))), "lib/tlapm/stdlib"))
|
|
@@ -1057,17 +1058,6 @@ const getTlapmLibrary = () =>
|
|
|
1057
1058
|
const expandGlobs = (paths: string[]) =>
|
|
1058
1059
|
paths.flatMap((path) => (GLOB_CHARACTERS.test(path) ? globSync(path).sort() : [path]));
|
|
1059
1060
|
|
|
1060
|
-
const proveWithTlapm = (args: string[]) => {
|
|
1061
|
-
const tlapm = getTlapmPaths()[0];
|
|
1062
|
-
if (tlapm === undefined) {
|
|
1063
|
-
console.error(
|
|
1064
|
-
"Error: tla-ts prove runs tlapm to prove obligations, but tlapm isn't on your PATH. Install tlapm, or pass -N to only generate the obligations.",
|
|
1065
|
-
);
|
|
1066
|
-
return 1;
|
|
1067
|
-
}
|
|
1068
|
-
return spawnSync(tlapm, expandGlobs(args), { stdio: "inherit" }).status ?? 1;
|
|
1069
|
-
};
|
|
1070
|
-
|
|
1071
1061
|
const readModule = (path: string) =>
|
|
1072
1062
|
existsSync(path) ? { file: path, source: readFileSync(path, "utf8") } : undefined;
|
|
1073
1063
|
|
|
@@ -1123,9 +1113,62 @@ const generateObligations = (generate: () => ModuleObligations[]) => {
|
|
|
1123
1113
|
}
|
|
1124
1114
|
};
|
|
1125
1115
|
|
|
1126
|
-
|
|
1127
|
-
|
|
1116
|
+
// tla-ts prove: proves each module with prove, printing each obligation as it ends.
|
|
1117
|
+
const proveModules = (args: string[]) => {
|
|
1128
1118
|
const parsed = PROVE_COMMAND.parse(args);
|
|
1119
|
+
const backend = parsed.get("--backend")?.[0];
|
|
1120
|
+
if (
|
|
1121
|
+
parsed.unknown[0] !== undefined ||
|
|
1122
|
+
parsed.incomplete ||
|
|
1123
|
+
(backend !== undefined && !isProveBackend(backend))
|
|
1124
|
+
) {
|
|
1125
|
+
console.error(`Usage: ${PROVE_COMMAND.usage}`);
|
|
1126
|
+
return 1;
|
|
1127
|
+
}
|
|
1128
|
+
const modulePaths = expandGlobs(parsed.positionals).map((path) =>
|
|
1129
|
+
path.endsWith(".tla") ? path : `${path}.tla`,
|
|
1130
|
+
);
|
|
1131
|
+
if (modulePaths.length === 0) {
|
|
1132
|
+
console.error(`Usage: ${PROVE_COMMAND.usage}`);
|
|
1133
|
+
return 1;
|
|
1134
|
+
}
|
|
1135
|
+
const tlapmLibrary = getTlapmLibrary();
|
|
1136
|
+
const includes = parsed.options.flatMap((option) => (option.name === "-I" ? option.values : []));
|
|
1137
|
+
return runEach(
|
|
1138
|
+
modulePaths,
|
|
1139
|
+
async (path) => {
|
|
1140
|
+
const directories = [
|
|
1141
|
+
dirname(path),
|
|
1142
|
+
".",
|
|
1143
|
+
...(tlapmLibrary ? [tlapmLibrary] : []),
|
|
1144
|
+
...includes.toReversed(),
|
|
1145
|
+
];
|
|
1146
|
+
const result = await prove({
|
|
1147
|
+
source: readFileSync(path, "utf8"),
|
|
1148
|
+
loadModule: (name) =>
|
|
1149
|
+
directories.map((directory) => readModule(`${directory}/${name}.tla`)).find(Boolean)
|
|
1150
|
+
?.source,
|
|
1151
|
+
backend,
|
|
1152
|
+
workers: getWorkerCount(parsed.get("-workers")),
|
|
1153
|
+
onObligation: (obligation) =>
|
|
1154
|
+
console.log(
|
|
1155
|
+
`${path}:${obligation.location}: ${obligation.status}${obligation.status === "proved" ? ` by ${obligation.prover}` : ""}${obligation.status === "failed" || obligation.status === "unsupported" ? ` (${obligation.reason})` : ""}`,
|
|
1156
|
+
),
|
|
1157
|
+
});
|
|
1158
|
+
const counts = Map.groupBy(result.obligations, (obligation) => obligation.status);
|
|
1159
|
+
const getCount = (status: ProofStatus) => counts.get(status)?.length ?? 0;
|
|
1160
|
+
console.log(
|
|
1161
|
+
`${result.obligations.length} obligations: ${getCount("proved")} proved, ${getCount("trivial")} trivial, ${getCount("failed")} failed, ${getCount("unsupported")} unsupported`,
|
|
1162
|
+
);
|
|
1163
|
+
return getCount("failed") + getCount("unsupported") === 0 ? EXIT_STATUS.success : 1;
|
|
1164
|
+
},
|
|
1165
|
+
() => createMessagePrinter(false),
|
|
1166
|
+
);
|
|
1167
|
+
};
|
|
1168
|
+
|
|
1169
|
+
const runProve = (args: string[]) => {
|
|
1170
|
+
if (!args.includes("-N") && !args.includes("--summary")) return proveModules(args);
|
|
1171
|
+
const parsed = OBLIGATIONS_COMMAND.parse(args);
|
|
1129
1172
|
const unsupported = parsed.unknown[0];
|
|
1130
1173
|
if (unsupported !== undefined) {
|
|
1131
1174
|
console.error(`Error: tla-ts prove does not support the tlapm option ${unsupported}.`);
|
|
@@ -1534,7 +1577,7 @@ const runJavaClass = (launch: JavaLaunch) => {
|
|
|
1534
1577
|
};
|
|
1535
1578
|
|
|
1536
1579
|
const run = async (args: string[]) => {
|
|
1537
|
-
if (args[0] === "prove") return reportErrors(() =>
|
|
1580
|
+
if (args[0] === "prove") return reportErrors(() => runProve(args.slice(1)));
|
|
1538
1581
|
const launch = getJavaLaunch(args);
|
|
1539
1582
|
if (launch === undefined) return checkSpecs(args, { libraries: [] });
|
|
1540
1583
|
// The TLC that -Dtla-ts.tlc names, or else the one of the jar on the class path.
|
package/src/values.ts
CHANGED
|
@@ -625,9 +625,14 @@ export const valuesEqual = (left: Value, right: Value): boolean => {
|
|
|
625
625
|
// TLC prints and words errors about an equal function by its Java class, so a value can stand for
|
|
626
626
|
// another in a state only if each function in it has the same class.
|
|
627
627
|
const createSameValueCheck = (isClassSensitive: boolean) => {
|
|
628
|
-
const areSameValues = (left: Value[], right: Value[]) =>
|
|
629
|
-
left === right
|
|
630
|
-
(left.length
|
|
628
|
+
const areSameValues = (left: Value[], right: Value[]) => {
|
|
629
|
+
if (left === right) return true;
|
|
630
|
+
if (left.length !== right.length) return false;
|
|
631
|
+
for (let index = 0; index < left.length; index++) {
|
|
632
|
+
if (!isSame(left[index], right[index])) return false;
|
|
633
|
+
}
|
|
634
|
+
return true;
|
|
635
|
+
};
|
|
631
636
|
const isSame = (left: Value, right: Value): boolean => {
|
|
632
637
|
if (left === right) return true;
|
|
633
638
|
if (typeof left !== "object" || typeof right !== "object") return false;
|