tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa
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/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -2
- package/dist/index.d.ts +3 -2
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +60 -60
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -44
- package/dist/run.js +44 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -43
- package/dist/transfer.js +39 -39
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +1 -0
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +1 -1
- package/src/check-trace.ts +90 -51
- package/src/check.ts +367 -178
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +16 -10
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +26 -9
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +22 -10
- package/src/environment.ts +58 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +117 -41
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +81 -33
- package/src/liveness.ts +49 -11
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +112 -145
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +169 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +63 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +32 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +47 -9
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -11
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +2 -0
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +10 -4
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +20 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +9 -5
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +16 -6
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +13 -5
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +2 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-kernel.ts +39 -5
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +584 -223
- package/src/prover/smt/solver/smtlib-script.ts +509 -154
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +284 -168
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +959 -243
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +166 -101
- package/src/simulate.ts +110 -50
- package/src/spec-description.ts +5 -6
- package/src/standard-modules.ts +15 -6
- package/src/subexpressions.ts +398 -108
- package/src/successors.ts +4 -2
- package/src/symmetry.ts +1 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +3 -2
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- package/src/tlc/trace-spec.ts +9 -22
- package/src/typed-tier.ts +32 -25
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
|
@@ -81,8 +81,8 @@ const getQfnraSolver = (solver: QfnraSolver) =>
|
|
|
81
81
|
`${solver.simpleCheck})`,
|
|
82
82
|
...(solver.heuristic === undefined ? [] : [`(try-for ${QFNRA_NLSAT} ${solver.heuristic})`]),
|
|
83
83
|
...solver.orders.map(
|
|
84
|
-
(
|
|
85
|
-
`(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${
|
|
84
|
+
(order) =>
|
|
85
|
+
`(try-for (using-params ${QFNRA_NLSAT} :variable_ordering_strategy ${order[0]}) ${order[1]})`,
|
|
86
86
|
),
|
|
87
87
|
`(using-params smt :use_ls true :ls_time ${solver.ls})`,
|
|
88
88
|
`(and-then (try-for (using-params smt :arith.greatest_error_pivot true) ${solver.smt}) ` +
|
|
@@ -256,6 +256,12 @@ export const QFUFBV_ACKR_PREAMBLE =
|
|
|
256
256
|
":pull_cheap_ite true :push_ite_bv false :local_ctx true :local_ctx_limit 10000000 " +
|
|
257
257
|
":ite_extra_rules true :mul2concat true :flat_and_or false))";
|
|
258
258
|
|
|
259
|
+
const QFUFBV =
|
|
260
|
+
"(using-params (and-then (and-then (using-params simplify :flat_and_or false) (using-params " +
|
|
261
|
+
"propagate-values :flat_and_or false) solve-eqs elim-uncnstr (if-no-proofs (if-no-unsat-cores " +
|
|
262
|
+
"reduce-args)) (if-no-proofs (if-no-unsat-cores reduce-bv-size)) max-bv-sharing (if-no-proofs " +
|
|
263
|
+
"(if-no-unsat-cores ackermannize_bv))) (if is-qfbv qfbv smt)) :elim_and true :blast_distinct true)";
|
|
264
|
+
|
|
259
265
|
const QFAUFLIA =
|
|
260
266
|
"(and-then (using-params (and-then simplify propagate-values solve-eqs elim-uncnstr simplify) " +
|
|
261
267
|
":elim_and true :som true :sort_store true) (using-params smt :array.simplify false))";
|
|
@@ -302,6 +308,7 @@ export const LOGIC_TACTICS: ReadonlyMap<string, string> = new Map([
|
|
|
302
308
|
["bv", UFBV],
|
|
303
309
|
["qfbv", QFBV],
|
|
304
310
|
["qfaufbv", QFAUFBV],
|
|
311
|
+
["qfufbv", QFUFBV],
|
|
305
312
|
["qfauflia", QFAUFLIA],
|
|
306
313
|
["qfuf", QFUF],
|
|
307
314
|
["qffp", QFFP],
|
|
@@ -54,7 +54,7 @@ export class LpSettings {
|
|
|
54
54
|
nraCalls: 0,
|
|
55
55
|
};
|
|
56
56
|
readonly maxRowLengthForBoundPropagation = 300;
|
|
57
|
-
|
|
57
|
+
isPropagatingEqs = true;
|
|
58
58
|
readonly intFindCubePeriod = 4;
|
|
59
59
|
readonly lcubeFlips = 16;
|
|
60
60
|
readonly hnfCutPeriod = 4;
|
|
@@ -70,6 +70,10 @@ export class LpSettings {
|
|
|
70
70
|
|
|
71
71
|
constructor(readonly isCanceled: () => boolean) {}
|
|
72
72
|
|
|
73
|
+
setRandomSeed(seed: number) {
|
|
74
|
+
this.random = new RandomGen(seed);
|
|
75
|
+
}
|
|
76
|
+
|
|
73
77
|
getRandomNext(bound?: number) {
|
|
74
78
|
const value = this.random.next();
|
|
75
79
|
return bound === undefined ? value : value % bound;
|
|
@@ -795,7 +795,7 @@ export class NlaCore {
|
|
|
795
795
|
this.limit.popChild(this.nraLimit);
|
|
796
796
|
stats.nraCalls++;
|
|
797
797
|
}
|
|
798
|
-
if (result === L_UNDEF && !hasNoEffect()) result = L_FALSE;
|
|
798
|
+
if (result === L_UNDEF && !hasNoEffect() && this.limit.inc()) result = L_FALSE;
|
|
799
799
|
stats.nlaLemmas += this.lemmas.length;
|
|
800
800
|
return result;
|
|
801
801
|
}
|
|
@@ -919,12 +919,12 @@ export class Grobner {
|
|
|
919
919
|
private setLevel2var() {
|
|
920
920
|
const core = this.core;
|
|
921
921
|
const count = core.lra.getColumnCount();
|
|
922
|
-
const weights = Array.from({ length: count }, (
|
|
922
|
+
const weights = Array.from({ length: count }, (_value, lpVar) => core.getVarWeight(lpVar));
|
|
923
923
|
for (let lpVar = 0; lpVar < count; lpVar++) {
|
|
924
924
|
if (!core.isMonicVar(lpVar) || !core.toRefine.has(lpVar)) continue;
|
|
925
925
|
for (const factor of core.emons.get(lpVar).vars) weights[factor] += 6;
|
|
926
926
|
}
|
|
927
|
-
const level2var = Array.from({ length: count }, (
|
|
927
|
+
const level2var = Array.from({ length: count }, (_value, lpVar) => lpVar).sort(
|
|
928
928
|
(first, second) => weights[first] - weights[second] || first - second,
|
|
929
929
|
);
|
|
930
930
|
this.manager.reset(level2var);
|
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { SmtCanceledError, SmtInvariantError } from "../../../../errors";
|
|
2
2
|
import { L_FALSE, L_TRUE, L_UNDEF } from "../lbool";
|
|
3
3
|
import { Rational, getLcm } from "../rational";
|
|
4
4
|
import { Anum } from "../nlsat/algebraic";
|
|
5
5
|
import { NlsatSolver } from "../nlsat/solver";
|
|
6
|
-
import type
|
|
6
|
+
import { type Polynomial, PolynomialRef, PolynomialRefVector } from "../nlsat/polynomial";
|
|
7
7
|
import { isIneqAtom } from "../nlsat/types";
|
|
8
8
|
import {
|
|
9
9
|
KIND_EQ,
|
|
@@ -92,13 +92,15 @@ const isDyadicArtifact = (lra: LarSolver, constraint: LarConstraint) =>
|
|
|
92
92
|
getConstraintCoeffs(lra, constraint).some((entry) => hasLargeDyadicDenominator(entry[1])));
|
|
93
93
|
|
|
94
94
|
export class NraSolver {
|
|
95
|
-
private solver
|
|
95
|
+
private solver: NlsatSolver;
|
|
96
96
|
private values: Anum[] = [];
|
|
97
97
|
private lp2nl = new Map<number, number>();
|
|
98
98
|
private literal2constraint = new Map<number, number>();
|
|
99
99
|
private vars2mon = new Map<string, number>();
|
|
100
100
|
|
|
101
|
-
constructor(private core: NlaCore) {
|
|
101
|
+
constructor(private core: NlaCore) {
|
|
102
|
+
this.solver = new NlsatSolver(core.nraLimit);
|
|
103
|
+
}
|
|
102
104
|
|
|
103
105
|
get am() {
|
|
104
106
|
return this.solver.am;
|
|
@@ -115,53 +117,48 @@ export class NraSolver {
|
|
|
115
117
|
const lra = core.lra;
|
|
116
118
|
const solver = this.solver;
|
|
117
119
|
const pm = solver.pm;
|
|
118
|
-
const definitions
|
|
120
|
+
const definitions = new PolynomialRefVector(pm);
|
|
119
121
|
const denominators: bigint[] = [];
|
|
122
|
+
const p = new PolynomialRef(pm);
|
|
123
|
+
const constant = new PolynomialRef(pm);
|
|
124
|
+
const product = new PolynomialRef(pm);
|
|
120
125
|
for (let lpVar = 0; lpVar < lra.columns.length; lpVar++) {
|
|
121
126
|
if (!isIncluded(lpVar)) {
|
|
122
|
-
definitions.push(
|
|
127
|
+
definitions.push(pm.zero);
|
|
123
128
|
denominators.push(0n);
|
|
124
129
|
continue;
|
|
125
130
|
}
|
|
126
131
|
const variable = solver.mkVar(lra.isInt(lpVar));
|
|
127
132
|
this.lp2nl.set(lpVar, variable);
|
|
133
|
+
let denominator = 1n;
|
|
128
134
|
if (core.emons.isMonicVar(lpVar)) {
|
|
129
|
-
|
|
130
|
-
let denominator = 1n;
|
|
131
|
-
for (const factor of core.emons.get(lpVar).vars) {
|
|
135
|
+
for (const [index, factor] of core.emons.get(lpVar).vars.entries()) {
|
|
132
136
|
denominator = denominators[factor] * denominator;
|
|
133
|
-
|
|
134
|
-
definition === null ? definitions[factor] : pm.mul(definition, definitions[factor]!);
|
|
137
|
+
p.set(index === 0 ? definitions.get(factor) : pm.mul(p.get(), definitions.get(factor)));
|
|
135
138
|
}
|
|
136
|
-
|
|
137
|
-
denominators.push(denominator);
|
|
138
|
-
continue;
|
|
139
|
-
}
|
|
140
|
-
if (lra.hasTerm(lpVar)) {
|
|
139
|
+
} else if (lra.hasTerm(lpVar)) {
|
|
141
140
|
const term = [...lra.getTerm(lpVar).coeffs];
|
|
142
|
-
const
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
);
|
|
146
|
-
let definition: Polynomial | null = null;
|
|
147
|
-
for (const entry of term) {
|
|
141
|
+
for (const entry of term)
|
|
142
|
+
denominator = getLcm(entry[1].div(Rational.of(denominators[entry[0]])).den, denominator);
|
|
143
|
+
for (const [index, entry] of term.entries()) {
|
|
148
144
|
const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
|
|
149
|
-
|
|
150
|
-
|
|
145
|
+
constant.set(pm.mkConst(coeff.num));
|
|
146
|
+
product.set(pm.mul(constant.get(), definitions.get(entry[0])));
|
|
147
|
+
p.set(index === 0 ? product.get() : pm.add(p.get(), product.get()));
|
|
148
|
+
product.reset();
|
|
149
|
+
constant.reset();
|
|
151
150
|
}
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
definitions.push(pm.mkVar(variable));
|
|
157
|
-
denominators.push(1n);
|
|
151
|
+
} else p.set(pm.mkVar(variable));
|
|
152
|
+
definitions.push(p.getOrNull() ?? pm.zero);
|
|
153
|
+
denominators.push(denominator);
|
|
154
|
+
p.reset();
|
|
158
155
|
}
|
|
159
156
|
return { definitions, denominators };
|
|
160
157
|
}
|
|
161
158
|
|
|
162
159
|
private addConstraint(
|
|
163
160
|
constraintIndex: number,
|
|
164
|
-
definitions:
|
|
161
|
+
definitions: PolynomialRefVector,
|
|
165
162
|
denominators: readonly bigint[],
|
|
166
163
|
) {
|
|
167
164
|
const lra = this.core.lra;
|
|
@@ -174,23 +171,32 @@ export class NraSolver {
|
|
|
174
171
|
(result, entry) => getLcm(result, entry[1].div(Rational.of(denominators[entry[0]])).den),
|
|
175
172
|
rhs.den,
|
|
176
173
|
);
|
|
177
|
-
|
|
174
|
+
const p = new PolynomialRef(pm);
|
|
175
|
+
const poly = new PolynomialRef(pm);
|
|
176
|
+
const constant = new PolynomialRef(pm);
|
|
177
|
+
p.set(pm.mkConst(-(rhs.num * denominator) / rhs.den));
|
|
178
178
|
for (const entry of coeffs) {
|
|
179
179
|
const coeff = entry[1].mul(Rational.of(denominator, denominators[entry[0]]));
|
|
180
|
-
|
|
180
|
+
poly.set(definitions.get(entry[0]));
|
|
181
|
+
constant.set(pm.mkConst(coeff.num));
|
|
182
|
+
poly.set(pm.mul(poly.get(), constant.get()));
|
|
183
|
+
constant.reset();
|
|
184
|
+
p.set(pm.add(p.get(), poly.get()));
|
|
185
|
+
poly.reset();
|
|
181
186
|
}
|
|
182
187
|
const kind = constraint.kind;
|
|
183
188
|
const literal =
|
|
184
189
|
kind === KIND_LE
|
|
185
|
-
? solver.mkIneqLiteral("GT", [
|
|
190
|
+
? solver.mkIneqLiteral("GT", [p.get()], [false]) ^ 1
|
|
186
191
|
: kind === KIND_GE
|
|
187
|
-
? solver.mkIneqLiteral("LT", [
|
|
192
|
+
? solver.mkIneqLiteral("LT", [p.get()], [false]) ^ 1
|
|
188
193
|
: solver.mkIneqLiteral(
|
|
189
194
|
kind === KIND_LT ? "LT" : kind === KIND_GT ? "GT" : "EQ",
|
|
190
|
-
[
|
|
195
|
+
[p.get()],
|
|
191
196
|
[false],
|
|
192
197
|
);
|
|
193
198
|
solver.mkExternalClause([literal], constraintIndex);
|
|
199
|
+
p.reset();
|
|
194
200
|
return literal;
|
|
195
201
|
}
|
|
196
202
|
|
|
@@ -234,6 +240,7 @@ export class NraSolver {
|
|
|
234
240
|
}
|
|
235
241
|
this.addConstraint(constraintIndex, definitions.definitions, definitions.denominators);
|
|
236
242
|
}
|
|
243
|
+
definitions.definitions.reset();
|
|
237
244
|
this.registerTranscendentals();
|
|
238
245
|
const result = this.solver.check();
|
|
239
246
|
if (result === L_TRUE) {
|
|
@@ -344,6 +351,7 @@ export class NraSolver {
|
|
|
344
351
|
);
|
|
345
352
|
this.literal2constraint.set(literal, constraintIndex);
|
|
346
353
|
}
|
|
354
|
+
definitions.definitions.reset();
|
|
347
355
|
this.registerTranscendentals();
|
|
348
356
|
}
|
|
349
357
|
|
|
@@ -356,7 +364,7 @@ export class NraSolver {
|
|
|
356
364
|
for (let index = 0; index < polynomial.size; index++) {
|
|
357
365
|
const monomial = polynomial.ms[index];
|
|
358
366
|
const coeff = Rational.of(polynomial.as[index]);
|
|
359
|
-
//
|
|
367
|
+
// Like Z3, this drops degrees: only an axiom's ¬best can be nonlinear, and ¬cell is valid alone.
|
|
360
368
|
if (monomial.size === 0) bound = bound.sub(coeff);
|
|
361
369
|
else if (monomial.size === 1) term.addMonomial(coeff, nl2lp[monomial.vars[0]]);
|
|
362
370
|
else {
|
|
@@ -377,8 +385,6 @@ export class NraSolver {
|
|
|
377
385
|
try {
|
|
378
386
|
return this.checkAssignmentCore();
|
|
379
387
|
} catch (error) {
|
|
380
|
-
// Deviation from Z3: a linear cell around an irrational section answers unknown, where Z3 exits.
|
|
381
|
-
if (error instanceof NlsatUnsupportedError) return L_UNDEF;
|
|
382
388
|
if (error instanceof SmtCanceledError && this.core.nraLimit.isExhausted()) return L_UNDEF;
|
|
383
389
|
throw error;
|
|
384
390
|
}
|
|
@@ -76,7 +76,7 @@ export class PddManager {
|
|
|
76
76
|
private freezeValue = Rational.zero;
|
|
77
77
|
|
|
78
78
|
constructor(numVars: number) {
|
|
79
|
-
this.initNodes(Array.from({ length: numVars }, (
|
|
79
|
+
this.initNodes(Array.from({ length: numVars }, (_value, index) => index));
|
|
80
80
|
}
|
|
81
81
|
|
|
82
82
|
reset(level2var: number[]) {
|
|
@@ -309,8 +309,7 @@ export class PddManager {
|
|
|
309
309
|
if (this.level(this.firstLeading(q)) > this.level(p)) return p;
|
|
310
310
|
break;
|
|
311
311
|
}
|
|
312
|
-
// Z3's op_entry equality compares the cached first operand with the new second one, so
|
|
313
|
-
// only an operation on two equal operands finds its cached result.
|
|
312
|
+
// Z3's op_entry equality compares the cached first operand with the new second one, so only equal operands hit.
|
|
314
313
|
// Deviation from Z3: on a hash collision Z3 returns that result for unequal operands too.
|
|
315
314
|
const isCached = p === q;
|
|
316
315
|
if (isCached) {
|
|
@@ -64,6 +64,8 @@ export class ModelEvaluator extends RewriterTpl {
|
|
|
64
64
|
this.rewriter = new Rewriter(manager, {
|
|
65
65
|
...TACTIC_REWRITER_OPTIONS,
|
|
66
66
|
bv: { ...DEFAULT_BV_OPTIONS, isHiDiv0: manager.isHiDiv0, isMkbv2num: true },
|
|
67
|
+
isExpandingSelects: true,
|
|
68
|
+
isKeepingDistinct: true,
|
|
67
69
|
});
|
|
68
70
|
this.rewriter.releaseResult = () => this.setLastResult(-1);
|
|
69
71
|
}
|
|
@@ -2,7 +2,7 @@ import { FAMILY_BASIC, FAMILY_USER, SORT_BOOL } from "./ast";
|
|
|
2
2
|
import type { Context } from "./context";
|
|
3
3
|
import { Enode } from "./enode";
|
|
4
4
|
import { FuncInterp, ProtoModel } from "./proto-model";
|
|
5
|
-
import type { DependentValue } from "./theory";
|
|
5
|
+
import type { DependentValue, ExtraFreshValue } from "./theory";
|
|
6
6
|
|
|
7
7
|
export interface GeneratedModel {
|
|
8
8
|
model: ProtoModel;
|
|
@@ -19,6 +19,9 @@ const isIncludedFuncInterp = (context: Context, decl: number) => {
|
|
|
19
19
|
return context.getTheory(family)?.includeFuncInterp(decl) ?? true;
|
|
20
20
|
};
|
|
21
21
|
|
|
22
|
+
const GREY = 1;
|
|
23
|
+
const BLACK = 2;
|
|
24
|
+
|
|
22
25
|
export const mkModel = (context: Context): GeneratedModel => {
|
|
23
26
|
const manager = context.manager;
|
|
24
27
|
const model = new ProtoModel(manager);
|
|
@@ -34,58 +37,95 @@ export const mkModel = (context: Context): GeneratedModel => {
|
|
|
34
37
|
context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr,
|
|
35
38
|
);
|
|
36
39
|
}
|
|
37
|
-
const
|
|
38
|
-
const
|
|
39
|
-
const
|
|
40
|
+
const roots: Enode[] = [];
|
|
41
|
+
const procs = new Map<Enode, number | DependentValue>();
|
|
42
|
+
const freshRoots = new Set<Enode>();
|
|
43
|
+
const extraFreshValues = new Set<ExtraFreshValue>();
|
|
40
44
|
for (const node of context.enodes) {
|
|
41
45
|
if (node.root !== node) continue;
|
|
42
46
|
const expr = node.owner;
|
|
43
47
|
if (!context.isRelevant(expr) && !manager.isValue(expr)) continue;
|
|
48
|
+
roots.push(node);
|
|
44
49
|
const sort = manager.sorts[expr];
|
|
45
50
|
const theory = context.getTheory(manager.getSortFamily(sort));
|
|
46
51
|
if (sort === SORT_BOOL)
|
|
47
|
-
|
|
48
|
-
else if (manager.isModelValue(expr))
|
|
52
|
+
procs.set(node, context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr);
|
|
53
|
+
else if (manager.isModelValue(expr)) procs.set(node, expr);
|
|
49
54
|
else if (theory !== undefined && theory.buildModels()) {
|
|
50
|
-
const
|
|
51
|
-
if (
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
55
|
+
const proc = node.getThVar(theory.id) < 0 ? undefined : theory.mkValue(node);
|
|
56
|
+
if (proc === undefined) {
|
|
57
|
+
const freshValue: ExtraFreshValue = { sort, value: undefined };
|
|
58
|
+
freshRoots.add(node);
|
|
59
|
+
extraFreshValues.add(freshValue);
|
|
60
|
+
procs.set(node, { dependencies: [freshValue], mkValue: (values) => values[0] });
|
|
61
|
+
} else {
|
|
62
|
+
if (typeof proc !== "number")
|
|
63
|
+
for (const dependency of proc.dependencies)
|
|
64
|
+
if (!(dependency instanceof Enode)) extraFreshValues.add(dependency);
|
|
65
|
+
procs.set(node, proc);
|
|
66
|
+
}
|
|
67
|
+
} else procs.set(node, model.getFreshValue(sort) ?? model.getSomeValue(sort));
|
|
59
68
|
}
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
const
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
root2value.set(node, value);
|
|
67
|
-
return value;
|
|
69
|
+
const colors = new Map<Enode | ExtraFreshValue, number>();
|
|
70
|
+
const traversedSorts = new Set<number>();
|
|
71
|
+
const sortedSources: (Enode | ExtraFreshValue)[] = [];
|
|
72
|
+
const todo: (Enode | ExtraFreshValue)[] = [];
|
|
73
|
+
const visitChild = (source: Enode | ExtraFreshValue) => {
|
|
74
|
+
if (!colors.has(source)) todo.push(source);
|
|
68
75
|
};
|
|
69
|
-
const
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
if (
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
76
|
+
const processSource = (source: Enode | ExtraFreshValue) => {
|
|
77
|
+
if (colors.get(source) === BLACK) return;
|
|
78
|
+
todo.push(source);
|
|
79
|
+
while (todo.length > 0) {
|
|
80
|
+
const current = todo[todo.length - 1];
|
|
81
|
+
const color = colors.get(current);
|
|
82
|
+
if (color === BLACK) todo.pop();
|
|
83
|
+
else if (color === GREY) {
|
|
84
|
+
colors.set(current, BLACK);
|
|
85
|
+
sortedSources.push(current);
|
|
86
|
+
} else {
|
|
87
|
+
colors.set(current, GREY);
|
|
88
|
+
if (current instanceof Enode) {
|
|
89
|
+
const proc = procs.get(current);
|
|
90
|
+
if (proc !== undefined && typeof proc !== "number")
|
|
91
|
+
for (const dependency of proc.dependencies)
|
|
92
|
+
visitChild(dependency instanceof Enode ? dependency.root : dependency);
|
|
93
|
+
} else if (!traversedSorts.has(current.sort)) {
|
|
94
|
+
for (const root of roots)
|
|
95
|
+
if (manager.sorts[root.owner] === current.sort && !freshRoots.has(root))
|
|
96
|
+
visitChild(root);
|
|
97
|
+
traversedSorts.add(current.sort);
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
}
|
|
86
101
|
};
|
|
87
|
-
for (const
|
|
88
|
-
for (const
|
|
102
|
+
for (const freshValue of extraFreshValues) processSource(freshValue);
|
|
103
|
+
for (const root of freshRoots) processSource(root);
|
|
104
|
+
for (const root of roots) processSource(root);
|
|
105
|
+
const root2value = new Map<Enode, number>();
|
|
106
|
+
for (const source of sortedSources) {
|
|
107
|
+
if (!(source instanceof Enode)) {
|
|
108
|
+
source.value = model.getFreshValue(source.sort) ?? undefined;
|
|
109
|
+
continue;
|
|
110
|
+
}
|
|
111
|
+
const expr = source.owner;
|
|
112
|
+
const sort = manager.sorts[expr];
|
|
113
|
+
const proc = procs.get(source) ?? model.getFreshValue(sort) ?? model.getSomeValue(sort);
|
|
114
|
+
const value = manager.isValue(expr)
|
|
115
|
+
? expr
|
|
116
|
+
: typeof proc === "number"
|
|
117
|
+
? proc
|
|
118
|
+
: proc.mkValue(
|
|
119
|
+
proc.dependencies.map((dependency) =>
|
|
120
|
+
dependency instanceof Enode
|
|
121
|
+
? (root2value.get(dependency.root) ??
|
|
122
|
+
model.getSomeValue(manager.sorts[dependency.owner]))
|
|
123
|
+
: (dependency.value ?? model.getSomeValue(dependency.sort)),
|
|
124
|
+
),
|
|
125
|
+
);
|
|
126
|
+
model.registerValue(value);
|
|
127
|
+
root2value.set(source, value);
|
|
128
|
+
}
|
|
89
129
|
const getValue = (node: Enode) =>
|
|
90
130
|
root2value.get(node.root) ?? model.getSomeValue(manager.sorts[node.owner]);
|
|
91
131
|
for (const node of context.enodes)
|
|
@@ -104,7 +144,9 @@ export const mkModel = (context: Context): GeneratedModel => {
|
|
|
104
144
|
interp = new FuncInterp(manager, node.numArgs);
|
|
105
145
|
model.registerFunc(node.decl, interp);
|
|
106
146
|
}
|
|
107
|
-
const args = Array.from({ length: node.numArgs }, (
|
|
147
|
+
const args = Array.from({ length: node.numArgs }, (_value, index) =>
|
|
148
|
+
getValue(node.getArg(index)),
|
|
149
|
+
);
|
|
108
150
|
if (interp.getEntry(args) === undefined) interp.insertNewEntry(args, getValue(node));
|
|
109
151
|
}
|
|
110
152
|
for (const theory of context.theories) theory.finalizeModel();
|
|
@@ -44,9 +44,9 @@ const getRoot = (value: bigint) => {
|
|
|
44
44
|
return low * low === value ? { root: low, isExact: true } : { root: low + 1n, isExact: false };
|
|
45
45
|
};
|
|
46
46
|
|
|
47
|
-
|
|
47
|
+
const mkBotExp = (ebits: number) => -(2 ** (ebits - 1) - 1);
|
|
48
48
|
|
|
49
|
-
|
|
49
|
+
const mkTopExp = (ebits: number) => 2 ** (ebits - 1);
|
|
50
50
|
|
|
51
51
|
export const mkMinExp = (ebits: number) => mkBotExp(ebits) + 1;
|
|
52
52
|
|
|
@@ -98,8 +98,6 @@ export const isPzero = (value: Mpf) => !value.sign && isZero(value);
|
|
|
98
98
|
|
|
99
99
|
export const isNeg = (value: Mpf) => value.sign && !isNan(value);
|
|
100
100
|
|
|
101
|
-
export const isPos = (value: Mpf) => !value.sign && !isNan(value);
|
|
102
|
-
|
|
103
101
|
export const isDenormal = (value: Mpf) => !isZero(value) && hasBotExp(value);
|
|
104
102
|
|
|
105
103
|
export const isNormal = (value: Mpf) => !(hasTopExp(value) || isDenormal(value) || isZero(value));
|
|
@@ -10,7 +10,7 @@ export class Mus {
|
|
|
10
10
|
|
|
11
11
|
constructor(
|
|
12
12
|
private manager: AstManager,
|
|
13
|
-
private solver: MaxsatSolver,
|
|
13
|
+
private solver: Pick<MaxsatSolver, "checkSat" | "getUnsatCore">,
|
|
14
14
|
) {
|
|
15
15
|
this.lit2expr = new RefVector(manager);
|
|
16
16
|
this.trail = new RefVector(manager);
|
|
@@ -33,8 +33,7 @@ export class Mus {
|
|
|
33
33
|
return L_TRUE;
|
|
34
34
|
}
|
|
35
35
|
let unknown = [...literals];
|
|
36
|
-
|
|
37
|
-
const literal = unknown.pop() as number;
|
|
36
|
+
for (let literal = unknown.pop(); literal !== undefined; literal = unknown.pop()) {
|
|
38
37
|
const notLiteral = mkNot(this.manager, literal);
|
|
39
38
|
this.trail.push(notLiteral);
|
|
40
39
|
const status = this.solver.checkSat([...mus.items, ...unknown, notLiteral]);
|
|
@@ -38,9 +38,13 @@ const ENGINE_NAMES = new Map([
|
|
|
38
38
|
["ddnf", ENGINE_DDNF],
|
|
39
39
|
]);
|
|
40
40
|
|
|
41
|
-
//
|
|
41
|
+
// As in Z3, these are copied when the context is made, so a later fp option doesn't apply.
|
|
42
42
|
export class FpParams {
|
|
43
|
-
|
|
43
|
+
private parameters: ReadonlyMap<string, string>;
|
|
44
|
+
|
|
45
|
+
constructor(parameters: ReadonlyMap<string, string>) {
|
|
46
|
+
this.parameters = new Map(parameters);
|
|
47
|
+
}
|
|
44
48
|
|
|
45
49
|
getBool(name: string, defaultValue: boolean) {
|
|
46
50
|
const value = this.parameters.get(`fp.${name}`);
|
|
@@ -117,6 +121,7 @@ export class DatalogContext {
|
|
|
117
121
|
readonly rewriter: Rewriter;
|
|
118
122
|
// m_mc: the converters since the last query, or undefined before one.
|
|
119
123
|
modelConverters: ModelConverter[] | undefined;
|
|
124
|
+
isBounded = false;
|
|
120
125
|
|
|
121
126
|
constructor(
|
|
122
127
|
readonly manager: AstManager,
|
|
@@ -328,6 +333,7 @@ export class DatalogContext {
|
|
|
328
333
|
|
|
329
334
|
query(query: number) {
|
|
330
335
|
this.modelConverters = [];
|
|
336
|
+
this.isBounded = false;
|
|
331
337
|
this.getEngine(query);
|
|
332
338
|
this.flushAddRules();
|
|
333
339
|
return this.ensureEngine(query).query(query);
|
|
@@ -362,7 +368,7 @@ export class DatalogContext {
|
|
|
362
368
|
: mkExists(
|
|
363
369
|
manager,
|
|
364
370
|
[...domain].reverse(),
|
|
365
|
-
domain.map((
|
|
371
|
+
domain.map((_value, index) => String(index)).reverse(),
|
|
366
372
|
atom,
|
|
367
373
|
);
|
|
368
374
|
manager.incRef(query);
|
|
@@ -395,7 +401,7 @@ export class DatalogContext {
|
|
|
395
401
|
...conjs.items.map((conj) => this.ruleManager.ensureApp(conj)),
|
|
396
402
|
];
|
|
397
403
|
const isNegated = tail.map(
|
|
398
|
-
(
|
|
404
|
+
(_value, index) => index < rule.uninterpretedSize && rule.isNegated[index],
|
|
399
405
|
);
|
|
400
406
|
const reduced = this.ruleManager.mk(rule.head, tail, isNegated, rule.name);
|
|
401
407
|
conjs.reset();
|
|
@@ -213,7 +213,7 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
213
213
|
const manager = this.context.manager;
|
|
214
214
|
let hasOutput = false;
|
|
215
215
|
for (const [predicate, slice] of this.sliceable) {
|
|
216
|
-
const domain = manager.funcDecls[predicate].domain.filter((
|
|
216
|
+
const domain = manager.funcDecls[predicate].domain.filter((_value, index) => !slice[index]);
|
|
217
217
|
if (domain.length < slice.length) {
|
|
218
218
|
const sliced = this.context.mkFreshHeadPredicate(
|
|
219
219
|
getSymbolName(manager.funcDecls[predicate].name),
|
|
@@ -238,7 +238,7 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
238
238
|
const slice = this.getPredicateSlice(manager.decls[atom]);
|
|
239
239
|
return manager.mkApp(
|
|
240
240
|
sliced,
|
|
241
|
-
manager.getArgs(atom).filter((
|
|
241
|
+
manager.getArgs(atom).filter((_value, index) => !slice[index]),
|
|
242
242
|
SORT_BOOL,
|
|
243
243
|
);
|
|
244
244
|
}
|
|
@@ -303,7 +303,7 @@ export class MkSlice implements RuleTransformerPlugin {
|
|
|
303
303
|
const domain = manager.funcDecls[predicate].domain;
|
|
304
304
|
const subst = domain
|
|
305
305
|
.map((sort, index) => manager.mkVar(index, sort))
|
|
306
|
-
.filter((
|
|
306
|
+
.filter((_value, index) => !slice[index]);
|
|
307
307
|
const interp = model.funcInterps.get(sliced);
|
|
308
308
|
if (interp === undefined) continue;
|
|
309
309
|
const oldInterp = new FuncInterp(manager, slice.length);
|
|
@@ -382,7 +382,7 @@ export class RuleManager {
|
|
|
382
382
|
return mkForall(
|
|
383
383
|
manager,
|
|
384
384
|
sorts,
|
|
385
|
-
sorts.map((
|
|
385
|
+
sorts.map((_value, index) => getVarName(index)),
|
|
386
386
|
matrix,
|
|
387
387
|
);
|
|
388
388
|
}
|
|
@@ -479,7 +479,7 @@ export class RuleManager {
|
|
|
479
479
|
const preQuant = this.pin(varSubst.apply(unboundTail, subst));
|
|
480
480
|
varSubst.release();
|
|
481
481
|
sorts.reverse();
|
|
482
|
-
const names = sorts.map((
|
|
482
|
+
const names = sorts.map((_value, index) => String(sorts.length - 1 - index));
|
|
483
483
|
const quantified = this.pin(mkExists(manager, sorts, names, preQuant));
|
|
484
484
|
let fixed = isTryingQe ? this.pin(simplifyQuantifiers(manager, quantified)) : quantified;
|
|
485
485
|
if (manager.kinds[fixed] !== KIND_APP) fixed = this.pin(manager.mkEq(fixed, manager.trueExpr));
|
|
@@ -64,7 +64,7 @@ export class HornSubsumeModelConverter {
|
|
|
64
64
|
const quantified = manager.mkQuantifier({
|
|
65
65
|
kind: QUANTIFIER_EXISTS,
|
|
66
66
|
sorts: sorts.reverse(),
|
|
67
|
-
names: sorts.map((
|
|
67
|
+
names: sorts.map((_value, index) => sorts.length - index - 1),
|
|
68
68
|
body: substituted,
|
|
69
69
|
patterns: [],
|
|
70
70
|
noPatterns: [],
|
|
@@ -138,7 +138,7 @@ class HornTactic {
|
|
|
138
138
|
);
|
|
139
139
|
if (sorts.length === 0) return formula;
|
|
140
140
|
sorts.reverse();
|
|
141
|
-
const names = sorts.map((
|
|
141
|
+
const names = sorts.map((_value, index) => String(sorts.length - index - 1));
|
|
142
142
|
const result = mkForall(manager, sorts, names, formula);
|
|
143
143
|
manager.incRef(result);
|
|
144
144
|
return result;
|