tla-ts 0.0.4-dev.e4c2d0e → 0.0.4-dev.ee344a5
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 +45 -1
- 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/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} +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 +96 -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 +73 -20
- package/src/standard-modules.ts +5 -2
- package/src/successors.ts +24 -5
- package/src/tlc-random.ts +55 -32
- package/src/tlc-version.ts +8 -7
- package/src/values.ts +85 -41
- 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,551 @@
|
|
|
1
|
+
// Ported from Z3 (src/smt/proto_model/proto_model.cpp, src/model/func_interp.cpp,
|
|
2
|
+
// src/model/value_factory.cpp, src/model/model_core.cpp), MIT license, see z3-license.txt. The
|
|
3
|
+
// model that the SMT kernel builds from a satisfying assignment, and that model-based quantifier
|
|
4
|
+
// instantiation completes and checks.
|
|
5
|
+
import {
|
|
6
|
+
AstManager,
|
|
7
|
+
KIND_APP,
|
|
8
|
+
KIND_VAR,
|
|
9
|
+
OP_AND,
|
|
10
|
+
OP_EQ,
|
|
11
|
+
OP_ITE,
|
|
12
|
+
SORT_BOOL,
|
|
13
|
+
isArithSort,
|
|
14
|
+
} from "./ast";
|
|
15
|
+
import { RandomGen } from "./random-gen";
|
|
16
|
+
import { Rational } from "./rational";
|
|
17
|
+
import { ObjHashtable, ObjMap } from "./hashtable";
|
|
18
|
+
import { ModelEvaluator } from "./model-evaluator";
|
|
19
|
+
import { RefVector } from "./ref-vector";
|
|
20
|
+
import { Rewriter, TACTIC_REWRITER_OPTIONS } from "./rewriter";
|
|
21
|
+
|
|
22
|
+
interface FuncEntry {
|
|
23
|
+
args: number[];
|
|
24
|
+
result: number;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
// func_interp: a finite table of entries and an else expression over the variables (:var i) for
|
|
28
|
+
// argument i. It holds the arguments and result of each entry, the else expression and the cached
|
|
29
|
+
// interpretation.
|
|
30
|
+
export class FuncInterp {
|
|
31
|
+
entries: FuncEntry[] = [];
|
|
32
|
+
private entryTable = new Map<string, FuncEntry>();
|
|
33
|
+
elseExpr: number | null = null;
|
|
34
|
+
private interp: number | null = null;
|
|
35
|
+
|
|
36
|
+
constructor(
|
|
37
|
+
private manager: AstManager,
|
|
38
|
+
readonly arity: number,
|
|
39
|
+
) {}
|
|
40
|
+
|
|
41
|
+
isPartial() {
|
|
42
|
+
return this.elseExpr === null;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
getEntry(args: number[]) {
|
|
46
|
+
return this.entryTable.get(args.join(","));
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
insertNewEntry(args: number[], result: number) {
|
|
50
|
+
const manager = this.manager;
|
|
51
|
+
this.resetInterpCache();
|
|
52
|
+
// func_entry: the result is held first, then the arguments.
|
|
53
|
+
manager.incRef(result);
|
|
54
|
+
for (const arg of args) manager.incRef(arg);
|
|
55
|
+
const entry = { args: [...args], result };
|
|
56
|
+
this.entries.push(entry);
|
|
57
|
+
this.entryTable.set(args.join(","), entry);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
insertEntry(args: number[], result: number) {
|
|
61
|
+
this.resetInterpCache();
|
|
62
|
+
const entry = this.getEntry(args);
|
|
63
|
+
if (entry === undefined) {
|
|
64
|
+
this.insertNewEntry(args, result);
|
|
65
|
+
return;
|
|
66
|
+
}
|
|
67
|
+
// func_entry::set_result.
|
|
68
|
+
this.manager.incRef(result);
|
|
69
|
+
this.manager.decRef(entry.result);
|
|
70
|
+
entry.result = result;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
private resetInterpCache() {
|
|
74
|
+
if (this.interp !== null) this.manager.decRef(this.interp);
|
|
75
|
+
this.interp = null;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
// func_entry::deallocate.
|
|
79
|
+
private releaseEntry(entry: FuncEntry) {
|
|
80
|
+
for (const arg of entry.args) this.manager.decRef(arg);
|
|
81
|
+
this.manager.decRef(entry.result);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
// ~func_interp.
|
|
85
|
+
release() {
|
|
86
|
+
for (const entry of this.entries) this.releaseEntry(entry);
|
|
87
|
+
if (this.elseExpr !== null) this.manager.decRef(this.elseExpr);
|
|
88
|
+
this.resetInterpCache();
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
// is_fi_entry_expr: (ite (and (= (:var 0) a0) ...) t e) with a ground t.
|
|
92
|
+
private getEntryArgs(expr: number) {
|
|
93
|
+
const manager = this.manager;
|
|
94
|
+
if (manager.getOp(expr) !== OP_ITE) return undefined;
|
|
95
|
+
const condition = manager.getArg(expr, 0);
|
|
96
|
+
if (!manager.isGround(manager.getArg(expr, 1)) || this.arity === 0) return undefined;
|
|
97
|
+
if (this.arity === 1 && manager.getOp(condition) !== OP_EQ) return undefined;
|
|
98
|
+
if (
|
|
99
|
+
this.arity > 1 &&
|
|
100
|
+
(manager.getOp(condition) !== OP_AND || manager.getNumArgs(condition) !== this.arity)
|
|
101
|
+
)
|
|
102
|
+
return undefined;
|
|
103
|
+
const args: number[] = [];
|
|
104
|
+
for (let index = 0; index < this.arity; index++) {
|
|
105
|
+
const eq = this.arity === 1 ? condition : manager.getArg(condition, index);
|
|
106
|
+
if (manager.getOp(eq) !== OP_EQ) return undefined;
|
|
107
|
+
const left = manager.getArg(eq, 0);
|
|
108
|
+
const right = manager.getArg(eq, 1);
|
|
109
|
+
if (manager.kinds[left] === KIND_VAR && manager.values[left] === index) args.push(right);
|
|
110
|
+
else if (manager.kinds[right] === KIND_VAR && manager.values[right] === index)
|
|
111
|
+
args.push(left);
|
|
112
|
+
else return undefined;
|
|
113
|
+
}
|
|
114
|
+
return args;
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
setElse(expr: number) {
|
|
118
|
+
if (expr === this.elseExpr) return;
|
|
119
|
+
this.resetInterpCache();
|
|
120
|
+
let current = expr;
|
|
121
|
+
for (let args = this.getEntryArgs(current); args !== undefined;) {
|
|
122
|
+
if (this.getEntry(args) === undefined)
|
|
123
|
+
this.insertEntry(args, this.manager.getArg(current, 1));
|
|
124
|
+
current = this.manager.getArg(current, 2);
|
|
125
|
+
args = this.getEntryArgs(current);
|
|
126
|
+
}
|
|
127
|
+
this.manager.incRef(current);
|
|
128
|
+
if (this.elseExpr !== null) this.manager.decRef(this.elseExpr);
|
|
129
|
+
this.elseExpr = current;
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
isConstant() {
|
|
133
|
+
const elseExpr = this.elseExpr;
|
|
134
|
+
if (elseExpr === null || !this.manager.isGround(elseExpr)) return false;
|
|
135
|
+
return this.entries.every((entry) => entry.result === elseExpr);
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
getMaxOccResult() {
|
|
139
|
+
const counts = new Map<number, number>();
|
|
140
|
+
let best: number | null = null;
|
|
141
|
+
let max = 0;
|
|
142
|
+
for (const entry of this.entries) {
|
|
143
|
+
const count = (counts.get(entry.result) ?? 0) + 1;
|
|
144
|
+
counts.set(entry.result, count);
|
|
145
|
+
if (count > max) {
|
|
146
|
+
max = count;
|
|
147
|
+
best = entry.result;
|
|
148
|
+
}
|
|
149
|
+
}
|
|
150
|
+
return best;
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
// compress: drops the entries whose result is the else value, and recognizes the identity.
|
|
154
|
+
compress() {
|
|
155
|
+
const manager = this.manager;
|
|
156
|
+
const elseExpr = this.elseExpr;
|
|
157
|
+
if (elseExpr === null || this.entries.length === 0 || !manager.isGround(elseExpr)) return;
|
|
158
|
+
const kept = this.entries.filter((entry) => {
|
|
159
|
+
if (entry.result !== elseExpr) return true;
|
|
160
|
+
this.releaseEntry(entry);
|
|
161
|
+
return false;
|
|
162
|
+
});
|
|
163
|
+
if (kept.length < this.entries.length) {
|
|
164
|
+
this.resetInterpCache();
|
|
165
|
+
this.entries = kept;
|
|
166
|
+
this.entryTable = new Map(kept.map((entry) => [entry.args.join(","), entry]));
|
|
167
|
+
}
|
|
168
|
+
if (this.entries.length > 0 && this.isIdentity()) {
|
|
169
|
+
for (const entry of this.entries) this.releaseEntry(entry);
|
|
170
|
+
this.entries = [];
|
|
171
|
+
this.entryTable.clear();
|
|
172
|
+
this.resetInterpCache();
|
|
173
|
+
const identity = manager.mkVar(0, manager.sorts[elseExpr]);
|
|
174
|
+
manager.incRef(identity);
|
|
175
|
+
manager.decRef(elseExpr);
|
|
176
|
+
this.elseExpr = identity;
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
// is_identity: only Bool has a finite number of elements among tlapm's sorts.
|
|
181
|
+
private isIdentity() {
|
|
182
|
+
const manager = this.manager;
|
|
183
|
+
const elseExpr = this.elseExpr;
|
|
184
|
+
if (this.arity !== 1 || elseExpr === null) return false;
|
|
185
|
+
for (const entry of this.entries)
|
|
186
|
+
if (entry.args[0] !== entry.result || entry.result === elseExpr) return false;
|
|
187
|
+
if (manager.kinds[elseExpr] === KIND_VAR) return true;
|
|
188
|
+
if (!manager.isUniqueValue(elseExpr) || manager.sorts[elseExpr] !== SORT_BOOL) return false;
|
|
189
|
+
return this.entries.length + 1 === 2;
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
// get_interp: the interpretation as an expression over the argument variables, which it caches.
|
|
193
|
+
getInterp() {
|
|
194
|
+
if (this.interp !== null) return this.interp;
|
|
195
|
+
const manager = this.manager;
|
|
196
|
+
const elseExpr = this.elseExpr;
|
|
197
|
+
if (elseExpr === null) return null;
|
|
198
|
+
let result = elseExpr;
|
|
199
|
+
const vars: number[] = [];
|
|
200
|
+
for (const entry of this.entries) {
|
|
201
|
+
if (entry.result === elseExpr) continue;
|
|
202
|
+
if (vars.length === 0)
|
|
203
|
+
entry.args.forEach((arg, index) => vars.push(manager.mkVar(index, manager.sorts[arg])));
|
|
204
|
+
const condition = manager.mkAnd(
|
|
205
|
+
entry.args.map((arg, index) => manager.mkEq(vars[index], arg)),
|
|
206
|
+
);
|
|
207
|
+
if (manager.isTrue(entry.result))
|
|
208
|
+
result = manager.isFalse(result) ? condition : manager.mkOr([condition, result]);
|
|
209
|
+
else if (manager.isFalse(entry.result)) {
|
|
210
|
+
const negated = manager.mkNot(condition);
|
|
211
|
+
result = manager.isTrue(result) ? negated : manager.mkAnd([negated, result]);
|
|
212
|
+
} else if (entry.result !== result)
|
|
213
|
+
result = manager.mkApp(OP_ITE, [condition, entry.result, result], manager.sorts[result]);
|
|
214
|
+
}
|
|
215
|
+
manager.incRef(result);
|
|
216
|
+
this.interp = result;
|
|
217
|
+
return result;
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
|
|
221
|
+
export class ProtoModel {
|
|
222
|
+
// m_interp and m_const_decls: the value of each constant, and the constants in the order they were
|
|
223
|
+
// registered.
|
|
224
|
+
readonly constInterps: ObjMap<number>;
|
|
225
|
+
private constDecls: number[] = [];
|
|
226
|
+
// m_finterp, in Z3's slot order, and m_func_decls, in the order they were registered.
|
|
227
|
+
readonly funcInterps: ObjMap<FuncInterp>;
|
|
228
|
+
private funcDecls: number[] = [];
|
|
229
|
+
private auxDecls: ObjHashtable;
|
|
230
|
+
// user_sort_factory and the arith_factory: the values of each sort, in Z3's hash order, and the
|
|
231
|
+
// values each factory holds, in the order it made or registered them.
|
|
232
|
+
private values = new Map<number, ObjHashtable>();
|
|
233
|
+
private userSortValues: RefVector;
|
|
234
|
+
private arithValues: RefVector;
|
|
235
|
+
private nextValue = new Map<number, number>();
|
|
236
|
+
private finiteSorts = new Set<number>();
|
|
237
|
+
private boolRandom: RandomGen;
|
|
238
|
+
private evaluator: ModelEvaluator;
|
|
239
|
+
// m_rewrite: the th_rewriter that cleanup simplifies the interpretations with.
|
|
240
|
+
private rewriter: Rewriter;
|
|
241
|
+
// The holders of a proto_model and a model are counted, and the last one releases it.
|
|
242
|
+
private refCount = 0;
|
|
243
|
+
|
|
244
|
+
constructor(readonly manager: AstManager) {
|
|
245
|
+
this.boolRandom = new RandomGen(manager.getNumAsts());
|
|
246
|
+
this.constInterps = new ObjMap((decl) => manager.getDeclHash(decl));
|
|
247
|
+
this.funcInterps = new ObjMap((decl) => manager.getDeclHash(decl));
|
|
248
|
+
this.userSortValues = new RefVector(manager);
|
|
249
|
+
this.arithValues = new RefVector(manager);
|
|
250
|
+
this.auxDecls = new ObjHashtable((decl) => manager.getDeclHash(decl));
|
|
251
|
+
this.evaluator = new ModelEvaluator(manager, this);
|
|
252
|
+
this.rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
// model_core::register_decl: the model holds the declaration and the value.
|
|
256
|
+
registerConst(decl: number, value: number) {
|
|
257
|
+
const old = this.constInterps.get(decl);
|
|
258
|
+
if (old === undefined) this.manager.incDeclRef(decl);
|
|
259
|
+
this.manager.incRef(value);
|
|
260
|
+
if (old === undefined) this.constDecls.push(decl);
|
|
261
|
+
else this.manager.decRef(old);
|
|
262
|
+
this.constInterps.set(decl, value);
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
// model_core::register_decl: the interpretation replaces the old one, which is released. The model
|
|
266
|
+
// holds the declaration.
|
|
267
|
+
registerFunc(decl: number, interp: FuncInterp) {
|
|
268
|
+
const old = this.funcInterps.get(decl);
|
|
269
|
+
if (old === undefined) {
|
|
270
|
+
this.funcDecls.push(decl);
|
|
271
|
+
this.manager.incDeclRef(decl);
|
|
272
|
+
}
|
|
273
|
+
this.funcInterps.set(decl, interp);
|
|
274
|
+
old?.release();
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
registerAuxDecl(decl: number, interp?: FuncInterp) {
|
|
278
|
+
if (interp !== undefined) this.registerFunc(decl, interp);
|
|
279
|
+
this.auxDecls.add(decl);
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
// reregister_decl: the old interpretation of decl moves to auxDecl.
|
|
283
|
+
reregisterDecl(decl: number, interp: FuncInterp, auxDecl: number) {
|
|
284
|
+
const old = this.funcInterps.get(decl);
|
|
285
|
+
if (old === undefined) {
|
|
286
|
+
this.registerFunc(decl, interp);
|
|
287
|
+
return;
|
|
288
|
+
}
|
|
289
|
+
this.registerFunc(auxDecl, old);
|
|
290
|
+
this.auxDecls.add(auxDecl);
|
|
291
|
+
this.funcInterps.set(decl, interp);
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
// eval: the result comes with a reference, which the caller releases.
|
|
295
|
+
eval(expr: number, isModelCompletion: boolean) {
|
|
296
|
+
this.evaluator.setModelCompletion(isModelCompletion);
|
|
297
|
+
const result = this.evaluator.rewrite(expr);
|
|
298
|
+
return result;
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
private getValueSet(sort: number) {
|
|
302
|
+
const existing = this.values.get(sort);
|
|
303
|
+
if (existing !== undefined) return existing;
|
|
304
|
+
const created = new ObjHashtable((value) => this.manager.hashes[value]);
|
|
305
|
+
this.values.set(sort, created);
|
|
306
|
+
return created;
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
// arith_factory's values are the integers, of either sort.
|
|
310
|
+
private mkIndexedValue(index: number, sort: number) {
|
|
311
|
+
return isArithSort(sort)
|
|
312
|
+
? this.manager.mkNumeralOfSort(Rational.of(BigInt(index)), sort)
|
|
313
|
+
: this.manager.mkModelValue(index, sort);
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
// mk_value and register_value: a value is inserted only when it is new, since inserting grows the
|
|
317
|
+
// table even for a value it has.
|
|
318
|
+
private addValue(sort: number, value: number) {
|
|
319
|
+
const set = this.getValueSet(sort);
|
|
320
|
+
if (set.has(value)) return;
|
|
321
|
+
(isArithSort(sort) ? this.arithValues : this.userSortValues).push(value);
|
|
322
|
+
set.add(value);
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
private mkValue(index: number, sort: number) {
|
|
326
|
+
const value = this.mkIndexedValue(index, sort);
|
|
327
|
+
this.addValue(sort, value);
|
|
328
|
+
return value;
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
registerValue(value: number) {
|
|
332
|
+
const sort = this.manager.sorts[value];
|
|
333
|
+
if (sort !== SORT_BOOL) this.addValue(sort, value);
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
getSomeValue(sort: number): number {
|
|
337
|
+
const manager = this.manager;
|
|
338
|
+
if (sort === SORT_BOOL)
|
|
339
|
+
return this.boolRandom.next() % 2 === 0 ? manager.falseExpr : manager.trueExpr;
|
|
340
|
+
const set = this.values.get(sort);
|
|
341
|
+
if (this.finiteSorts.has(sort) && set !== undefined) {
|
|
342
|
+
const random = new RandomGen(manager.getNumAsts());
|
|
343
|
+
let count = 1;
|
|
344
|
+
let result = manager.falseExpr;
|
|
345
|
+
for (const value of set) {
|
|
346
|
+
if (random.next() % count++ === 0) result = value;
|
|
347
|
+
if (count > 10) break;
|
|
348
|
+
}
|
|
349
|
+
return result;
|
|
350
|
+
}
|
|
351
|
+
if (set !== undefined && set.size > 0)
|
|
352
|
+
return set[Symbol.iterator]().next().value ?? this.mkValue(0, sort);
|
|
353
|
+
return this.mkValue(0, sort);
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
getFreshValue(sort: number): number | null {
|
|
357
|
+
if (sort === SORT_BOOL || this.finiteSorts.has(sort)) return null;
|
|
358
|
+
const set = this.getValueSet(sort);
|
|
359
|
+
let next = this.nextValue.get(sort) ?? 0;
|
|
360
|
+
for (;;) {
|
|
361
|
+
const value = this.mkIndexedValue(next, sort);
|
|
362
|
+
next++;
|
|
363
|
+
if (!set.has(value)) {
|
|
364
|
+
this.addValue(sort, value);
|
|
365
|
+
this.nextValue.set(sort, next);
|
|
366
|
+
return value;
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
freezeUniverse(sort: number) {
|
|
372
|
+
if (this.finiteSorts.has(sort)) return;
|
|
373
|
+
const set = this.values.get(sort);
|
|
374
|
+
if (set === undefined || set.size === 0) this.getSomeValue(sort);
|
|
375
|
+
this.finiteSorts.add(sort);
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
isFinite(sort: number) {
|
|
379
|
+
return this.manager.isUninterpretedSort(sort) && this.finiteSorts.has(sort);
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
getKnownUniverse(sort: number): number[] {
|
|
383
|
+
return [...(this.values.get(sort) ?? [])];
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
compress() {
|
|
387
|
+
for (const decl of this.funcDecls) this.funcInterps.get(decl)?.compress();
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
completePartialFunc(decl: number, isUsingFresh: boolean) {
|
|
391
|
+
const interp = this.funcInterps.get(decl);
|
|
392
|
+
if (interp === undefined || !interp.isPartial()) return;
|
|
393
|
+
const range = this.manager.funcDecls[decl].range;
|
|
394
|
+
const fresh = isUsingFresh ? this.getFreshValue(range) : null;
|
|
395
|
+
interp.setElse(fresh ?? interp.getMaxOccResult() ?? this.getSomeValue(range));
|
|
396
|
+
}
|
|
397
|
+
|
|
398
|
+
completePartialFuncs(isUsingFresh: boolean) {
|
|
399
|
+
// get_some_value may register more declarations, which the loop then completes too.
|
|
400
|
+
for (let index = 0; index < this.funcDecls.length; index++)
|
|
401
|
+
this.completePartialFunc(this.funcDecls[index], isUsingFresh);
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
// cleanup_expr: replaces the uninterpreted constants in an else expression with their values. Like
|
|
405
|
+
// Z3, it walks a todo stack, so it rewrites the last argument of a term first. The trail holds the
|
|
406
|
+
// terms it rewrote until the next call.
|
|
407
|
+
private cleanupExpr(trail: RefVector, expr: number, foundAuxDecls: ObjHashtable) {
|
|
408
|
+
const manager = this.manager;
|
|
409
|
+
trail.reset();
|
|
410
|
+
const cache = new Map<number, number>();
|
|
411
|
+
const todo = [expr];
|
|
412
|
+
while (todo.length > 0) {
|
|
413
|
+
const current = todo[todo.length - 1];
|
|
414
|
+
if (manager.isUninterpretedConst(current)) {
|
|
415
|
+
todo.pop();
|
|
416
|
+
const decl = manager.decls[current];
|
|
417
|
+
const existing = this.constInterps.get(decl);
|
|
418
|
+
const value = existing ?? this.getSomeValue(manager.sorts[current]);
|
|
419
|
+
if (existing === undefined) this.registerConst(decl, value);
|
|
420
|
+
cache.set(current, value);
|
|
421
|
+
continue;
|
|
422
|
+
}
|
|
423
|
+
if (manager.kinds[current] !== KIND_APP || manager.getNumArgs(current) === 0) {
|
|
424
|
+
todo.pop();
|
|
425
|
+
cache.set(current, current);
|
|
426
|
+
continue;
|
|
427
|
+
}
|
|
428
|
+
const numTodo = todo.length;
|
|
429
|
+
for (let index = 0; index < manager.getNumArgs(current); index++) {
|
|
430
|
+
const arg = manager.getArg(current, index);
|
|
431
|
+
if (!cache.has(arg)) todo.push(arg);
|
|
432
|
+
}
|
|
433
|
+
if (todo.length > numTodo) continue;
|
|
434
|
+
todo.pop();
|
|
435
|
+
const decl = manager.decls[current];
|
|
436
|
+
if (this.auxDecls.has(decl)) foundAuxDecls.add(decl);
|
|
437
|
+
const rewritten = manager.withTemporaries(() =>
|
|
438
|
+
this.rewriter.mkApp(
|
|
439
|
+
decl,
|
|
440
|
+
manager.mapArgs(current, (arg) => cache.get(arg) ?? arg),
|
|
441
|
+
manager.sorts[current],
|
|
442
|
+
),
|
|
443
|
+
);
|
|
444
|
+
if (rewritten === current) manager.decRef(rewritten);
|
|
445
|
+
else trail.pushOwned(rewritten);
|
|
446
|
+
cache.set(current, rewritten);
|
|
447
|
+
}
|
|
448
|
+
return cache.get(expr) ?? expr;
|
|
449
|
+
}
|
|
450
|
+
|
|
451
|
+
// cleanup: also removes the auxiliary declarations that no interpretation uses.
|
|
452
|
+
cleanup() {
|
|
453
|
+
const manager = this.manager;
|
|
454
|
+
const foundAuxDecls = new ObjHashtable((decl) => manager.getDeclHash(decl));
|
|
455
|
+
const trail = new RefVector(manager);
|
|
456
|
+
// Like Z3, it collects the interpretations before it cleans them up.
|
|
457
|
+
const interps = Array.from(this.funcInterps, (entry) => entry[1]);
|
|
458
|
+
for (const interp of interps)
|
|
459
|
+
if (interp.elseExpr !== null)
|
|
460
|
+
interp.setElse(this.cleanupExpr(trail, interp.elseExpr, foundAuxDecls));
|
|
461
|
+
for (let index = 0; index < this.constDecls.length; index++) {
|
|
462
|
+
const decl = this.constDecls[index];
|
|
463
|
+
const value = this.constInterps.get(decl) as number;
|
|
464
|
+
const cleaned = this.cleanupExpr(trail, value, foundAuxDecls);
|
|
465
|
+
if (cleaned !== value) this.registerConst(decl, cleaned);
|
|
466
|
+
}
|
|
467
|
+
if (foundAuxDecls.size !== this.auxDecls.size) {
|
|
468
|
+
// remove_aux_decls_not_in_set.
|
|
469
|
+
this.funcDecls = this.funcDecls.filter(
|
|
470
|
+
(decl) => !this.auxDecls.has(decl) || foundAuxDecls.has(decl),
|
|
471
|
+
);
|
|
472
|
+
for (const decl of this.auxDecls) if (!foundAuxDecls.has(decl)) this.unregisterDecl(decl);
|
|
473
|
+
this.auxDecls = foundAuxDecls;
|
|
474
|
+
}
|
|
475
|
+
trail.reset();
|
|
476
|
+
}
|
|
477
|
+
|
|
478
|
+
// model_core::unregister_decl: releases the value or the interpretation. The last constant takes
|
|
479
|
+
// the place of a removed one.
|
|
480
|
+
private unregisterDecl(decl: number) {
|
|
481
|
+
const value = this.constInterps.get(decl);
|
|
482
|
+
if (value !== undefined) {
|
|
483
|
+
const index = this.constDecls.indexOf(decl);
|
|
484
|
+
this.constDecls[index] = this.constDecls[this.constDecls.length - 1];
|
|
485
|
+
this.constDecls.pop();
|
|
486
|
+
this.constInterps.delete(decl);
|
|
487
|
+
this.manager.decDeclRef(decl);
|
|
488
|
+
this.manager.decRef(value);
|
|
489
|
+
return;
|
|
490
|
+
}
|
|
491
|
+
const interp = this.funcInterps.get(decl);
|
|
492
|
+
if (interp === undefined) return;
|
|
493
|
+
this.funcInterps.delete(decl);
|
|
494
|
+
const index = this.funcDecls.indexOf(decl);
|
|
495
|
+
if (index !== -1) this.funcDecls.splice(index, 1);
|
|
496
|
+
this.manager.decDeclRef(decl);
|
|
497
|
+
interp.release();
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
incRef() {
|
|
501
|
+
this.refCount++;
|
|
502
|
+
}
|
|
503
|
+
|
|
504
|
+
decRef() {
|
|
505
|
+
this.refCount--;
|
|
506
|
+
if (this.refCount === 0) this.release();
|
|
507
|
+
}
|
|
508
|
+
|
|
509
|
+
// ~proto_model: the rewriter, the evaluator and the factories go before the interpretations, and
|
|
510
|
+
// the user sort factory before the arith_factory.
|
|
511
|
+
private release() {
|
|
512
|
+
this.rewriter.release();
|
|
513
|
+
this.evaluator.release();
|
|
514
|
+
this.userSortValues.reset();
|
|
515
|
+
this.arithValues.reset();
|
|
516
|
+
for (const entry of this.constInterps) {
|
|
517
|
+
this.manager.decDeclRef(entry[0]);
|
|
518
|
+
this.manager.decRef(entry[1]);
|
|
519
|
+
}
|
|
520
|
+
for (const entry of this.funcInterps) {
|
|
521
|
+
this.manager.decDeclRef(entry[0]);
|
|
522
|
+
entry[1].release();
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
// mk_model: the model holds the values of the constants and the universes of the uninterpreted
|
|
527
|
+
// sorts, and takes the interpretations of the functions.
|
|
528
|
+
mkModel() {
|
|
529
|
+
const model = new ProtoModel(this.manager);
|
|
530
|
+
for (const entry of this.constInterps) model.registerConst(entry[0], entry[1]);
|
|
531
|
+
for (const entry of this.funcInterps) {
|
|
532
|
+
model.registerFunc(entry[0], entry[1]);
|
|
533
|
+
this.manager.decDeclRef(entry[0]);
|
|
534
|
+
}
|
|
535
|
+
this.funcInterps.clear();
|
|
536
|
+
this.funcDecls = [];
|
|
537
|
+
for (const entry of this.values)
|
|
538
|
+
if (!isArithSort(entry[0])) for (const value of entry[1]) model.registerValue(value);
|
|
539
|
+
return model;
|
|
540
|
+
}
|
|
541
|
+
|
|
542
|
+
// model::get_some_const_interp.
|
|
543
|
+
getSomeConstInterp(decl: number) {
|
|
544
|
+
return this.constInterps.get(decl) ?? this.getSomeValue(this.manager.funcDecls[decl].range);
|
|
545
|
+
}
|
|
546
|
+
|
|
547
|
+
// model::are_equal for values.
|
|
548
|
+
areEqual(first: number, second: number) {
|
|
549
|
+
return first === second;
|
|
550
|
+
}
|
|
551
|
+
}
|
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
// Ported from Z3 (src/ast/normal_forms/pull_quant.cpp), MIT license, see z3-license.txt. Pulls
|
|
2
|
+
// the universal quantifiers nested in a formula in Skolem normal form to the top, so the model
|
|
3
|
+
// finder sees one flat quantifier.
|
|
4
|
+
import { KIND_QUANTIFIER, OP_AND, OP_NOT, OP_OR, type AstManager, type SmtSymbol } from "./ast";
|
|
5
|
+
import { mkNot } from "./ast-util";
|
|
6
|
+
import { type Rewrite, RewriterTpl, VarShifter } from "./rewriter-tpl";
|
|
7
|
+
|
|
8
|
+
// rewriter_tpl with pull_quant's rw_cfg.
|
|
9
|
+
export class PullQuant extends RewriterTpl {
|
|
10
|
+
// rw_cfg::m_shift.
|
|
11
|
+
private varShifter: VarShifter;
|
|
12
|
+
|
|
13
|
+
constructor(manager: AstManager) {
|
|
14
|
+
super(manager);
|
|
15
|
+
this.varShifter = new VarShifter(manager);
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
// pull_quant1_core for an application of not, and or or. The result comes with a reference.
|
|
19
|
+
private pullFromApp(decl: number, args: number[], sort: number) {
|
|
20
|
+
const manager = this.manager;
|
|
21
|
+
if (manager.funcDecls[decl].op === OP_NOT) {
|
|
22
|
+
const child = args[0];
|
|
23
|
+
if (manager.kinds[child] !== KIND_QUANTIFIER) return -1;
|
|
24
|
+
const data = manager.getQuantifier(child);
|
|
25
|
+
const result = manager.mkQuantifier({
|
|
26
|
+
...data,
|
|
27
|
+
isForall: !data.isForall,
|
|
28
|
+
body: mkNot(manager, data.body),
|
|
29
|
+
});
|
|
30
|
+
manager.incRef(result);
|
|
31
|
+
return result;
|
|
32
|
+
}
|
|
33
|
+
let isForall: boolean | undefined;
|
|
34
|
+
// The variables in reverse, the last variable of the first quantifier first. A name that repeats
|
|
35
|
+
// becomes a fresh one.
|
|
36
|
+
const sorts: number[] = [];
|
|
37
|
+
const names: SmtSymbol[] = [];
|
|
38
|
+
let weight = Number.POSITIVE_INFINITY;
|
|
39
|
+
let qid = "";
|
|
40
|
+
for (const child of args) {
|
|
41
|
+
if (manager.kinds[child] !== KIND_QUANTIFIER) continue;
|
|
42
|
+
const data = manager.getQuantifier(child);
|
|
43
|
+
if (isForall === undefined) isForall = data.isForall;
|
|
44
|
+
else if (isForall !== data.isForall) return -1;
|
|
45
|
+
if (sorts.length === 0) qid = data.qid;
|
|
46
|
+
weight = Math.min(weight, data.weight);
|
|
47
|
+
for (let index = data.sorts.length - 1; index >= 0; index--) {
|
|
48
|
+
const name = data.names[index];
|
|
49
|
+
sorts.push(data.sorts[index]);
|
|
50
|
+
names.push(
|
|
51
|
+
names.includes(name)
|
|
52
|
+
? manager.mkFreshVarName(typeof name === "number" ? null : name)
|
|
53
|
+
: name,
|
|
54
|
+
);
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
if (isForall === undefined) return -1;
|
|
58
|
+
const numDecls = sorts.length;
|
|
59
|
+
let shiftAmount = 0;
|
|
60
|
+
// new_adjusted_children, which holds each shifted child.
|
|
61
|
+
const adjusted = args.map((child) => {
|
|
62
|
+
if (manager.kinds[child] !== KIND_QUANTIFIER)
|
|
63
|
+
return this.varShifter.shift(child, 0, numDecls, 0);
|
|
64
|
+
const data = manager.getQuantifier(child);
|
|
65
|
+
const shifted = this.varShifter.shift(
|
|
66
|
+
data.body,
|
|
67
|
+
data.sorts.length,
|
|
68
|
+
numDecls - data.sorts.length,
|
|
69
|
+
shiftAmount,
|
|
70
|
+
);
|
|
71
|
+
shiftAmount += data.sorts.length;
|
|
72
|
+
return shifted;
|
|
73
|
+
});
|
|
74
|
+
const result = manager.mkQuantifier({
|
|
75
|
+
isForall,
|
|
76
|
+
sorts: sorts.reverse(),
|
|
77
|
+
names: names.reverse(),
|
|
78
|
+
body: manager.mkApp(decl, adjusted, sort),
|
|
79
|
+
patterns: [],
|
|
80
|
+
weight,
|
|
81
|
+
qid,
|
|
82
|
+
});
|
|
83
|
+
manager.incRef(result);
|
|
84
|
+
for (const child of adjusted) manager.decRef(child);
|
|
85
|
+
return result;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
reduceApp(decl: number, args: number[], sort: number): number | Rewrite {
|
|
89
|
+
const manager = this.manager;
|
|
90
|
+
const op = manager.funcDecls[decl].op;
|
|
91
|
+
if (op === OP_NOT && manager.isNot(args[0])) {
|
|
92
|
+
const expr = manager.getArg(args[0], 0);
|
|
93
|
+
manager.incRef(expr);
|
|
94
|
+
return { expr, depth: 1 };
|
|
95
|
+
}
|
|
96
|
+
if (op !== OP_OR && op !== OP_AND && op !== OP_NOT) return -1;
|
|
97
|
+
return this.pullFromApp(decl, args, sort);
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
reduceQuantifier(expr: number, body: number) {
|
|
101
|
+
const manager = this.manager;
|
|
102
|
+
const data = manager.getQuantifier(expr);
|
|
103
|
+
if (!data.isForall) {
|
|
104
|
+
const result = manager.mkNot(
|
|
105
|
+
manager.mkQuantifier({ ...data, isForall: true, body: mkNot(manager, body) }),
|
|
106
|
+
);
|
|
107
|
+
manager.incRef(result);
|
|
108
|
+
return result;
|
|
109
|
+
}
|
|
110
|
+
if (manager.kinds[body] !== KIND_QUANTIFIER || !manager.getQuantifier(body).isForall) return -1;
|
|
111
|
+
const nested = manager.getQuantifier(body);
|
|
112
|
+
const result = manager.mkQuantifier({
|
|
113
|
+
isForall: true,
|
|
114
|
+
sorts: [...data.sorts, ...nested.sorts],
|
|
115
|
+
names: [...data.names, ...nested.names],
|
|
116
|
+
body: nested.body,
|
|
117
|
+
patterns: [],
|
|
118
|
+
weight: Math.min(data.weight, nested.weight),
|
|
119
|
+
qid: data.qid,
|
|
120
|
+
});
|
|
121
|
+
manager.incRef(result);
|
|
122
|
+
return result;
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
// ~rw: the configuration's shifter goes first, then the rewriter.
|
|
126
|
+
release() {
|
|
127
|
+
this.varShifter.release();
|
|
128
|
+
super.release();
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
// pull_quant's operator(), with a pull_quant of its own. The result comes with a reference, which
|
|
133
|
+
// the caller releases.
|
|
134
|
+
export const pullQuant = (manager: AstManager, expr: number) => {
|
|
135
|
+
const pull = new PullQuant(manager);
|
|
136
|
+
const result = pull.rewrite(expr);
|
|
137
|
+
pull.release();
|
|
138
|
+
return result;
|
|
139
|
+
};
|