tla-ts 0.0.3 → 0.0.4-dev.2a873ee
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 +46 -115
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/deciders.cjs +366 -0
- package/dist/deciders.js +366 -0
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +194 -8
- package/dist/index.d.ts +194 -8
- 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 -20
- package/dist/run-cli.js +37 -20
- package/dist/tlapm.cjs +10 -0
- package/dist/tlapm.js +10 -0
- package/dist/transfer.cjs +1387 -18
- package/dist/transfer.js +1387 -18
- package/dist/worker.cjs +21 -0
- package/dist/worker.js +21 -0
- package/package.json +24 -11
- package/src/ast.ts +149 -8
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1540 -235
- package/src/cli-options.ts +12 -6
- package/src/cli.ts +8 -1
- package/src/codegen.ts +98 -39
- package/src/config.ts +254 -181
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +540 -140
- package/src/errors.ts +284 -4
- package/src/evaluate.ts +1043 -293
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +46 -11
- package/src/index.ts +11 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +127 -30
- package/src/live-check.ts +867 -0
- package/src/liveness.ts +218 -572
- package/src/{obligation-action.ts → obligations/action.ts} +247 -69
- package/src/{obligation-anon.ts → obligations/anon.ts} +49 -47
- package/src/obligations/ctx.ts +64 -0
- package/src/{obligation-deref.ts → obligations/deref.ts} +51 -92
- package/src/{obligation-expression.ts → obligations/expression.ts} +117 -57
- package/src/{obligation-format.ts → obligations/format.ts} +7 -8
- package/src/{obligation-generate.ts → obligations/generate.ts} +170 -192
- package/src/{obligations.ts → obligations/index.ts} +32 -16
- package/src/{obligation-levels.ts → obligations/levels.ts} +26 -28
- package/src/{obligation-module.ts → obligations/module.ts} +113 -121
- 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 -2
- package/src/{obligation-source.ts → obligations/source.ts} +156 -99
- package/src/obligations/temporal.ts +321 -0
- package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
- package/src/ocaml-marshal.ts +166 -0
- package/src/parallel-worker.ts +169 -224
- package/src/parallel.ts +140 -81
- package/src/parser.ts +456 -147
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/prove/decide-pool.ts +95 -0
- package/src/prove/deciders.ts +33 -0
- package/src/prove/first-order.ts +78 -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 +446 -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 +546 -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 +433 -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 +331 -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 +330 -0
- package/src/prove/isabelle/pure/name.ts +98 -0
- package/src/prove/isabelle/pure/net.ts +215 -0
- package/src/prove/isabelle/pure/object-logic.ts +41 -0
- package/src/prove/isabelle/pure/pattern.ts +631 -0
- package/src/prove/isabelle/pure/raw-simplifier.ts +338 -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 +133 -0
- package/src/prove/isabelle/pure/simplifier.ts +106 -0
- package/src/prove/isabelle/pure/table.ts +201 -0
- package/src/prove/isabelle/pure/tactic.ts +168 -0
- package/src/prove/isabelle/pure/tactical.ts +264 -0
- package/src/prove/isabelle/pure/term-ord.ts +105 -0
- package/src/prove/isabelle/pure/term.ts +688 -0
- package/src/prove/isabelle/pure/thm.ts +783 -0
- package/src/prove/isabelle/pure/type.ts +121 -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 +508 -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 +529 -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 +22 -0
- package/src/prove/prove.ts +498 -0
- package/src/prove/ptl/decide.ts +68 -0
- package/src/prove/ptl/encode.ts +255 -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 +209 -0
- package/src/prove/smt/context.ts +108 -0
- package/src/prove/smt/data.ts +636 -0
- package/src/prove/smt/encode.ts +164 -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 +181 -0
- package/src/prove/smt/rewrite.ts +772 -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 +91 -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 +642 -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 +737 -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 +379 -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 +162 -0
- package/src/prove/zenon/tla/tla.ts +506 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1481 -426
- package/src/run-cli.ts +1483 -212
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +203 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +241 -110
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +54 -25
- package/src/tlapm-cache.ts +236 -0
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +78 -10
- package/src/tlc-random.ts +84 -33
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +19 -0
- package/src/transfer.ts +15 -3
- package/src/values.ts +787 -190
- package/src/worker.ts +65 -0
- package/dist/parallel.cjs +0 -12
- package/dist/parallel.js +0 -12
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
// Shrinking an array by setting its length takes V8's slow path, many times slower than pop.
|
|
2
|
+
export const shrink = <T>(values: T[], size: number) => {
|
|
3
|
+
while (values.length > size) values.pop();
|
|
4
|
+
};
|
|
5
|
+
|
|
6
|
+
// Writing far past an array's end turns it into a dictionary in V8, which makes every access a hash
|
|
7
|
+
// lookup. So this fills the gap first.
|
|
8
|
+
export const setAt = <T>(values: (T | undefined)[], index: number, value: T | undefined) => {
|
|
9
|
+
while (values.length < index) values.push(undefined);
|
|
10
|
+
values[index] = value;
|
|
11
|
+
};
|
|
12
|
+
|
|
13
|
+
// A typed array of twice the length with the same contents.
|
|
14
|
+
export const grow = <
|
|
15
|
+
T extends Uint8Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer>,
|
|
16
|
+
>(
|
|
17
|
+
array: T,
|
|
18
|
+
): T => {
|
|
19
|
+
const grown = new (array.constructor as new (length: number) => T)(2 * array.length);
|
|
20
|
+
grown.set(array);
|
|
21
|
+
return grown;
|
|
22
|
+
};
|
|
@@ -0,0 +1,469 @@
|
|
|
1
|
+
// Ported from Z3 (src/solver/assertions/asserted_formulas.cpp), MIT license, see z3-license.txt. The
|
|
2
|
+
// preprocessing that the SMT kernel runs on its assertions before search.
|
|
3
|
+
import { SmtInvariantError } from "../../../errors";
|
|
4
|
+
import { AstManager, KIND_APP, OP_AND, OP_EQ, OP_ITE, OP_NOT, OP_OR, SORT_BOOL } from "./ast";
|
|
5
|
+
import { mkNot } from "./ast-util";
|
|
6
|
+
import { DefinedNames, Nnf } from "./nnf";
|
|
7
|
+
import { PatternInference } from "./pattern-inference";
|
|
8
|
+
import { MaxBvSharing } from "./maximize-ac-sharing";
|
|
9
|
+
import { PullQuant } from "./pull-quant";
|
|
10
|
+
import { RefVector } from "./ref-vector";
|
|
11
|
+
import { KERNEL_REWRITER_OPTIONS, Rewriter } from "./rewriter";
|
|
12
|
+
import { RewriterTpl } from "./rewriter-tpl";
|
|
13
|
+
|
|
14
|
+
// pattern_inference_rw: infers the patterns of each universal quantifier without patterns. Its
|
|
15
|
+
// cache lives as long as the assertions, like Z3's.
|
|
16
|
+
class PatternInferenceRw extends RewriterTpl {
|
|
17
|
+
constructor(
|
|
18
|
+
manager: AstManager,
|
|
19
|
+
private inference: PatternInference,
|
|
20
|
+
) {
|
|
21
|
+
super(manager);
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
reduceQuantifier(expr: number, body: number) {
|
|
25
|
+
const manager = this.manager;
|
|
26
|
+
const data = manager.getQuantifier(expr);
|
|
27
|
+
if (!data.isForall || data.patterns.length > 0) return -1;
|
|
28
|
+
const quantifier = manager.withTemporaries(() => {
|
|
29
|
+
const inferred = this.inference.infer(data.sorts.length, body, data.weight);
|
|
30
|
+
const withPatterns = manager.mkQuantifier({ ...data, body, patterns: inferred.patterns });
|
|
31
|
+
return inferred.weight === data.weight
|
|
32
|
+
? withPatterns
|
|
33
|
+
: manager.mkQuantifier({
|
|
34
|
+
...data,
|
|
35
|
+
body,
|
|
36
|
+
patterns: inferred.patterns,
|
|
37
|
+
weight: inferred.weight,
|
|
38
|
+
});
|
|
39
|
+
});
|
|
40
|
+
if (manager.getQuantifier(quantifier).patterns.length > 0) return quantifier;
|
|
41
|
+
// pi_pull_quantifiers: pulling the nested quantifiers out may give the body a pattern. The
|
|
42
|
+
// quantifier with the new patterns replaces new_q at once, and the pulled quantifier and
|
|
43
|
+
// pull_quant's cache go when reduce_quantifier returns.
|
|
44
|
+
const pull = new PullQuant(manager);
|
|
45
|
+
const pulled = pull.rewrite(quantifier);
|
|
46
|
+
const pulledData = manager.getQuantifier(pulled);
|
|
47
|
+
const result =
|
|
48
|
+
pulled === quantifier
|
|
49
|
+
? -1
|
|
50
|
+
: manager.withTemporaries(
|
|
51
|
+
() => {
|
|
52
|
+
const patterns = this.inference.inferPulled(pulledData.sorts.length, pulledData.body);
|
|
53
|
+
return patterns.length === 0 ? -1 : manager.mkQuantifier({ ...pulledData, patterns });
|
|
54
|
+
},
|
|
55
|
+
(innerResult) => (innerResult === -1 ? [] : [innerResult]),
|
|
56
|
+
);
|
|
57
|
+
if (result !== -1) manager.decRef(quantifier);
|
|
58
|
+
manager.decRef(pulled);
|
|
59
|
+
pull.release();
|
|
60
|
+
return result === -1 ? quantifier : result;
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
// Z3's Knuth-Bendix style order for propagate_values: values are smallest, then deeper terms are
|
|
65
|
+
// greater.
|
|
66
|
+
const isGreater = (manager: AstManager, left: number, right: number): boolean => {
|
|
67
|
+
if (left === right) return false;
|
|
68
|
+
const isLeftValue = manager.isUniqueValue(left);
|
|
69
|
+
const isRightValue = manager.isUniqueValue(right);
|
|
70
|
+
if (!isLeftValue && isRightValue) return true;
|
|
71
|
+
if (isLeftValue && !isRightValue) return false;
|
|
72
|
+
if (manager.depths[left] !== manager.depths[right])
|
|
73
|
+
return manager.depths[left] > manager.depths[right];
|
|
74
|
+
if (manager.kinds[left] !== KIND_APP || manager.kinds[right] !== KIND_APP) return false;
|
|
75
|
+
const leftDeclId = manager.getDeclId(left);
|
|
76
|
+
const rightDeclId = manager.getDeclId(right);
|
|
77
|
+
if (leftDeclId !== rightDeclId) return leftDeclId > rightDeclId;
|
|
78
|
+
if (manager.getNumArgs(left) !== manager.getNumArgs(right))
|
|
79
|
+
return manager.getNumArgs(left) > manager.getNumArgs(right);
|
|
80
|
+
for (let index = 0; index < manager.getNumArgs(left); index++)
|
|
81
|
+
if (manager.getArg(left, index) !== manager.getArg(right, index))
|
|
82
|
+
return isGreater(manager, manager.getArg(left, index), manager.getArg(right, index));
|
|
83
|
+
return false;
|
|
84
|
+
};
|
|
85
|
+
|
|
86
|
+
// expr_substitution under scoped_expr_substitution: the first entry for a key wins, and pop removes
|
|
87
|
+
// the entries since the matching push. The map and the trail hold their keys and values.
|
|
88
|
+
class Substitution {
|
|
89
|
+
readonly map = new Map<number, number>();
|
|
90
|
+
private trail: RefVector;
|
|
91
|
+
private trailLims: number[] = [];
|
|
92
|
+
|
|
93
|
+
constructor(private manager: AstManager) {
|
|
94
|
+
this.trail = new RefVector(manager);
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
insert(key: number, value: number) {
|
|
98
|
+
if (this.map.has(key)) return;
|
|
99
|
+
this.manager.incRef(key);
|
|
100
|
+
this.manager.incRef(value);
|
|
101
|
+
this.map.set(key, value);
|
|
102
|
+
this.trail.push(key);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
push() {
|
|
106
|
+
this.trailLims.push(this.trail.size);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
pop() {
|
|
110
|
+
const size = this.trailLims[this.trailLims.length - 1];
|
|
111
|
+
this.trailLims.pop();
|
|
112
|
+
for (const key of this.trail.items.slice(size)) {
|
|
113
|
+
const value = this.map.get(key);
|
|
114
|
+
if (value === undefined) throw new SmtInvariantError("a trailed key has no substitution");
|
|
115
|
+
this.manager.decRef(value);
|
|
116
|
+
this.map.delete(key);
|
|
117
|
+
this.manager.decRef(key);
|
|
118
|
+
}
|
|
119
|
+
this.trail.shrink(size);
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
// update_substitution: a ground equality is oriented by the order, and any other formula maps to
|
|
123
|
+
// true, or its atom to false.
|
|
124
|
+
update(expr: number) {
|
|
125
|
+
const manager = this.manager;
|
|
126
|
+
if (manager.isGround(expr) && manager.getOp(expr) === OP_EQ) {
|
|
127
|
+
const left = manager.getArg(expr, 0);
|
|
128
|
+
const right = manager.getArg(expr, 1);
|
|
129
|
+
if (isGreater(manager, left, right)) {
|
|
130
|
+
this.insert(left, right);
|
|
131
|
+
return;
|
|
132
|
+
}
|
|
133
|
+
if (isGreater(manager, right, left)) {
|
|
134
|
+
this.insert(right, left);
|
|
135
|
+
return;
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
if (manager.isNot(expr)) this.insert(manager.getArg(expr, 0), manager.falseExpr);
|
|
139
|
+
else this.insert(expr, manager.trueExpr);
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
// asserted_formulas: the assertions of a context. Each assertion is rewritten when it is asserted,
|
|
144
|
+
// and reduce preprocesses the new ones. Their units and oriented equalities then rewrite the later
|
|
145
|
+
// assertions. Like Z3, it holds its formulas, so that expressions are deleted in Z3's order.
|
|
146
|
+
// A pushed scope: the number of formulas when it began, and m_inconsistent_old.
|
|
147
|
+
interface AssertedScope {
|
|
148
|
+
numFormulas: number;
|
|
149
|
+
isInconsistent: boolean;
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
export class AssertedFormulas {
|
|
153
|
+
private formulas: RefVector;
|
|
154
|
+
private qhead = 0;
|
|
155
|
+
private substitution: Substitution;
|
|
156
|
+
private rewriter: Rewriter;
|
|
157
|
+
private isEliminatingAnd = false;
|
|
158
|
+
private isReducePending = true;
|
|
159
|
+
private names: DefinedNames;
|
|
160
|
+
private patternInference: PatternInferenceRw;
|
|
161
|
+
private bvSharing: MaxBvSharing;
|
|
162
|
+
private hasQuantifiers = false;
|
|
163
|
+
// m_inconsistent: whether a formula is false, after which no formula is added or preprocessed.
|
|
164
|
+
isInconsistent = false;
|
|
165
|
+
// The scopes that are pushed only when a formula is asserted, and the pushed scopes.
|
|
166
|
+
private numLazyScopes = 0;
|
|
167
|
+
private scopes: AssertedScope[] = [];
|
|
168
|
+
|
|
169
|
+
constructor(private manager: AstManager) {
|
|
170
|
+
this.formulas = new RefVector(manager);
|
|
171
|
+
this.substitution = new Substitution(manager);
|
|
172
|
+
this.rewriter = new Rewriter(manager, KERNEL_REWRITER_OPTIONS);
|
|
173
|
+
this.names = new DefinedNames(manager);
|
|
174
|
+
this.patternInference = new PatternInferenceRw(manager, new PatternInference(manager));
|
|
175
|
+
this.bvSharing = new MaxBvSharing(manager);
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
// push_scope: the scope is pushed when a formula is asserted in it.
|
|
179
|
+
push() {
|
|
180
|
+
this.numLazyScopes++;
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
// pop_scope: removes the formulas, names and substitutions since the matching push.
|
|
184
|
+
pop() {
|
|
185
|
+
if (this.numLazyScopes > 0) {
|
|
186
|
+
this.numLazyScopes--;
|
|
187
|
+
return;
|
|
188
|
+
}
|
|
189
|
+
const scope = this.scopes[this.scopes.length - 1];
|
|
190
|
+
this.scopes.pop();
|
|
191
|
+
this.isInconsistent = scope.isInconsistent;
|
|
192
|
+
this.bvSharing.popScope();
|
|
193
|
+
this.names.pop();
|
|
194
|
+
this.substitution.pop();
|
|
195
|
+
this.formulas.shrink(scope.numFormulas);
|
|
196
|
+
this.qhead = scope.numFormulas;
|
|
197
|
+
this.flushCache();
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
// force_push: the pushed formulas are already reduced and committed.
|
|
201
|
+
private forcePush() {
|
|
202
|
+
for (; this.numLazyScopes > 0; this.numLazyScopes--) {
|
|
203
|
+
this.substitution.push();
|
|
204
|
+
this.scopes.push({ numFormulas: this.formulas.size, isInconsistent: this.isInconsistent });
|
|
205
|
+
this.names.push();
|
|
206
|
+
this.bvSharing.pushScope();
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
assertExpr(expr: number) {
|
|
211
|
+
this.forcePush();
|
|
212
|
+
const manager = this.manager;
|
|
213
|
+
if (this.isInconsistent || manager.isTrue(expr)) return;
|
|
214
|
+
this.setEliminateAnd(false);
|
|
215
|
+
const rewritten = this.rewriter.rewrite(expr);
|
|
216
|
+
if (manager.hasQuantifierFlags[expr]) this.hasQuantifiers = true;
|
|
217
|
+
this.pushAssertion(rewritten, this.formulas);
|
|
218
|
+
manager.decRef(rewritten);
|
|
219
|
+
this.isReducePending = true;
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
getNumFormulas() {
|
|
223
|
+
return this.formulas.size;
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
// reduce and commit: the new formulas after preprocessing, which the context internalizes. Like
|
|
227
|
+
// internalize_assertions, nothing is committed once the formulas are inconsistent.
|
|
228
|
+
reduce() {
|
|
229
|
+
if (this.qhead === this.formulas.size) return [];
|
|
230
|
+
if (!this.isInconsistent) this.reduceCore();
|
|
231
|
+
if (this.isInconsistent) return [];
|
|
232
|
+
const result = this.formulas.items.slice(this.qhead);
|
|
233
|
+
for (const formula of result) this.substitution.update(formula);
|
|
234
|
+
this.qhead = this.formulas.size;
|
|
235
|
+
return result;
|
|
236
|
+
}
|
|
237
|
+
|
|
238
|
+
// asserted_formulas::reduce: each step but the last stops the preprocessing when a formula is
|
|
239
|
+
// false.
|
|
240
|
+
private reduceCore() {
|
|
241
|
+
this.setEliminateAnd(false);
|
|
242
|
+
this.propagateValues();
|
|
243
|
+
if (this.isInconsistent) return;
|
|
244
|
+
this.isReducePending = true;
|
|
245
|
+
this.nnfCnf();
|
|
246
|
+
if (this.isInconsistent) return;
|
|
247
|
+
this.setEliminateAnd(true);
|
|
248
|
+
this.reduceAsserted();
|
|
249
|
+
if (this.isInconsistent) return;
|
|
250
|
+
if (
|
|
251
|
+
this.hasQuantifiers &&
|
|
252
|
+
this.simplifyFormulas((formula) => this.patternInference.rewrite(formula))
|
|
253
|
+
)
|
|
254
|
+
this.isReducePending = true;
|
|
255
|
+
if (this.isInconsistent) return;
|
|
256
|
+
// max_bv_sharing, whose post_op reduces the formulas again.
|
|
257
|
+
if (this.simplifyFormulas((formula) => this.bvSharing.rewrite(formula)))
|
|
258
|
+
this.isReducePending = true;
|
|
259
|
+
if (this.isInconsistent) return;
|
|
260
|
+
this.reduceAsserted();
|
|
261
|
+
if (this.isInconsistent) return;
|
|
262
|
+
this.isReducePending = true;
|
|
263
|
+
this.flattenClauses();
|
|
264
|
+
if (this.isInconsistent) return;
|
|
265
|
+
this.flushCache();
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
// push_assertion: splits conjunctions and negated disjunctions. A false formula makes the
|
|
269
|
+
// assertions inconsistent.
|
|
270
|
+
private pushAssertion(expr: number, result: RefVector) {
|
|
271
|
+
const manager = this.manager;
|
|
272
|
+
if (this.isInconsistent || manager.isTrue(expr)) return;
|
|
273
|
+
if (manager.isFalse(expr)) {
|
|
274
|
+
result.push(expr);
|
|
275
|
+
this.isInconsistent = true;
|
|
276
|
+
return;
|
|
277
|
+
}
|
|
278
|
+
const op = manager.getOp(expr);
|
|
279
|
+
if (op === OP_AND) {
|
|
280
|
+
for (let index = 0; index < manager.getNumArgs(expr); index++) {
|
|
281
|
+
const arg = manager.getArg(expr, index);
|
|
282
|
+
this.pushAssertion(arg, result);
|
|
283
|
+
}
|
|
284
|
+
return;
|
|
285
|
+
}
|
|
286
|
+
if (op === OP_NOT && manager.getOp(manager.getArg(expr, 0)) === OP_OR) {
|
|
287
|
+
const disjunction = manager.getArg(expr, 0);
|
|
288
|
+
for (let index = 0; index < manager.getNumArgs(disjunction); index++) {
|
|
289
|
+
// narg holds the negation while it is pushed.
|
|
290
|
+
const negation = mkNot(manager, manager.getArg(disjunction, index));
|
|
291
|
+
manager.incRef(negation);
|
|
292
|
+
this.pushAssertion(negation, result);
|
|
293
|
+
manager.decRef(negation);
|
|
294
|
+
}
|
|
295
|
+
return;
|
|
296
|
+
}
|
|
297
|
+
result.push(expr);
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
// flush_cache: the rewriter is reset, with the committed substitution.
|
|
301
|
+
private flushCache() {
|
|
302
|
+
this.rewriter.setSubstitution(this.substitution.map);
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
private setEliminateAnd(isEliminatingAnd: boolean) {
|
|
306
|
+
if (this.isEliminatingAnd === isEliminatingAnd) return;
|
|
307
|
+
this.isEliminatingAnd = isEliminatingAnd;
|
|
308
|
+
this.isReducePending = true;
|
|
309
|
+
this.rewriter.setEliminatingAnd(isEliminatingAnd);
|
|
310
|
+
this.flushCache();
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
// swap_asserted_formulas: the new formulas replace those from qhead on.
|
|
314
|
+
private swapFormulas(formulas: RefVector) {
|
|
315
|
+
this.formulas.shrink(this.qhead);
|
|
316
|
+
for (const formula of formulas.items) this.formulas.push(formula);
|
|
317
|
+
formulas.reset();
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
// simplify_fmls: a formula that simplify changes is split again. simplify returns its result with
|
|
321
|
+
// a reference. Whether a formula changed.
|
|
322
|
+
private simplifyFormulas(simplify: (formula: number) => number) {
|
|
323
|
+
const manager = this.manager;
|
|
324
|
+
const formulas = new RefVector(manager);
|
|
325
|
+
let isChanged = false;
|
|
326
|
+
for (let index = this.qhead; index < this.formulas.size; index++) {
|
|
327
|
+
const formula = this.formulas.items[index];
|
|
328
|
+
const result = simplify(formula);
|
|
329
|
+
if (result === formula) formulas.push(formula);
|
|
330
|
+
else {
|
|
331
|
+
this.pushAssertion(result, formulas);
|
|
332
|
+
isChanged = true;
|
|
333
|
+
}
|
|
334
|
+
manager.decRef(result);
|
|
335
|
+
}
|
|
336
|
+
this.swapFormulas(formulas);
|
|
337
|
+
return isChanged;
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
// reduce_asserted_formulas: the rewriter rewrites the formulas, unless they are already in its
|
|
341
|
+
// normal form.
|
|
342
|
+
private reduceAsserted() {
|
|
343
|
+
if (!this.isReducePending) return;
|
|
344
|
+
this.simplifyFormulas((formula) => this.rewriter.rewrite(formula));
|
|
345
|
+
this.isReducePending = false;
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
// asserted_formulas::propagate_values: a forward and a backward pass that rewrite each formula with
|
|
349
|
+
// the committed substitution and the units of the formulas before it. Z3 stops after one round,
|
|
350
|
+
// since the passes add no formula. When a formula changed, reduce-asserted rewrites them all.
|
|
351
|
+
private propagateValues() {
|
|
352
|
+
const manager = this.manager;
|
|
353
|
+
const substitution = this.substitution;
|
|
354
|
+
const size = this.formulas.size;
|
|
355
|
+
let numPropagated = 0;
|
|
356
|
+
const propagate = (index: number) => {
|
|
357
|
+
const formula = this.formulas.items[index];
|
|
358
|
+
manager.incRef(formula);
|
|
359
|
+
const rewritten = this.rewriter.rewrite(formula);
|
|
360
|
+
this.formulas.set(index, rewritten);
|
|
361
|
+
if (manager.isFalse(rewritten)) this.isInconsistent = true;
|
|
362
|
+
substitution.update(rewritten);
|
|
363
|
+
if (rewritten !== formula) numPropagated++;
|
|
364
|
+
manager.decRef(rewritten);
|
|
365
|
+
manager.decRef(formula);
|
|
366
|
+
};
|
|
367
|
+
this.flushCache();
|
|
368
|
+
substitution.push();
|
|
369
|
+
for (let index = this.qhead; index < size; index++) propagate(index);
|
|
370
|
+
this.flushCache();
|
|
371
|
+
substitution.pop();
|
|
372
|
+
substitution.push();
|
|
373
|
+
for (let index = size - 1; index >= this.qhead; index--) propagate(index);
|
|
374
|
+
substitution.pop();
|
|
375
|
+
this.flushCache();
|
|
376
|
+
if (numPropagated > 0) this.reduceAsserted();
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
// asserted_formulas::nnf_cnf: one NNF object normalizes every formula, and the rewriter, which does
|
|
380
|
+
// not eliminate and yet, rewrites each normal form and the definitions of the names it introduced.
|
|
381
|
+
private nnfCnf() {
|
|
382
|
+
const manager = this.manager;
|
|
383
|
+
const nnf = new Nnf(manager, this.names);
|
|
384
|
+
const formulas = new RefVector(manager);
|
|
385
|
+
const todo = new RefVector(manager);
|
|
386
|
+
for (let index = this.qhead; index < this.formulas.size; index++) {
|
|
387
|
+
todo.reset();
|
|
388
|
+
let result = nnf.apply(this.formulas.items[index], todo);
|
|
389
|
+
todo.push(result);
|
|
390
|
+
for (let position = 0; position < todo.size; position++) {
|
|
391
|
+
const rewritten = this.rewriter.rewrite(todo.items[position]);
|
|
392
|
+
manager.decRef(result);
|
|
393
|
+
result = rewritten;
|
|
394
|
+
this.pushAssertion(result, formulas);
|
|
395
|
+
}
|
|
396
|
+
manager.decRef(result);
|
|
397
|
+
}
|
|
398
|
+
this.swapFormulas(formulas);
|
|
399
|
+
todo.reset();
|
|
400
|
+
nnf.release();
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
// asserted_formulas::flatten_clauses: an ite at the top becomes two clauses, and a conjunction
|
|
404
|
+
// that occurs in one binary clause is distributed.
|
|
405
|
+
private flattenClauses() {
|
|
406
|
+
const manager = this.manager;
|
|
407
|
+
const mkNegation = (expr: number) =>
|
|
408
|
+
manager.isNot(expr) ? manager.getArg(expr, 0) : manager.mkApp(OP_NOT, [expr], SORT_BOOL);
|
|
409
|
+
const isConjunction = (expr: number) =>
|
|
410
|
+
manager.isNot(expr) && manager.getOp(manager.getArg(expr, 0)) === OP_OR;
|
|
411
|
+
for (let isChanged = true; isChanged;) {
|
|
412
|
+
isChanged = false;
|
|
413
|
+
const formulas = new RefVector(manager);
|
|
414
|
+
const occurrences = new Map<number, number>();
|
|
415
|
+
for (let index = this.qhead; index < this.formulas.size; index++) {
|
|
416
|
+
const formula = this.formulas.items[index];
|
|
417
|
+
if (manager.getOp(formula) !== OP_OR || manager.getNumArgs(formula) !== 2) continue;
|
|
418
|
+
for (let argIndex = 0; argIndex < 2; argIndex++) {
|
|
419
|
+
const arg = manager.getArg(formula, argIndex);
|
|
420
|
+
if (isConjunction(arg)) occurrences.set(arg, (occurrences.get(arg) ?? 0) + 1);
|
|
421
|
+
}
|
|
422
|
+
}
|
|
423
|
+
for (let index = this.qhead; index < this.formulas.size; index++) {
|
|
424
|
+
const formula = this.formulas.items[index];
|
|
425
|
+
if (manager.getOp(formula) === OP_OR && manager.getNumArgs(formula) === 2) {
|
|
426
|
+
const conjunctionIndex = [1, 0].find(
|
|
427
|
+
(position) =>
|
|
428
|
+
isConjunction(manager.getArg(formula, position)) &&
|
|
429
|
+
occurrences.get(manager.getArg(formula, position)) === 1,
|
|
430
|
+
);
|
|
431
|
+
if (conjunctionIndex !== undefined) {
|
|
432
|
+
const other = manager.getArg(formula, 1 - conjunctionIndex);
|
|
433
|
+
const disjunction = manager.getArg(manager.getArg(formula, conjunctionIndex), 0);
|
|
434
|
+
for (let argIndex = 0; argIndex < manager.getNumArgs(disjunction); argIndex++)
|
|
435
|
+
formulas.push(
|
|
436
|
+
manager.mkApp(
|
|
437
|
+
OP_OR,
|
|
438
|
+
[other, mkNegation(manager.getArg(disjunction, argIndex))],
|
|
439
|
+
SORT_BOOL,
|
|
440
|
+
),
|
|
441
|
+
);
|
|
442
|
+
isChanged = true;
|
|
443
|
+
continue;
|
|
444
|
+
}
|
|
445
|
+
}
|
|
446
|
+
if (manager.getOp(formula) === OP_ITE) {
|
|
447
|
+
formulas.push(
|
|
448
|
+
manager.mkApp(
|
|
449
|
+
OP_OR,
|
|
450
|
+
[mkNegation(manager.getArg(formula, 0)), manager.getArg(formula, 1)],
|
|
451
|
+
SORT_BOOL,
|
|
452
|
+
),
|
|
453
|
+
);
|
|
454
|
+
formulas.push(
|
|
455
|
+
manager.mkApp(
|
|
456
|
+
OP_OR,
|
|
457
|
+
[manager.getArg(formula, 0), manager.getArg(formula, 2)],
|
|
458
|
+
SORT_BOOL,
|
|
459
|
+
),
|
|
460
|
+
);
|
|
461
|
+
isChanged = true;
|
|
462
|
+
continue;
|
|
463
|
+
}
|
|
464
|
+
formulas.push(formula);
|
|
465
|
+
}
|
|
466
|
+
this.swapFormulas(formulas);
|
|
467
|
+
}
|
|
468
|
+
}
|
|
469
|
+
}
|
|
@@ -0,0 +1,157 @@
|
|
|
1
|
+
// Ported from Z3 (src/ast/ast_lt.cpp, src/util/symbol.cpp), MIT license, see z3-license.txt. A
|
|
2
|
+
// total order on expressions that does not depend on their ids. The rewriter sorts a disjunction
|
|
3
|
+
// only when its arguments are out of this order.
|
|
4
|
+
import {
|
|
5
|
+
FAMILY_MODEL_VALUE,
|
|
6
|
+
FAMILY_USER,
|
|
7
|
+
KIND_APP,
|
|
8
|
+
KIND_QUANTIFIER,
|
|
9
|
+
KIND_VAR,
|
|
10
|
+
OP_ITE,
|
|
11
|
+
OP_NUM,
|
|
12
|
+
OP_PATTERN,
|
|
13
|
+
SORT_INT,
|
|
14
|
+
type AstManager,
|
|
15
|
+
type SmtSymbol,
|
|
16
|
+
} from "./ast";
|
|
17
|
+
import { Rational } from "./rational";
|
|
18
|
+
|
|
19
|
+
// The parts of a func_decl that lt compares: its name, parameters, domain and range.
|
|
20
|
+
interface DeclKey {
|
|
21
|
+
name: SmtSymbol;
|
|
22
|
+
parameters: (number | Rational)[];
|
|
23
|
+
domain: number[];
|
|
24
|
+
range: number;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
// Z3's PARAM_INT, PARAM_AST and PARAM_RATIONAL kinds order the parameters of builtin declarations.
|
|
28
|
+
const PARAM_INT = 0;
|
|
29
|
+
const PARAM_RATIONAL = 3;
|
|
30
|
+
|
|
31
|
+
const compareValues = (first: number, second: number) =>
|
|
32
|
+
first === second ? 0 : first < second ? -1 : 1;
|
|
33
|
+
|
|
34
|
+
const compareParameters = (first: number | Rational, second: number | Rational) =>
|
|
35
|
+
first instanceof Rational && second instanceof Rational
|
|
36
|
+
? first.compare(second)
|
|
37
|
+
: typeof first === "number" && typeof second === "number"
|
|
38
|
+
? compareValues(first, second)
|
|
39
|
+
: 0;
|
|
40
|
+
|
|
41
|
+
// lt on symbols: numerical symbols come first, by number, and other names compare by their bytes.
|
|
42
|
+
const compareNames = (first: SmtSymbol, second: SmtSymbol) => {
|
|
43
|
+
if (first === second) return 0;
|
|
44
|
+
if (typeof first === "number")
|
|
45
|
+
return typeof second === "number" ? compareValues(first, second) : -1;
|
|
46
|
+
if (typeof second === "number") return 1;
|
|
47
|
+
return first < second ? -1 : 1;
|
|
48
|
+
};
|
|
49
|
+
|
|
50
|
+
const getDeclKey = (manager: AstManager, expr: number): DeclKey => {
|
|
51
|
+
const decl = manager.funcDecls[manager.decls[expr]];
|
|
52
|
+
const range = manager.sorts[expr];
|
|
53
|
+
if (decl.family === FAMILY_USER)
|
|
54
|
+
return { name: decl.name, parameters: [], domain: decl.domain, range };
|
|
55
|
+
// A numeral's declaration has the parameters (value, is_int), and a model value's (index, sort).
|
|
56
|
+
if (decl.op === OP_NUM) {
|
|
57
|
+
const isInt = range === SORT_INT;
|
|
58
|
+
return {
|
|
59
|
+
name: isInt ? "Int" : "Real",
|
|
60
|
+
parameters: [PARAM_RATIONAL, manager.getRationalValue(expr), PARAM_INT, isInt ? 1 : 0],
|
|
61
|
+
domain: [],
|
|
62
|
+
range,
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
if (decl.family === FAMILY_MODEL_VALUE)
|
|
66
|
+
return { name: decl.name, parameters: [PARAM_INT, manager.values[expr]], domain: [], range };
|
|
67
|
+
const builtin = manager.getBuiltinSignature(decl.op, manager.getArgs(expr));
|
|
68
|
+
return { name: builtin.name, parameters: [], domain: builtin.domain, range };
|
|
69
|
+
};
|
|
70
|
+
|
|
71
|
+
const compareSorts = (manager: AstManager, first: number, second: number) =>
|
|
72
|
+
first === second ? 0 : compareNames(manager.sortNames[first], manager.sortNames[second]);
|
|
73
|
+
|
|
74
|
+
// Whether two applications of the same declaration have the same key: a user declaration's is its
|
|
75
|
+
// own, and a builtin's other than a numeral, model value or pattern follows from the sort of the
|
|
76
|
+
// argument that getBuiltinSignature reads and the range.
|
|
77
|
+
const isSameDeclKey = (manager: AstManager, first: number, second: number) => {
|
|
78
|
+
const decl = manager.funcDecls[manager.decls[first]];
|
|
79
|
+
if (decl.family === FAMILY_USER) return true;
|
|
80
|
+
if (decl.op === OP_NUM || decl.op === OP_PATTERN || decl.family === FAMILY_MODEL_VALUE)
|
|
81
|
+
return false;
|
|
82
|
+
const index = decl.op === OP_ITE ? 1 : 0;
|
|
83
|
+
return (
|
|
84
|
+
manager.sorts[first] === manager.sorts[second] &&
|
|
85
|
+
manager.sorts[manager.getArg(first, index)] === manager.sorts[manager.getArg(second, index)]
|
|
86
|
+
);
|
|
87
|
+
};
|
|
88
|
+
|
|
89
|
+
const compareDecls = (manager: AstManager, first: number, second: number) => {
|
|
90
|
+
if (manager.decls[first] === manager.decls[second] && isSameDeclKey(manager, first, second))
|
|
91
|
+
return 0;
|
|
92
|
+
const firstKey = getDeclKey(manager, first);
|
|
93
|
+
const secondKey = getDeclKey(manager, second);
|
|
94
|
+
const byName = compareNames(firstKey.name, secondKey.name);
|
|
95
|
+
if (byName !== 0) return byName;
|
|
96
|
+
const byArity = compareValues(firstKey.domain.length, secondKey.domain.length);
|
|
97
|
+
if (byArity !== 0) return byArity;
|
|
98
|
+
const byParameterCount = compareValues(firstKey.parameters.length, secondKey.parameters.length);
|
|
99
|
+
if (byParameterCount !== 0) return byParameterCount;
|
|
100
|
+
for (let index = 0; index < firstKey.parameters.length; index++) {
|
|
101
|
+
const byParameter = compareParameters(firstKey.parameters[index], secondKey.parameters[index]);
|
|
102
|
+
if (byParameter !== 0) return byParameter;
|
|
103
|
+
}
|
|
104
|
+
for (let index = 0; index < firstKey.domain.length; index++) {
|
|
105
|
+
const byDomain = compareSorts(manager, firstKey.domain[index], secondKey.domain[index]);
|
|
106
|
+
if (byDomain !== 0) return byDomain;
|
|
107
|
+
}
|
|
108
|
+
return compareSorts(manager, firstKey.range, secondKey.range);
|
|
109
|
+
};
|
|
110
|
+
|
|
111
|
+
const compareAsts = (manager: AstManager, first: number, second: number): number => {
|
|
112
|
+
if (first === second) return 0;
|
|
113
|
+
const byKind = compareValues(manager.kinds[first], manager.kinds[second]);
|
|
114
|
+
if (byKind !== 0) return byKind;
|
|
115
|
+
if (manager.kinds[first] === KIND_VAR) {
|
|
116
|
+
const byIndex = compareValues(manager.values[first], manager.values[second]);
|
|
117
|
+
return byIndex !== 0
|
|
118
|
+
? byIndex
|
|
119
|
+
: compareSorts(manager, manager.sorts[first], manager.sorts[second]);
|
|
120
|
+
}
|
|
121
|
+
if (manager.kinds[first] === KIND_QUANTIFIER) {
|
|
122
|
+
const firstData = manager.getQuantifier(first);
|
|
123
|
+
const secondData = manager.getQuantifier(second);
|
|
124
|
+
const byHeader =
|
|
125
|
+
compareValues(firstData.isForall ? 0 : 1, secondData.isForall ? 0 : 1) ||
|
|
126
|
+
compareValues(firstData.sorts.length, secondData.sorts.length) ||
|
|
127
|
+
compareValues(firstData.patterns.length, secondData.patterns.length) ||
|
|
128
|
+
compareValues(firstData.weight, secondData.weight);
|
|
129
|
+
if (byHeader !== 0) return byHeader;
|
|
130
|
+
for (let index = 0; index < firstData.sorts.length; index++) {
|
|
131
|
+
const byDecl =
|
|
132
|
+
compareNames(firstData.names[index], secondData.names[index]) ||
|
|
133
|
+
compareSorts(manager, firstData.sorts[index], secondData.sorts[index]);
|
|
134
|
+
if (byDecl !== 0) return byDecl;
|
|
135
|
+
}
|
|
136
|
+
for (let index = 0; index < firstData.patterns.length; index++) {
|
|
137
|
+
const byPattern = compareAsts(manager, firstData.patterns[index], secondData.patterns[index]);
|
|
138
|
+
if (byPattern !== 0) return byPattern;
|
|
139
|
+
}
|
|
140
|
+
return compareAsts(manager, firstData.body, secondData.body);
|
|
141
|
+
}
|
|
142
|
+
if (manager.kinds[first] !== KIND_APP) return 0;
|
|
143
|
+
const byHeader =
|
|
144
|
+
compareValues(manager.getNumArgs(first), manager.getNumArgs(second)) ||
|
|
145
|
+
compareValues(manager.depths[first], manager.depths[second]) ||
|
|
146
|
+
compareDecls(manager, first, second);
|
|
147
|
+
if (byHeader !== 0) return byHeader;
|
|
148
|
+
for (let index = 0; index < manager.getNumArgs(first); index++) {
|
|
149
|
+
const byArg = compareAsts(manager, manager.getArg(first, index), manager.getArg(second, index));
|
|
150
|
+
if (byArg !== 0) return byArg;
|
|
151
|
+
}
|
|
152
|
+
return 0;
|
|
153
|
+
};
|
|
154
|
+
|
|
155
|
+
// lt: whether the first expression comes before the second.
|
|
156
|
+
export const isAstLess = (manager: AstManager, first: number, second: number) =>
|
|
157
|
+
compareAsts(manager, first, second) < 0;
|