tla-ts 0.0.4-dev.a0009b7 → 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 +37 -1
- package/dist/index.d.ts +37 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -4
- package/dist/parallel-worker.js +1 -4
- package/dist/prove-worker.cjs +9 -0
- package/dist/prove-worker.d.cts +9 -0
- package/dist/prove-worker.d.ts +9 -0
- package/dist/prove-worker.js +9 -0
- package/dist/prove.cjs +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 +26 -7
- package/src/errors.ts +86 -0
- package/src/evaluate.ts +63 -20
- 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 +97 -47
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,297 @@
|
|
|
1
|
+
// Ported from Zenon's node.ml and heap.ml, as shipped in tlapm. Copyright 2001-2004 INRIA, see
|
|
2
|
+
// LICENSE.
|
|
3
|
+
//
|
|
4
|
+
// Tableau nodes and the queue that orders them. The search keeps the queue of every open branch,
|
|
5
|
+
// so the queue is persistent: inserting or removing returns a new queue and shares the rest.
|
|
6
|
+
|
|
7
|
+
import type { Expr } from "./expr";
|
|
8
|
+
import type { Rule } from "./proof";
|
|
9
|
+
|
|
10
|
+
export type Priority = "prop" | "arity" | "arity_eq" | { instance: Expr };
|
|
11
|
+
|
|
12
|
+
export interface Node {
|
|
13
|
+
conclusions: Expr[];
|
|
14
|
+
rule: Rule;
|
|
15
|
+
priority: Priority;
|
|
16
|
+
goalness: number;
|
|
17
|
+
branches: Expr[][];
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
export interface Cons<Item> {
|
|
21
|
+
head: Item;
|
|
22
|
+
tail: Cons<Item> | undefined;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
type List<Item> = Cons<Item> | undefined;
|
|
26
|
+
|
|
27
|
+
const cons = <Item>(head: Item, tail: List<Item>): Cons<Item> => ({ head, tail });
|
|
28
|
+
|
|
29
|
+
const reverse = <Item>(list: List<Item>) => {
|
|
30
|
+
let result: List<Item> = undefined;
|
|
31
|
+
for (let cell = list; cell !== undefined; cell = cell.tail) result = cons(cell.head, result);
|
|
32
|
+
return result;
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
// A node in the instance heap, with the size of the term that instantiates its formula.
|
|
36
|
+
interface Entry {
|
|
37
|
+
node: Node;
|
|
38
|
+
size: number;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
interface Tree {
|
|
42
|
+
entry: Entry;
|
|
43
|
+
left: Tree | undefined;
|
|
44
|
+
right: Tree | undefined;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
// Zenon's Heap: a persistent binary heap that alternates insertion paths.
|
|
48
|
+
interface Heap {
|
|
49
|
+
tree: Tree | undefined;
|
|
50
|
+
path: number;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
const META_WEIGHT = 5;
|
|
54
|
+
const TAU_DIVISOR = 8;
|
|
55
|
+
|
|
56
|
+
const getInstanceSize = (term: Expr) =>
|
|
57
|
+
term.size + term.metas.length * META_WEIGHT + Math.floor(term.taus / TAU_DIVISOR);
|
|
58
|
+
|
|
59
|
+
const insertTree = (tree: Tree | undefined, entry: Entry, path: number): Tree => {
|
|
60
|
+
if (tree === undefined) return { entry, left: undefined, right: undefined };
|
|
61
|
+
const isSmaller = entry.size < tree.entry.size;
|
|
62
|
+
const here = isSmaller ? entry : tree.entry;
|
|
63
|
+
const next = isSmaller ? tree.entry : entry;
|
|
64
|
+
const nextPath = Math.floor(path / 2);
|
|
65
|
+
return path % 2 === 0
|
|
66
|
+
? { entry: here, left: insertTree(tree.left, next, nextPath), right: tree.right }
|
|
67
|
+
: { entry: here, left: tree.left, right: insertTree(tree.right, next, nextPath) };
|
|
68
|
+
};
|
|
69
|
+
|
|
70
|
+
const insertHeap = (heap: Heap, entry: Entry): Heap => ({
|
|
71
|
+
tree: insertTree(heap.tree, entry, heap.path),
|
|
72
|
+
path: heap.path + 1,
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
const removeTree = (tree: Tree): [Entry, Tree | undefined] => {
|
|
76
|
+
if (tree.left === undefined) return [tree.entry, tree.right];
|
|
77
|
+
if (tree.right === undefined) return [tree.entry, tree.left];
|
|
78
|
+
const isLeftFirst = tree.left.entry.size < tree.right.entry.size;
|
|
79
|
+
const first = isLeftFirst ? tree.left : tree.right;
|
|
80
|
+
const second = isLeftFirst ? tree.right : tree.left;
|
|
81
|
+
const removed = removeTree(first);
|
|
82
|
+
return [tree.entry, { entry: removed[0], left: removed[1], right: second }];
|
|
83
|
+
};
|
|
84
|
+
|
|
85
|
+
const removeHeap = (heap: Heap): [Node, Heap] | undefined => {
|
|
86
|
+
if (heap.tree === undefined) return undefined;
|
|
87
|
+
const removed = removeTree(heap.tree);
|
|
88
|
+
return [removed[0].node, { tree: removed[1], path: heap.path }];
|
|
89
|
+
};
|
|
90
|
+
|
|
91
|
+
export interface Queue {
|
|
92
|
+
prop1: List<Node>;
|
|
93
|
+
prop2: List<Node>;
|
|
94
|
+
unary: List<Node>;
|
|
95
|
+
binary: List<Node>;
|
|
96
|
+
nary: List<Node>;
|
|
97
|
+
eqFront: List<Node>;
|
|
98
|
+
eqBack: List<Node>;
|
|
99
|
+
eqCount: number;
|
|
100
|
+
instState: number;
|
|
101
|
+
instSize: List<[number, Heap]>;
|
|
102
|
+
instFront: List<Node>;
|
|
103
|
+
instBack: List<Node>;
|
|
104
|
+
// The nodes inserted since the root. Removed nodes still count, because the queues of the
|
|
105
|
+
// branches above keep them.
|
|
106
|
+
insertedCount: number;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
const SMALL_INSTANCES = 16;
|
|
110
|
+
const OLD_INSTANCES = 2;
|
|
111
|
+
const MAX_INSTANCES = SMALL_INSTANCES + OLD_INSTANCES;
|
|
112
|
+
const EQUALITY_COUNT = 10;
|
|
113
|
+
|
|
114
|
+
export const EMPTY_QUEUE: Queue = {
|
|
115
|
+
prop1: undefined,
|
|
116
|
+
prop2: undefined,
|
|
117
|
+
unary: undefined,
|
|
118
|
+
binary: undefined,
|
|
119
|
+
nary: undefined,
|
|
120
|
+
eqFront: undefined,
|
|
121
|
+
eqBack: undefined,
|
|
122
|
+
eqCount: EQUALITY_COUNT,
|
|
123
|
+
instState: 0,
|
|
124
|
+
instSize: undefined,
|
|
125
|
+
instFront: undefined,
|
|
126
|
+
instBack: undefined,
|
|
127
|
+
insertedCount: 0,
|
|
128
|
+
};
|
|
129
|
+
|
|
130
|
+
const insertByGoalness = (list: List<[number, Heap]>, entry: Entry): List<[number, Heap]> => {
|
|
131
|
+
const goalness = entry.node.goalness;
|
|
132
|
+
let heap: Heap = { tree: undefined, path: 0 };
|
|
133
|
+
for (let cell = list; cell !== undefined; cell = cell.tail)
|
|
134
|
+
if (cell.head[0] === goalness) {
|
|
135
|
+
heap = cell.head[1];
|
|
136
|
+
break;
|
|
137
|
+
}
|
|
138
|
+
const inserted: [number, Heap] = [goalness, insertHeap(heap, entry)];
|
|
139
|
+
const insert = (rest: List<[number, Heap]>): Cons<[number, Heap]> => {
|
|
140
|
+
if (rest === undefined) return cons(inserted, undefined);
|
|
141
|
+
if (rest.head[0] === goalness) return cons(inserted, rest.tail);
|
|
142
|
+
if (rest.head[0] > goalness) return cons(inserted, rest);
|
|
143
|
+
return cons(rest.head, insert(rest.tail));
|
|
144
|
+
};
|
|
145
|
+
return insert(list);
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
const canInstantiate = (meta: Expr, expression: Expr): boolean => {
|
|
149
|
+
switch (expression.kind) {
|
|
150
|
+
case "var":
|
|
151
|
+
case "true":
|
|
152
|
+
case "false":
|
|
153
|
+
return true;
|
|
154
|
+
case "meta":
|
|
155
|
+
return !expression.args[0].metas.includes(meta);
|
|
156
|
+
case "all":
|
|
157
|
+
case "ex":
|
|
158
|
+
case "tau":
|
|
159
|
+
case "lam":
|
|
160
|
+
return canInstantiate(meta, expression.args[1]);
|
|
161
|
+
default:
|
|
162
|
+
return expression.args.every((inner) => canInstantiate(meta, inner));
|
|
163
|
+
}
|
|
164
|
+
};
|
|
165
|
+
|
|
166
|
+
export const insertNode = (previous: Queue, node: Node): Queue => {
|
|
167
|
+
const queue = { ...previous, insertedCount: previous.insertedCount + 1 };
|
|
168
|
+
const priority = node.priority;
|
|
169
|
+
if (priority === "prop")
|
|
170
|
+
return node.branches.length < 2
|
|
171
|
+
? { ...queue, prop1: cons(node, queue.prop1) }
|
|
172
|
+
: { ...queue, prop2: cons(node, queue.prop2) };
|
|
173
|
+
if (priority === "arity") {
|
|
174
|
+
const count = node.branches.length;
|
|
175
|
+
if (count === 0) return { ...queue, prop1: cons(node, queue.prop1) };
|
|
176
|
+
if (count === 1) return { ...queue, unary: cons(node, queue.unary) };
|
|
177
|
+
if (count === 2) return { ...queue, binary: cons(node, queue.binary) };
|
|
178
|
+
return { ...queue, nary: cons(node, queue.nary) };
|
|
179
|
+
}
|
|
180
|
+
if (priority === "arity_eq") return { ...queue, eqBack: cons(node, queue.eqBack) };
|
|
181
|
+
const rule = node.rule;
|
|
182
|
+
const quantified =
|
|
183
|
+
rule.name === "all"
|
|
184
|
+
? rule.args[0]
|
|
185
|
+
: rule.name === "not_ex" && rule.args[0].kind === "not"
|
|
186
|
+
? rule.args[0].args[0]
|
|
187
|
+
: undefined;
|
|
188
|
+
if (
|
|
189
|
+
(rule.name === "all" || rule.name === "not_ex") &&
|
|
190
|
+
quantified !== undefined &&
|
|
191
|
+
canInstantiate(quantified, rule.args[1])
|
|
192
|
+
)
|
|
193
|
+
return {
|
|
194
|
+
...queue,
|
|
195
|
+
instBack: cons(node, queue.instBack),
|
|
196
|
+
instSize: insertByGoalness(queue.instSize, { node, size: getInstanceSize(rule.args[1]) }),
|
|
197
|
+
};
|
|
198
|
+
return { ...queue, instBack: cons(node, queue.instBack) };
|
|
199
|
+
};
|
|
200
|
+
|
|
201
|
+
const removeAt = (
|
|
202
|
+
goalness: number,
|
|
203
|
+
list: List<[number, Heap]>,
|
|
204
|
+
): [Node, List<[number, Heap]>] | undefined => {
|
|
205
|
+
if (list === undefined) return undefined;
|
|
206
|
+
if (list.head[0] < goalness) {
|
|
207
|
+
const removed = removeAt(goalness, list.tail);
|
|
208
|
+
return removed && [removed[0], cons(list.head, removed[1])];
|
|
209
|
+
}
|
|
210
|
+
const removed = removeHeap(list.head[1]);
|
|
211
|
+
if (removed === undefined) return removeAt(goalness, list.tail);
|
|
212
|
+
return [removed[0], cons([list.head[0], removed[1]], list.tail)];
|
|
213
|
+
};
|
|
214
|
+
|
|
215
|
+
// On even states, the smallest instance of the most goal-directed formulas; on odd states, the
|
|
216
|
+
// smallest instance overall.
|
|
217
|
+
const removeByGoalness = (state: number, list: List<[number, Heap]>) => {
|
|
218
|
+
if (state % 2 === 0) return removeAt(0, list);
|
|
219
|
+
let best = 0;
|
|
220
|
+
let bestSize: number | undefined = undefined;
|
|
221
|
+
for (let cell = list; cell !== undefined; cell = cell.tail) {
|
|
222
|
+
const head = cell.head[1].tree?.entry;
|
|
223
|
+
const isBetter = head !== undefined && (bestSize === undefined || head.size < bestSize);
|
|
224
|
+
if (isBetter) {
|
|
225
|
+
best = cell.head[0];
|
|
226
|
+
bestSize = head.size;
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
return removeAt(best, list);
|
|
230
|
+
};
|
|
231
|
+
|
|
232
|
+
const isEmptySizes = (list: List<[number, Heap]>) => {
|
|
233
|
+
for (let cell = list; cell !== undefined; cell = cell.tail)
|
|
234
|
+
if (cell.head[1].tree !== undefined) return false;
|
|
235
|
+
return true;
|
|
236
|
+
};
|
|
237
|
+
|
|
238
|
+
const removeEquality = (queue: Queue): [Node, Queue] | undefined => {
|
|
239
|
+
if (queue.eqFront !== undefined)
|
|
240
|
+
return [queue.eqFront.head, { ...queue, eqFront: queue.eqFront.tail }];
|
|
241
|
+
if (queue.eqBack === undefined) return undefined;
|
|
242
|
+
const front = reverse(queue.eqBack);
|
|
243
|
+
return front && [front.head, { ...queue, eqFront: front.tail, eqBack: undefined }];
|
|
244
|
+
};
|
|
245
|
+
|
|
246
|
+
const removeInstance = (queue: Queue): [Node, Queue] | undefined => {
|
|
247
|
+
if (queue.instState < SMALL_INSTANCES) {
|
|
248
|
+
const removed = removeByGoalness(queue.instState, queue.instSize);
|
|
249
|
+
if (removed !== undefined)
|
|
250
|
+
return [removed[0], { ...queue, instState: queue.instState + 1, instSize: removed[1] }];
|
|
251
|
+
return removeInstance({ ...queue, instState: SMALL_INSTANCES });
|
|
252
|
+
}
|
|
253
|
+
if (queue.instFront !== undefined)
|
|
254
|
+
return [
|
|
255
|
+
queue.instFront.head,
|
|
256
|
+
{
|
|
257
|
+
...queue,
|
|
258
|
+
instFront: queue.instFront.tail,
|
|
259
|
+
instState: (queue.instState + 1) % MAX_INSTANCES,
|
|
260
|
+
},
|
|
261
|
+
];
|
|
262
|
+
if (queue.instBack === undefined)
|
|
263
|
+
return isEmptySizes(queue.instSize) ? undefined : removeInstance({ ...queue, instState: 0 });
|
|
264
|
+
return removeInstance({ ...queue, instFront: reverse(queue.instBack), instBack: undefined });
|
|
265
|
+
};
|
|
266
|
+
|
|
267
|
+
export const removeNode = (queue: Queue): [Node, Queue] | undefined => {
|
|
268
|
+
if (queue.prop1 !== undefined) return [queue.prop1.head, { ...queue, prop1: queue.prop1.tail }];
|
|
269
|
+
if (queue.prop2 !== undefined) return [queue.prop2.head, { ...queue, prop2: queue.prop2.tail }];
|
|
270
|
+
if (queue.unary !== undefined) return [queue.unary.head, { ...queue, unary: queue.unary.tail }];
|
|
271
|
+
if (queue.binary !== undefined)
|
|
272
|
+
return [queue.binary.head, { ...queue, binary: queue.binary.tail }];
|
|
273
|
+
if (queue.nary !== undefined) return [queue.nary.head, { ...queue, nary: queue.nary.tail }];
|
|
274
|
+
if (queue.eqCount > 0) {
|
|
275
|
+
const counted = { ...queue, eqCount: queue.eqCount - 1 };
|
|
276
|
+
return removeEquality(counted) ?? removeInstance(counted);
|
|
277
|
+
}
|
|
278
|
+
const reset = { ...queue, eqCount: EQUALITY_COUNT };
|
|
279
|
+
return removeInstance(reset) ?? removeEquality(reset);
|
|
280
|
+
};
|
|
281
|
+
|
|
282
|
+
const last = <Item>(list: Cons<Item>) => {
|
|
283
|
+
let cell = list;
|
|
284
|
+
while (cell.tail !== undefined) cell = cell.tail;
|
|
285
|
+
return cell.head;
|
|
286
|
+
};
|
|
287
|
+
|
|
288
|
+
export const getQueueHead = (queue: Queue) =>
|
|
289
|
+
queue.prop1?.head ??
|
|
290
|
+
queue.prop2?.head ??
|
|
291
|
+
queue.unary?.head ??
|
|
292
|
+
queue.binary?.head ??
|
|
293
|
+
queue.nary?.head ??
|
|
294
|
+
queue.eqFront?.head ??
|
|
295
|
+
(queue.eqBack && last(queue.eqBack)) ??
|
|
296
|
+
queue.instFront?.head ??
|
|
297
|
+
(queue.instBack && last(queue.instBack));
|
|
@@ -0,0 +1,169 @@
|
|
|
1
|
+
// The parts of OCaml's standard library whose exact behavior steers Zenon's search.
|
|
2
|
+
//
|
|
3
|
+
// Hashtbl.hash on the values Zenon hashes: strings, and the (int, string list) pairs that Expr
|
|
4
|
+
// hashes. Zenon orders record fields by these hashes. Ints are 63-bit in OCaml, so an int is a
|
|
5
|
+
// high part in [-2^30, 2^30) and a low part in [0, 2^32).
|
|
6
|
+
|
|
7
|
+
const TWO_32 = 4294967296;
|
|
8
|
+
const TWO_31 = 2147483648;
|
|
9
|
+
const TWO_30 = 1073741824;
|
|
10
|
+
|
|
11
|
+
// A block's header with its color bits cleared: two fields and tag 0, for a pair or a list cell.
|
|
12
|
+
const PAIR_HEADER = 0x800;
|
|
13
|
+
|
|
14
|
+
const MEANINGFUL_LIMIT = 10;
|
|
15
|
+
|
|
16
|
+
const encoder = new TextEncoder();
|
|
17
|
+
|
|
18
|
+
const rotateLeft = (value: number, count: number) => (value << count) | (value >>> (32 - count));
|
|
19
|
+
|
|
20
|
+
const mix = (hash: number, data: number) => {
|
|
21
|
+
const scrambled = Math.imul(rotateLeft(Math.imul(data, 0xcc9e2d51), 15), 0x1b873593);
|
|
22
|
+
return (Math.imul(rotateLeft(hash ^ scrambled, 13), 5) + 0xe6546b64) | 0;
|
|
23
|
+
};
|
|
24
|
+
|
|
25
|
+
const finalMix = (hash: number) => {
|
|
26
|
+
const first = Math.imul(hash ^ (hash >>> 16), 0x85ebca6b);
|
|
27
|
+
const second = Math.imul(first ^ (first >>> 13), 0xc2b2ae35);
|
|
28
|
+
return ((second ^ (second >>> 16)) >>> 0) & 0x3fffffff;
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
// A string's UTF-8 bytes as the little-endian words that caml_hash_mix_string mixes, the last one
|
|
32
|
+
// partial.
|
|
33
|
+
interface StringWords {
|
|
34
|
+
words: number[];
|
|
35
|
+
length: number;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const getStringWords = (value: string): StringWords => {
|
|
39
|
+
const bytes = encoder.encode(value);
|
|
40
|
+
const words: number[] = [];
|
|
41
|
+
for (let index = 0; index < bytes.length; index += 4)
|
|
42
|
+
words.push(
|
|
43
|
+
bytes[index] |
|
|
44
|
+
((bytes[index + 1] ?? 0) << 8) |
|
|
45
|
+
((bytes[index + 2] ?? 0) << 16) |
|
|
46
|
+
((bytes[index + 3] ?? 0) << 24),
|
|
47
|
+
);
|
|
48
|
+
return { words, length: bytes.length };
|
|
49
|
+
};
|
|
50
|
+
|
|
51
|
+
const mixWords = (hash: number, encoded: StringWords) => {
|
|
52
|
+
let mixed = hash;
|
|
53
|
+
for (const word of encoded.words) mixed = mix(mixed, word);
|
|
54
|
+
return mixed ^ encoded.length;
|
|
55
|
+
};
|
|
56
|
+
|
|
57
|
+
// caml_hash_mix_intnat on the tagged value 2n + 1 of the int n.
|
|
58
|
+
const mixInt = (hash: number, high: number, low: number) => {
|
|
59
|
+
const taggedLow = (low * 2 + 1) % TWO_32;
|
|
60
|
+
const taggedHigh = high * 2 + Math.floor((low * 2 + 1) / TWO_32);
|
|
61
|
+
return mix(hash, (taggedHigh ^ (taggedHigh < 0 ? -1 : 0) ^ taggedLow) | 0);
|
|
62
|
+
};
|
|
63
|
+
|
|
64
|
+
// Hashtbl.hash on strings and on (int, string list) pairs. It keeps each string's words and hash,
|
|
65
|
+
// because Zenon hashes the same variable names over and over.
|
|
66
|
+
export const createHasher = () => {
|
|
67
|
+
const stringWords = new Map<string, StringWords>();
|
|
68
|
+
const stringHashes = new Map<string, number>();
|
|
69
|
+
const mixString = (hash: number, value: string) => {
|
|
70
|
+
const cached = stringWords.get(value);
|
|
71
|
+
const encoded = cached ?? getStringWords(value);
|
|
72
|
+
if (cached === undefined) stringWords.set(value, encoded);
|
|
73
|
+
return mixWords(hash, encoded);
|
|
74
|
+
};
|
|
75
|
+
return {
|
|
76
|
+
hashString: (value: string) => {
|
|
77
|
+
const cached = stringHashes.get(value);
|
|
78
|
+
if (cached !== undefined) return cached;
|
|
79
|
+
const hash = finalMix(mixString(0, value));
|
|
80
|
+
stringHashes.set(value, hash);
|
|
81
|
+
return hash;
|
|
82
|
+
},
|
|
83
|
+
hashIntAndStrings: (high: number, low: number, strings: string[]) => {
|
|
84
|
+
let hash = mixInt(mix(0, PAIR_HEADER), high, low);
|
|
85
|
+
let meaningful = MEANINGFUL_LIMIT - 1;
|
|
86
|
+
for (const value of strings) {
|
|
87
|
+
if (meaningful === 0) return finalMix(hash);
|
|
88
|
+
hash = mixString(mix(hash, PAIR_HEADER), value);
|
|
89
|
+
meaningful--;
|
|
90
|
+
}
|
|
91
|
+
return finalMix(meaningful === 0 ? hash : mixInt(hash, 0, 0));
|
|
92
|
+
},
|
|
93
|
+
};
|
|
94
|
+
};
|
|
95
|
+
|
|
96
|
+
const wrapHigh = (value: number) => {
|
|
97
|
+
const wrapped = ((value % TWO_31) + TWO_31) % TWO_31;
|
|
98
|
+
return wrapped >= TWO_30 ? wrapped - TWO_31 : wrapped;
|
|
99
|
+
};
|
|
100
|
+
|
|
101
|
+
export interface Int63 {
|
|
102
|
+
high: number;
|
|
103
|
+
low: number;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
// Expr's combine: x + y * 131 + 1, wrapping like OCaml's 63-bit ints.
|
|
107
|
+
export const combine = (left: Int63, right: Int63): Int63 => {
|
|
108
|
+
const product = right.low * 131;
|
|
109
|
+
const productCarry = Math.floor(product / TWO_32);
|
|
110
|
+
const sum = left.low + (product - productCarry * TWO_32) + 1;
|
|
111
|
+
const sumCarry = Math.floor(sum / TWO_32);
|
|
112
|
+
return {
|
|
113
|
+
high: wrapHigh(left.high + right.high * 131 + productCarry + sumCarry),
|
|
114
|
+
low: sum - sumCarry * TWO_32,
|
|
115
|
+
};
|
|
116
|
+
};
|
|
117
|
+
|
|
118
|
+
export const toInt63 = (value: number): Int63 => ({ high: 0, low: value });
|
|
119
|
+
|
|
120
|
+
// The merges of OCaml's List.stable_sort, on arrays. Each returns its result reversed, as OCaml's
|
|
121
|
+
// rev_merge and rev_merge_rev do.
|
|
122
|
+
const mergeReversed = <Item>(
|
|
123
|
+
first: Item[],
|
|
124
|
+
second: Item[],
|
|
125
|
+
takesFirst: (left: Item, right: Item) => boolean,
|
|
126
|
+
) => {
|
|
127
|
+
const merged: Item[] = [];
|
|
128
|
+
let firstIndex = 0;
|
|
129
|
+
let secondIndex = 0;
|
|
130
|
+
while (firstIndex < first.length && secondIndex < second.length) {
|
|
131
|
+
if (takesFirst(first[firstIndex], second[secondIndex])) merged.push(first[firstIndex++]);
|
|
132
|
+
else merged.push(second[secondIndex++]);
|
|
133
|
+
}
|
|
134
|
+
while (firstIndex < first.length) merged.push(first[firstIndex++]);
|
|
135
|
+
while (secondIndex < second.length) merged.push(second[secondIndex++]);
|
|
136
|
+
return merged.reverse();
|
|
137
|
+
};
|
|
138
|
+
|
|
139
|
+
// OCaml's List.sort, step for step, so that a comparison that isn't a total order still gives
|
|
140
|
+
// Zenon's result.
|
|
141
|
+
export const stableSort = <Item>(items: Item[], compare: (left: Item, right: Item) => number) => {
|
|
142
|
+
const sortRun = (count: number, start: number, isReversed: boolean): Item[] => {
|
|
143
|
+
const isBefore = (left: Item, right: Item) =>
|
|
144
|
+
isReversed ? compare(left, right) > 0 : compare(left, right) <= 0;
|
|
145
|
+
if (count === 2) {
|
|
146
|
+
const first = items[start];
|
|
147
|
+
const second = items[start + 1];
|
|
148
|
+
return isBefore(first, second) ? [first, second] : [second, first];
|
|
149
|
+
}
|
|
150
|
+
if (count === 3) {
|
|
151
|
+
const first = items[start];
|
|
152
|
+
const second = items[start + 1];
|
|
153
|
+
const third = items[start + 2];
|
|
154
|
+
if (isBefore(first, second)) {
|
|
155
|
+
if (isBefore(second, third)) return [first, second, third];
|
|
156
|
+
return isBefore(first, third) ? [first, third, second] : [third, first, second];
|
|
157
|
+
}
|
|
158
|
+
if (isBefore(first, third)) return [second, first, third];
|
|
159
|
+
return isBefore(second, third) ? [second, third, first] : [third, second, first];
|
|
160
|
+
}
|
|
161
|
+
const firstCount = count >> 1;
|
|
162
|
+
const left = sortRun(firstCount, start, !isReversed);
|
|
163
|
+
const right = sortRun(count - firstCount, start + firstCount, !isReversed);
|
|
164
|
+
return isReversed
|
|
165
|
+
? mergeReversed(left, right, (first, second) => compare(first, second) <= 0)
|
|
166
|
+
: mergeReversed(left, right, (first, second) => compare(first, second) > 0);
|
|
167
|
+
};
|
|
168
|
+
return items.length < 2 ? [...items] : sortRun(items.length, 0, false);
|
|
169
|
+
};
|