tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.94c3dd828
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/deciders.cjs +37 -36
- package/dist/deciders.js +55 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +3 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +146 -58
- package/dist/prove.js +142 -54
- package/dist/run.cjs +45 -43
- package/dist/run.js +47 -45
- package/dist/transfer.cjs +39 -36
- package/dist/transfer.js +23 -20
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/check.ts +203 -33
- package/src/cli/tlapm.ts +261 -68
- package/src/dependencies.ts +23 -2
- package/src/errors.ts +1 -1
- package/src/exit-codes.ts +1 -0
- package/src/liveness-checker.ts +530 -201
- package/src/liveness.ts +47 -32
- package/src/obligations/anonymize.ts +2 -4
- package/src/obligations/index.ts +5 -3
- package/src/obligations/pragma.ts +2 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +151 -42
- package/src/prover/deciders.ts +1 -8
- package/src/prover/isabelle/isar/attrib.ts +86 -45
- package/src/prover/isabelle/isar/context.ts +25 -22
- package/src/prover/isabelle/isar/induct.ts +2 -5
- package/src/prover/isabelle/isar/method.ts +5 -7
- package/src/prover/isabelle/isar/proof.ts +33 -16
- package/src/prover/isabelle/isar/rule-cases.ts +6 -14
- package/src/prover/isabelle/isar/theory.ts +16 -17
- package/src/prover/isabelle/isar/toplevel.ts +46 -52
- package/src/prover/isabelle/provers/classical.ts +1 -1
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +1 -0
- package/src/prover/prep/methods.ts +50 -3
- package/src/prover/prep/normalize.ts +4 -1
- package/src/prover/prove.ts +58 -32
- package/src/prover/ptl/decide.ts +43 -63
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +1 -0
- package/src/prover/smt/solver/aig-tactic.ts +25 -15
- package/src/prover/smt/solver/arith-rewriter.ts +3 -5
- package/src/prover/smt/solver/asserted-formulas.ts +1 -1
- package/src/prover/smt/solver/ast-util.ts +3 -1
- package/src/prover/smt/solver/ast.ts +110 -152
- package/src/prover/smt/solver/bound-manager.ts +39 -28
- package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
- package/src/prover/smt/solver/bv-rewriter.ts +14 -16
- package/src/prover/smt/solver/bv1-blast.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +19 -14
- package/src/prover/smt/solver/check-logic.ts +6 -1
- package/src/prover/smt/solver/context.ts +20 -10
- package/src/prover/smt/solver/demodulator.ts +2 -2
- package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
- package/src/prover/smt/solver/distribute-forall.ts +1 -10
- package/src/prover/smt/solver/dom-simplify.ts +1 -1
- package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
- package/src/prover/smt/solver/e-matching.ts +6 -6
- package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
- package/src/prover/smt/solver/enode.ts +15 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
- package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
- package/src/prover/smt/solver/euf/egraph.ts +65 -32
- package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
- package/src/prover/smt/solver/euf/mam.ts +6 -48
- package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
- package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
- package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
- package/src/prover/smt/solver/euf/q-solver.ts +2 -0
- package/src/prover/smt/solver/euf/th-solver.ts +1 -1
- package/src/prover/smt/solver/factor.ts +1 -11
- package/src/prover/smt/solver/fd-solver.ts +1 -2
- package/src/prover/smt/solver/fm-tactic.ts +19 -13
- package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
- package/src/prover/smt/solver/internalizer.ts +41 -2
- package/src/prover/smt/solver/lia2pb.ts +18 -4
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
- package/src/prover/smt/solver/macro-finder.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +13 -13
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
- package/src/prover/smt/solver/maxcore.ts +4 -12
- package/src/prover/smt/solver/maxlex.ts +0 -7
- package/src/prover/smt/solver/maxsmt-base.ts +7 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
- package/src/prover/smt/solver/model-evaluator.ts +9 -5
- package/src/prover/smt/solver/model-macro-solver.ts +3 -3
- package/src/prover/smt/solver/muz/dl-context.ts +57 -3
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
- package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
- package/src/prover/smt/solver/muz/hnf.ts +6 -5
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
- package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
- package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
- package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
- package/src/prover/smt/solver/muz/substitution.ts +88 -37
- package/src/prover/smt/solver/nlqsat.ts +2 -2
- package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
- package/src/prover/smt/solver/nlsat/explain.ts +5 -0
- package/src/prover/smt/solver/nlsat/solver.ts +36 -25
- package/src/prover/smt/solver/opt-context.ts +9 -8
- package/src/prover/smt/solver/opt-nlsat.ts +68 -58
- package/src/prover/smt/solver/opt-solver.ts +16 -7
- package/src/prover/smt/solver/optsmt.ts +12 -9
- package/src/prover/smt/solver/pattern-inference.ts +2 -2
- package/src/prover/smt/solver/pb-rewriter.ts +13 -13
- package/src/prover/smt/solver/poly-rewriter.ts +2 -2
- package/src/prover/smt/solver/probes.ts +1 -1
- package/src/prover/smt/solver/propagate-values.ts +4 -0
- package/src/prover/smt/solver/proto-model.ts +5 -5
- package/src/prover/smt/solver/purify-arith.ts +50 -15
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
- package/src/prover/smt/solver/qe-mbp.ts +13 -23
- package/src/prover/smt/solver/qe.ts +45 -53
- package/src/prover/smt/solver/qsat.ts +70 -90
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
- package/src/prover/smt/solver/quasi-macros.ts +9 -18
- package/src/prover/smt/solver/rational.ts +17 -0
- package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
- package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
- package/src/prover/smt/solver/rewriter.ts +1 -1
- package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
- package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
- package/src/prover/smt/solver/sat/clause.ts +1 -3
- package/src/prover/smt/solver/sat/config.ts +3 -3
- package/src/prover/smt/solver/sat/consequences.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
- package/src/prover/smt/solver/sat/model-converter.ts +1 -15
- package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
- package/src/prover/smt/solver/sat/probing.ts +22 -19
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
- package/src/prover/smt/solver/sat/simplifier.ts +15 -56
- package/src/prover/smt/solver/sat/solver.ts +20 -19
- package/src/prover/smt/solver/sat/watch-list.ts +7 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
- package/src/prover/smt/solver/seq-derive.ts +6 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
- package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
- package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
- package/src/prover/smt/solver/seq-re-util.ts +1 -2
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +4 -4
- package/src/prover/smt/solver/seq-rewriter.ts +1 -4
- package/src/prover/smt/solver/smt-setup.ts +15 -9
- package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
- package/src/prover/smt/solver/smtlib-script.ts +866 -728
- package/src/prover/smt/solver/tactic.ts +66 -14
- package/src/prover/smt/solver/theory-array.ts +25 -58
- package/src/prover/smt/solver/theory-bv.ts +13 -50
- package/src/prover/smt/solver/theory-fpa.ts +46 -78
- package/src/prover/smt/solver/theory-pb.ts +10 -6
- package/src/prover/smt/solver/theory-recfun.ts +2 -2
- package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
- package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
- package/src/prover/smt/solver/theory-seq-state.ts +6 -3
- package/src/prover/smt/solver/theory-seq.ts +32 -54
- package/src/prover/smt/solver/theory.ts +16 -1
- package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
- package/src/prover/smt/solver/var-subst.ts +2 -2
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/zenon/decide.ts +9 -11
- package/src/prover/zenon/node.ts +12 -11
- package/src/prover/zenon/tla/sets.ts +1 -1
- package/src/search.ts +131 -16
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/summary.ts +29 -14
- package/src/typed-tier.ts +6535 -0
- package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
|
@@ -841,28 +841,19 @@ export class AstManager {
|
|
|
841
841
|
domain: number[],
|
|
842
842
|
range: number,
|
|
843
843
|
) {
|
|
844
|
-
|
|
845
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
844
|
+
return this.addDecl(
|
|
846
845
|
name,
|
|
846
|
+
FAMILY_RECFUN,
|
|
847
|
+
op,
|
|
847
848
|
domain,
|
|
848
849
|
range,
|
|
850
|
+
parameters,
|
|
849
851
|
getInfoHash(
|
|
850
852
|
Z3_RECFUN_FAMILY,
|
|
851
853
|
op - RECFUN_OP_BASE,
|
|
852
854
|
op === OP_FUN_CASE_PRED ? [parameters[0], this.declHashes[parameters[1]]] : parameters,
|
|
853
855
|
),
|
|
854
856
|
);
|
|
855
|
-
this.funcDecls.push({
|
|
856
|
-
name,
|
|
857
|
-
family: FAMILY_RECFUN,
|
|
858
|
-
op,
|
|
859
|
-
domain,
|
|
860
|
-
range,
|
|
861
|
-
isSkolem: false,
|
|
862
|
-
smallId: this.mkSmallId(),
|
|
863
|
-
parameters,
|
|
864
|
-
});
|
|
865
|
-
return decl;
|
|
866
857
|
}
|
|
867
858
|
|
|
868
859
|
private getSignature(expr: number) {
|
|
@@ -1112,35 +1103,33 @@ export class AstManager {
|
|
|
1112
1103
|
}
|
|
1113
1104
|
|
|
1114
1105
|
mkSort(name: SmtSymbol) {
|
|
1115
|
-
this.
|
|
1106
|
+
const sort = this.addSort(
|
|
1107
|
+
getSymbolName(name),
|
|
1108
|
+
FAMILY_USER,
|
|
1109
|
+
[],
|
|
1116
1110
|
combineHash(
|
|
1117
1111
|
getSymbolHash(name),
|
|
1118
1112
|
getInfoHash(Z3_USER_SORT_FAMILY, this.getUserSortKind(name), []),
|
|
1119
1113
|
),
|
|
1120
1114
|
);
|
|
1121
|
-
this.sortNames.push(getSymbolName(name));
|
|
1122
|
-
this.sortFamilies.push(FAMILY_USER);
|
|
1123
|
-
this.sortWidths.push(0);
|
|
1124
|
-
this.sortSbits.push(0);
|
|
1125
|
-
this.sortParameters.push([]);
|
|
1126
|
-
this.sortSizes.push(SORT_SIZE_INFINITE);
|
|
1127
1115
|
this.mkSmallId();
|
|
1128
|
-
return
|
|
1116
|
+
return sort;
|
|
1129
1117
|
}
|
|
1130
1118
|
|
|
1131
1119
|
mkBvSort(width: number) {
|
|
1132
1120
|
const existing = this.bvSorts.get(width);
|
|
1133
1121
|
if (existing !== undefined) return existing;
|
|
1134
|
-
this.
|
|
1135
|
-
|
|
1136
|
-
|
|
1137
|
-
|
|
1138
|
-
|
|
1139
|
-
|
|
1140
|
-
|
|
1122
|
+
const sort = this.addSort(
|
|
1123
|
+
"bv",
|
|
1124
|
+
FAMILY_BV,
|
|
1125
|
+
[],
|
|
1126
|
+
combineHash(getSymbolHash("bv"), getInfoHash(Z3_BV_FAMILY, 0, [width])),
|
|
1127
|
+
width,
|
|
1128
|
+
0,
|
|
1129
|
+
width < 64 ? 1n << BigInt(width) : SORT_SIZE_VERY_BIG,
|
|
1130
|
+
);
|
|
1141
1131
|
// bv_decl_plugin makes the sorts up to 64 bits when Z3 starts.
|
|
1142
1132
|
if (width > 64) this.mkSmallId();
|
|
1143
|
-
const sort = this.sortNames.length - 1;
|
|
1144
1133
|
this.bvSorts.set(width, sort);
|
|
1145
1134
|
return sort;
|
|
1146
1135
|
}
|
|
@@ -1149,40 +1138,35 @@ export class AstManager {
|
|
|
1149
1138
|
const key = `${ebits}:${sbits}`;
|
|
1150
1139
|
const existing = this.fpSorts.get(key);
|
|
1151
1140
|
if (existing !== undefined) return existing;
|
|
1152
|
-
this.
|
|
1141
|
+
const sort = this.addSort(
|
|
1142
|
+
"FloatingPoint",
|
|
1143
|
+
FAMILY_FPA,
|
|
1144
|
+
[],
|
|
1153
1145
|
combineHash(
|
|
1154
1146
|
getSymbolHash("FloatingPoint"),
|
|
1155
1147
|
getInfoHash(Z3_FPA_FAMILY, Z3_FLOATING_POINT_SORT, [ebits, sbits]),
|
|
1156
1148
|
),
|
|
1149
|
+
ebits,
|
|
1150
|
+
sbits,
|
|
1151
|
+
SORT_SIZE_VERY_BIG,
|
|
1157
1152
|
);
|
|
1158
|
-
this.sortNames.push("FloatingPoint");
|
|
1159
|
-
this.sortFamilies.push(FAMILY_FPA);
|
|
1160
|
-
this.sortWidths.push(ebits);
|
|
1161
|
-
this.sortSbits.push(sbits);
|
|
1162
|
-
this.sortParameters.push([]);
|
|
1163
|
-
this.sortSizes.push(SORT_SIZE_VERY_BIG);
|
|
1164
1153
|
this.mkSmallId();
|
|
1165
|
-
const sort = this.sortNames.length - 1;
|
|
1166
1154
|
this.fpSorts.set(key, sort);
|
|
1167
1155
|
return sort;
|
|
1168
1156
|
}
|
|
1169
1157
|
|
|
1170
1158
|
mkRmSort() {
|
|
1171
1159
|
if (this.rmSort !== -1) return this.rmSort;
|
|
1172
|
-
this.
|
|
1160
|
+
this.rmSort = this.addSort(
|
|
1161
|
+
"RoundingMode",
|
|
1162
|
+
FAMILY_FPA,
|
|
1163
|
+
[],
|
|
1173
1164
|
combineHash(
|
|
1174
1165
|
getSymbolHash("RoundingMode"),
|
|
1175
1166
|
getInfoHash(Z3_FPA_FAMILY, Z3_ROUNDING_MODE_SORT, []),
|
|
1176
1167
|
),
|
|
1177
1168
|
);
|
|
1178
|
-
this.sortNames.push("RoundingMode");
|
|
1179
|
-
this.sortFamilies.push(FAMILY_FPA);
|
|
1180
|
-
this.sortWidths.push(0);
|
|
1181
|
-
this.sortSbits.push(0);
|
|
1182
|
-
this.sortParameters.push([]);
|
|
1183
|
-
this.sortSizes.push(SORT_SIZE_INFINITE);
|
|
1184
1169
|
this.mkSmallId();
|
|
1185
|
-
this.rmSort = this.sortNames.length - 1;
|
|
1186
1170
|
return this.rmSort;
|
|
1187
1171
|
}
|
|
1188
1172
|
|
|
@@ -1202,27 +1186,44 @@ export class AstManager {
|
|
|
1202
1186
|
return this.sortSbits[sort];
|
|
1203
1187
|
}
|
|
1204
1188
|
|
|
1205
|
-
|
|
1206
|
-
|
|
1207
|
-
|
|
1208
|
-
|
|
1189
|
+
private addDecl(
|
|
1190
|
+
name: SmtSymbol,
|
|
1191
|
+
family: number,
|
|
1192
|
+
op: number,
|
|
1193
|
+
domain: number[],
|
|
1194
|
+
range: number,
|
|
1195
|
+
parameters: number[],
|
|
1196
|
+
infoHash: number,
|
|
1197
|
+
hasSmallId = true,
|
|
1198
|
+
) {
|
|
1209
1199
|
const decl = this.funcDecls.length;
|
|
1210
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
1211
|
-
name,
|
|
1212
|
-
domain,
|
|
1213
|
-
range,
|
|
1214
|
-
getInfoHash(Z3_FPA_FAMILY, op - FPA_OP_BASE, parameters),
|
|
1215
|
-
);
|
|
1200
|
+
this.declHashes[decl] = this.getFuncDeclHash(name, domain, range, infoHash);
|
|
1216
1201
|
this.funcDecls.push({
|
|
1217
1202
|
name,
|
|
1218
|
-
family
|
|
1203
|
+
family,
|
|
1219
1204
|
op,
|
|
1220
1205
|
domain,
|
|
1221
1206
|
range,
|
|
1222
1207
|
isSkolem: false,
|
|
1223
|
-
smallId: this.mkSmallId(),
|
|
1208
|
+
smallId: hasSmallId ? this.mkSmallId() : -1,
|
|
1224
1209
|
parameters,
|
|
1225
1210
|
});
|
|
1211
|
+
return decl;
|
|
1212
|
+
}
|
|
1213
|
+
|
|
1214
|
+
mkFpaDecl(op: number, name: string, parameters: number[], domain: number[], range: number) {
|
|
1215
|
+
const key = `${op}:${name}:${parameters.join(",")}:${domain.join(",")}:${range}`;
|
|
1216
|
+
const existing = this.fpaDecls.get(key);
|
|
1217
|
+
if (existing !== undefined) return existing;
|
|
1218
|
+
const decl = this.addDecl(
|
|
1219
|
+
name,
|
|
1220
|
+
FAMILY_FPA,
|
|
1221
|
+
op,
|
|
1222
|
+
domain,
|
|
1223
|
+
range,
|
|
1224
|
+
parameters,
|
|
1225
|
+
getInfoHash(Z3_FPA_FAMILY, op - FPA_OP_BASE, parameters),
|
|
1226
|
+
);
|
|
1226
1227
|
this.fpaDecls.set(key, decl);
|
|
1227
1228
|
return decl;
|
|
1228
1229
|
}
|
|
@@ -1232,12 +1233,13 @@ export class AstManager {
|
|
|
1232
1233
|
const key = `${op}:${parameters.join(",")}:${domain.join(",")}`;
|
|
1233
1234
|
const existing = this.pbDecls.get(key);
|
|
1234
1235
|
if (existing !== undefined) return existing;
|
|
1235
|
-
const decl = this.
|
|
1236
|
-
|
|
1237
|
-
|
|
1238
|
-
|
|
1236
|
+
const decl = this.addDecl(
|
|
1237
|
+
PB_OP_NAMES[op - PB_OP_BASE],
|
|
1238
|
+
FAMILY_PB,
|
|
1239
|
+
op,
|
|
1239
1240
|
domain,
|
|
1240
1241
|
SORT_BOOL,
|
|
1242
|
+
[],
|
|
1241
1243
|
getInfoHash(
|
|
1242
1244
|
Z3_PB_FAMILY,
|
|
1243
1245
|
op - PB_OP_BASE,
|
|
@@ -1248,16 +1250,6 @@ export class AstManager {
|
|
|
1248
1250
|
),
|
|
1249
1251
|
),
|
|
1250
1252
|
);
|
|
1251
|
-
this.funcDecls.push({
|
|
1252
|
-
name,
|
|
1253
|
-
family: FAMILY_PB,
|
|
1254
|
-
op,
|
|
1255
|
-
domain,
|
|
1256
|
-
range: SORT_BOOL,
|
|
1257
|
-
isSkolem: false,
|
|
1258
|
-
smallId: this.mkSmallId(),
|
|
1259
|
-
parameters: [],
|
|
1260
|
-
});
|
|
1261
1253
|
this.pbParameters.set(decl, parameters);
|
|
1262
1254
|
this.pbDecls.set(key, decl);
|
|
1263
1255
|
return decl;
|
|
@@ -1280,14 +1272,22 @@ export class AstManager {
|
|
|
1280
1272
|
return this.fpValues[id];
|
|
1281
1273
|
}
|
|
1282
1274
|
|
|
1283
|
-
private addSort(
|
|
1275
|
+
private addSort(
|
|
1276
|
+
name: string,
|
|
1277
|
+
family: number,
|
|
1278
|
+
parameters: number[],
|
|
1279
|
+
hash: number,
|
|
1280
|
+
width = 0,
|
|
1281
|
+
sbits = 0,
|
|
1282
|
+
size = SORT_SIZE_INFINITE,
|
|
1283
|
+
) {
|
|
1284
1284
|
this.sortHashes.push(hash);
|
|
1285
1285
|
this.sortNames.push(name);
|
|
1286
1286
|
this.sortFamilies.push(family);
|
|
1287
|
-
this.sortWidths.push(
|
|
1288
|
-
this.sortSbits.push(
|
|
1287
|
+
this.sortWidths.push(width);
|
|
1288
|
+
this.sortSbits.push(sbits);
|
|
1289
1289
|
this.sortParameters.push(parameters);
|
|
1290
|
-
this.sortSizes.push(
|
|
1290
|
+
this.sortSizes.push(size);
|
|
1291
1291
|
return this.sortNames.length - 1;
|
|
1292
1292
|
}
|
|
1293
1293
|
|
|
@@ -1394,27 +1394,19 @@ export class AstManager {
|
|
|
1394
1394
|
const existing = this.seqDecls.get(key);
|
|
1395
1395
|
if (existing !== undefined) return existing;
|
|
1396
1396
|
const isChar = op >= CHAR_OP_BASE;
|
|
1397
|
-
const decl = this.
|
|
1398
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
1397
|
+
const decl = this.addDecl(
|
|
1399
1398
|
name,
|
|
1399
|
+
isChar ? FAMILY_CHAR : FAMILY_SEQ,
|
|
1400
|
+
op,
|
|
1400
1401
|
domain,
|
|
1401
1402
|
range,
|
|
1403
|
+
parameters,
|
|
1402
1404
|
getInfoHash(
|
|
1403
1405
|
isChar ? Z3_CHAR_FAMILY : Z3_SEQ_FAMILY,
|
|
1404
1406
|
op - (isChar ? CHAR_OP_BASE : SEQ_OP_BASE),
|
|
1405
1407
|
parameterHashes,
|
|
1406
1408
|
),
|
|
1407
1409
|
);
|
|
1408
|
-
this.funcDecls.push({
|
|
1409
|
-
name,
|
|
1410
|
-
family: isChar ? FAMILY_CHAR : FAMILY_SEQ,
|
|
1411
|
-
op,
|
|
1412
|
-
domain,
|
|
1413
|
-
range,
|
|
1414
|
-
isSkolem: false,
|
|
1415
|
-
smallId: this.mkSmallId(),
|
|
1416
|
-
parameters,
|
|
1417
|
-
});
|
|
1418
1410
|
this.seqDecls.set(key, decl);
|
|
1419
1411
|
return decl;
|
|
1420
1412
|
}
|
|
@@ -1468,7 +1460,10 @@ export class AstManager {
|
|
|
1468
1460
|
const key = parameters.join(",");
|
|
1469
1461
|
const existing = this.arraySorts.get(key);
|
|
1470
1462
|
if (existing !== undefined) return existing;
|
|
1471
|
-
this.
|
|
1463
|
+
const sort = this.addSort(
|
|
1464
|
+
"Array",
|
|
1465
|
+
FAMILY_ARRAY,
|
|
1466
|
+
parameters,
|
|
1472
1467
|
combineHash(
|
|
1473
1468
|
getSymbolHash("Array"),
|
|
1474
1469
|
getInfoHash(
|
|
@@ -1477,15 +1472,11 @@ export class AstManager {
|
|
|
1477
1472
|
parameters.map((parameter) => this.sortHashes[parameter]),
|
|
1478
1473
|
),
|
|
1479
1474
|
),
|
|
1475
|
+
0,
|
|
1476
|
+
0,
|
|
1477
|
+
this.getArraySortSize(parameters),
|
|
1480
1478
|
);
|
|
1481
|
-
this.sortNames.push("Array");
|
|
1482
|
-
this.sortFamilies.push(FAMILY_ARRAY);
|
|
1483
|
-
this.sortWidths.push(0);
|
|
1484
|
-
this.sortSbits.push(0);
|
|
1485
|
-
this.sortParameters.push(parameters);
|
|
1486
|
-
this.sortSizes.push(this.getArraySortSize(parameters));
|
|
1487
1479
|
this.mkSmallId();
|
|
1488
|
-
const sort = this.sortNames.length - 1;
|
|
1489
1480
|
this.arraySorts.set(key, sort);
|
|
1490
1481
|
return sort;
|
|
1491
1482
|
}
|
|
@@ -1535,7 +1526,6 @@ export class AstManager {
|
|
|
1535
1526
|
const key = `${op}:${parameters.join(",")}:${domain.join(",")}`;
|
|
1536
1527
|
const existing = this.arrayDecls.get(key);
|
|
1537
1528
|
if (existing !== undefined) return existing;
|
|
1538
|
-
const decl = this.funcDecls.length;
|
|
1539
1529
|
const parameterHashes = parameters.map((parameter) =>
|
|
1540
1530
|
op === OP_CONST_ARRAY
|
|
1541
1531
|
? this.sortHashes[parameter]
|
|
@@ -1544,22 +1534,15 @@ export class AstManager {
|
|
|
1544
1534
|
(this.getDeclHash(parameter) ?? 0)
|
|
1545
1535
|
: parameter,
|
|
1546
1536
|
);
|
|
1547
|
-
|
|
1548
|
-
name,
|
|
1549
|
-
domain,
|
|
1550
|
-
range,
|
|
1551
|
-
getInfoHash(Z3_ARRAY_FAMILY, op - ARRAY_OP_BASE, parameterHashes),
|
|
1552
|
-
);
|
|
1553
|
-
this.funcDecls.push({
|
|
1537
|
+
const decl = this.addDecl(
|
|
1554
1538
|
name,
|
|
1555
|
-
|
|
1539
|
+
FAMILY_ARRAY,
|
|
1556
1540
|
op,
|
|
1557
1541
|
domain,
|
|
1558
1542
|
range,
|
|
1559
|
-
isSkolem: false,
|
|
1560
|
-
smallId: this.mkSmallId(),
|
|
1561
1543
|
parameters,
|
|
1562
|
-
|
|
1544
|
+
getInfoHash(Z3_ARRAY_FAMILY, op - ARRAY_OP_BASE, parameterHashes),
|
|
1545
|
+
);
|
|
1563
1546
|
this.arrayDecls.set(key, decl);
|
|
1564
1547
|
return decl;
|
|
1565
1548
|
}
|
|
@@ -1573,14 +1556,12 @@ export class AstManager {
|
|
|
1573
1556
|
const key = `${family}:${typeof name}:${name}:${parameters.join(",")}`;
|
|
1574
1557
|
const existing = this.parametricSorts.get(key);
|
|
1575
1558
|
if (existing !== undefined) return existing;
|
|
1576
|
-
this.
|
|
1577
|
-
|
|
1578
|
-
|
|
1579
|
-
|
|
1580
|
-
|
|
1581
|
-
|
|
1582
|
-
this.sortSizes.push(SORT_SIZE_INFINITE);
|
|
1583
|
-
const sort = this.sortNames.length - 1;
|
|
1559
|
+
const sort = this.addSort(
|
|
1560
|
+
getSymbolName(name),
|
|
1561
|
+
family,
|
|
1562
|
+
parameters,
|
|
1563
|
+
combineHash(getSymbolHash(name), infoHash),
|
|
1564
|
+
);
|
|
1584
1565
|
this.sortSmallIds[sort] = this.mkSmallId();
|
|
1585
1566
|
this.parametricSorts.set(key, sort);
|
|
1586
1567
|
return sort;
|
|
@@ -1653,23 +1634,15 @@ export class AstManager {
|
|
|
1653
1634
|
const key = `${op}:${name}:${parameters.join(",")}:${domain.join(",")}:${range}`;
|
|
1654
1635
|
const existing = this.datatypeDecls.get(key);
|
|
1655
1636
|
if (existing !== undefined) return existing;
|
|
1656
|
-
const decl = this.
|
|
1657
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
1658
|
-
name,
|
|
1659
|
-
domain,
|
|
1660
|
-
range,
|
|
1661
|
-
getInfoHash(Z3_DATATYPE_FAMILY, op - DATATYPE_OP_BASE, parameterHashes),
|
|
1662
|
-
);
|
|
1663
|
-
this.funcDecls.push({
|
|
1637
|
+
const decl = this.addDecl(
|
|
1664
1638
|
name,
|
|
1665
|
-
|
|
1639
|
+
FAMILY_DATATYPE,
|
|
1666
1640
|
op,
|
|
1667
1641
|
domain,
|
|
1668
1642
|
range,
|
|
1669
|
-
isSkolem: false,
|
|
1670
|
-
smallId: this.mkSmallId(),
|
|
1671
1643
|
parameters,
|
|
1672
|
-
|
|
1644
|
+
getInfoHash(Z3_DATATYPE_FAMILY, op - DATATYPE_OP_BASE, parameterHashes),
|
|
1645
|
+
);
|
|
1673
1646
|
this.datatypeDecls.set(key, decl);
|
|
1674
1647
|
return decl;
|
|
1675
1648
|
}
|
|
@@ -1686,23 +1659,16 @@ export class AstManager {
|
|
|
1686
1659
|
const key = `${op}:${parameters.join(",")}:${domain.join(",")}`;
|
|
1687
1660
|
const existing = this.bvDecls.get(key);
|
|
1688
1661
|
if (existing !== undefined) return existing;
|
|
1689
|
-
const decl = this.
|
|
1690
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
1691
|
-
name,
|
|
1692
|
-
domain,
|
|
1693
|
-
range,
|
|
1694
|
-
getInfoHash(Z3_BV_FAMILY, op - BV_OP_BASE, parameters),
|
|
1695
|
-
);
|
|
1696
|
-
this.funcDecls.push({
|
|
1662
|
+
const decl = this.addDecl(
|
|
1697
1663
|
name,
|
|
1698
|
-
|
|
1664
|
+
FAMILY_BV,
|
|
1699
1665
|
op,
|
|
1700
1666
|
domain,
|
|
1701
1667
|
range,
|
|
1702
|
-
isSkolem: false,
|
|
1703
|
-
smallId: UNCACHED_BV_OPS.has(op) ? -1 : this.mkSmallId(),
|
|
1704
1668
|
parameters,
|
|
1705
|
-
|
|
1669
|
+
getInfoHash(Z3_BV_FAMILY, op - BV_OP_BASE, parameters),
|
|
1670
|
+
!UNCACHED_BV_OPS.has(op),
|
|
1671
|
+
);
|
|
1706
1672
|
this.bvDecls.set(key, decl);
|
|
1707
1673
|
return decl;
|
|
1708
1674
|
}
|
|
@@ -2207,7 +2173,7 @@ export class AstManager {
|
|
|
2207
2173
|
const noPatterns = data.patterns.length > 0 ? [] : data.noPatterns;
|
|
2208
2174
|
const key = `q${data.kind}:${data.sorts.join(",")}:${JSON.stringify(data.names)}:${
|
|
2209
2175
|
data.body
|
|
2210
|
-
}:${data.patterns.join(",")}:${noPatterns.join(",")}:${data.weight}`;
|
|
2176
|
+
}:${data.patterns.join(",")}:${noPatterns.join(",")}:${data.weight}:${data.qid}`;
|
|
2211
2177
|
const existing = this.table.get(key);
|
|
2212
2178
|
if (existing !== undefined) {
|
|
2213
2179
|
// A dead quantifier comes back as the new one Z3 makes, with its skolem id.
|
|
@@ -2270,27 +2236,19 @@ export class AstManager {
|
|
|
2270
2236
|
const name = op === OP_LABEL_LIT ? "lbl-lit" : isPositive ? "lblpos" : "lblneg";
|
|
2271
2237
|
const domain = op === OP_LABEL ? [SORT_BOOL] : [];
|
|
2272
2238
|
const parameterHashes = names.map(getSymbolHash);
|
|
2273
|
-
const decl = this.
|
|
2274
|
-
this.declHashes[decl] = this.getFuncDeclHash(
|
|
2239
|
+
const decl = this.addDecl(
|
|
2275
2240
|
name,
|
|
2241
|
+
FAMILY_LABEL,
|
|
2242
|
+
op,
|
|
2276
2243
|
domain,
|
|
2277
2244
|
SORT_BOOL,
|
|
2245
|
+
parameters,
|
|
2278
2246
|
getInfoHash(
|
|
2279
2247
|
Z3_LABEL_FAMILY,
|
|
2280
2248
|
op - LABEL_OP_BASE,
|
|
2281
2249
|
op === OP_LABEL ? [isPositive ? 1 : 0, ...parameterHashes] : parameterHashes,
|
|
2282
2250
|
),
|
|
2283
2251
|
);
|
|
2284
|
-
this.funcDecls.push({
|
|
2285
|
-
name,
|
|
2286
|
-
family: FAMILY_LABEL,
|
|
2287
|
-
op,
|
|
2288
|
-
domain,
|
|
2289
|
-
range: SORT_BOOL,
|
|
2290
|
-
isSkolem: false,
|
|
2291
|
-
smallId: this.mkSmallId(),
|
|
2292
|
-
parameters,
|
|
2293
|
-
});
|
|
2294
2252
|
this.labelDecls.set(key, decl);
|
|
2295
2253
|
return decl;
|
|
2296
2254
|
}
|
|
@@ -10,6 +10,7 @@ import {
|
|
|
10
10
|
OP_OR,
|
|
11
11
|
OP_UMINUS,
|
|
12
12
|
} from "./ast";
|
|
13
|
+
import type { Dependency } from "./goal";
|
|
13
14
|
import { Rational } from "./rational";
|
|
14
15
|
|
|
15
16
|
interface Limit {
|
|
@@ -34,6 +35,8 @@ const NEGATED = new Map([
|
|
|
34
35
|
export class BoundManager {
|
|
35
36
|
readonly lowers = new Map<number, Limit>();
|
|
36
37
|
readonly uppers = new Map<number, Limit>();
|
|
38
|
+
readonly lowerDependencies = new Map<number, Dependency>();
|
|
39
|
+
readonly upperDependencies = new Map<number, Dependency>();
|
|
37
40
|
readonly boundedVars: number[] = [];
|
|
38
41
|
|
|
39
42
|
constructor(readonly manager: AstManager) {}
|
|
@@ -48,9 +51,9 @@ export class BoundManager {
|
|
|
48
51
|
return { value: manager.getRationalValue(expr), isInt: manager.isInt(expr) };
|
|
49
52
|
}
|
|
50
53
|
|
|
51
|
-
add(form: number) {
|
|
54
|
+
add(form: number, dependency?: Dependency) {
|
|
52
55
|
const manager = this.manager;
|
|
53
|
-
if (this.isDisjunctiveBound(form) || this.isEqualityBound(form)) return;
|
|
56
|
+
if (this.isDisjunctiveBound(form, dependency) || this.isEqualityBound(form, dependency)) return;
|
|
54
57
|
let atom = form;
|
|
55
58
|
let isPositive = true;
|
|
56
59
|
while (manager.isNot(atom)) {
|
|
@@ -79,35 +82,43 @@ export class BoundManager {
|
|
|
79
82
|
: { value: found.numeral.value, op };
|
|
80
83
|
const isStrict = normalized.op === OP_LT || normalized.op === OP_GT;
|
|
81
84
|
if (normalized.op === OP_GT || normalized.op === OP_GE)
|
|
82
|
-
this.insertLower(found.variable, isStrict, normalized.value);
|
|
83
|
-
else this.insertUpper(found.variable, isStrict, normalized.value);
|
|
85
|
+
this.insertLower(found.variable, isStrict, normalized.value, dependency);
|
|
86
|
+
else this.insertUpper(found.variable, isStrict, normalized.value, dependency);
|
|
84
87
|
}
|
|
85
88
|
|
|
86
|
-
private insertUpper(
|
|
89
|
+
private insertUpper(
|
|
90
|
+
variable: number,
|
|
91
|
+
isStrict: boolean,
|
|
92
|
+
value: Rational,
|
|
93
|
+
dependency: Dependency | undefined,
|
|
94
|
+
) {
|
|
87
95
|
const old = this.uppers.get(variable);
|
|
88
|
-
if (old
|
|
89
|
-
|
|
90
|
-
if (!
|
|
91
|
-
return;
|
|
96
|
+
if (old !== undefined) {
|
|
97
|
+
const order = value.compare(old.value);
|
|
98
|
+
if (order > 0 || (order === 0 && (!isStrict || old.isStrict))) return;
|
|
92
99
|
}
|
|
93
|
-
|
|
94
|
-
if (
|
|
95
|
-
|
|
100
|
+
this.uppers.set(variable, { value, isStrict });
|
|
101
|
+
if (dependency !== undefined) this.upperDependencies.set(variable, dependency);
|
|
102
|
+
if (old === undefined && !this.lowers.has(variable)) this.boundedVars.push(variable);
|
|
96
103
|
}
|
|
97
104
|
|
|
98
|
-
private insertLower(
|
|
105
|
+
private insertLower(
|
|
106
|
+
variable: number,
|
|
107
|
+
isStrict: boolean,
|
|
108
|
+
value: Rational,
|
|
109
|
+
dependency: Dependency | undefined,
|
|
110
|
+
) {
|
|
99
111
|
const old = this.lowers.get(variable);
|
|
100
|
-
if (old
|
|
101
|
-
|
|
102
|
-
if (!
|
|
103
|
-
return;
|
|
112
|
+
if (old !== undefined) {
|
|
113
|
+
const order = value.compare(old.value);
|
|
114
|
+
if (order < 0 || (order === 0 && (!isStrict || old.isStrict))) return;
|
|
104
115
|
}
|
|
105
|
-
|
|
106
|
-
if (
|
|
107
|
-
|
|
116
|
+
this.lowers.set(variable, { value, isStrict });
|
|
117
|
+
if (dependency !== undefined) this.lowerDependencies.set(variable, dependency);
|
|
118
|
+
if (old === undefined && !this.uppers.has(variable)) this.boundedVars.push(variable);
|
|
108
119
|
}
|
|
109
120
|
|
|
110
|
-
private isEqualityBound(form: number) {
|
|
121
|
+
private isEqualityBound(form: number, dependency: Dependency | undefined) {
|
|
111
122
|
const manager = this.manager;
|
|
112
123
|
if (manager.getOp(form) !== OP_EQ) return false;
|
|
113
124
|
const first = manager.getArg(form, 0);
|
|
@@ -117,19 +128,19 @@ export class BoundManager {
|
|
|
117
128
|
const other = isSwapped ? first : second;
|
|
118
129
|
const numeral = this.getNumeral(other);
|
|
119
130
|
if (manager.isUninterpretedConst(variable) && numeral !== undefined) {
|
|
120
|
-
this.insertLower(variable, false, numeral.value);
|
|
121
|
-
this.insertUpper(variable, false, numeral.value);
|
|
131
|
+
this.insertLower(variable, false, numeral.value, dependency);
|
|
132
|
+
this.insertUpper(variable, false, numeral.value, dependency);
|
|
122
133
|
return true;
|
|
123
134
|
}
|
|
124
135
|
if (manager.getOp(other) !== OP_MOD) return false;
|
|
125
136
|
const modulus = this.getNumeral(manager.getArg(other, 1));
|
|
126
137
|
if (modulus === undefined || !modulus.value.isPositive()) return false;
|
|
127
|
-
this.insertLower(variable, false, Rational.zero);
|
|
128
|
-
this.insertUpper(variable, false, modulus.value.sub(Rational.one));
|
|
138
|
+
this.insertLower(variable, false, Rational.zero, dependency);
|
|
139
|
+
this.insertUpper(variable, false, modulus.value.sub(Rational.one), dependency);
|
|
129
140
|
return true;
|
|
130
141
|
}
|
|
131
142
|
|
|
132
|
-
private isDisjunctiveBound(form: number) {
|
|
143
|
+
private isDisjunctiveBound(form: number, dependency: Dependency | undefined) {
|
|
133
144
|
const manager = this.manager;
|
|
134
145
|
if (manager.getOp(form) !== OP_OR || manager.getNumArgs(form) === 0) return false;
|
|
135
146
|
let variable = -1;
|
|
@@ -160,8 +171,8 @@ export class BoundManager {
|
|
|
160
171
|
if (found.value.compare(lower) < 0) lower = found.value;
|
|
161
172
|
if (found.value.compare(upper) > 0) upper = found.value;
|
|
162
173
|
}
|
|
163
|
-
this.insertLower(variable, false, lower);
|
|
164
|
-
this.insertUpper(variable, false, upper);
|
|
174
|
+
this.insertLower(variable, false, lower, dependency);
|
|
175
|
+
this.insertUpper(variable, false, upper, dependency);
|
|
165
176
|
return true;
|
|
166
177
|
}
|
|
167
178
|
|
|
@@ -5,22 +5,18 @@ import {
|
|
|
5
5
|
type AstManager,
|
|
6
6
|
FAMILY_BASIC,
|
|
7
7
|
KIND_APP,
|
|
8
|
-
OP_ADD,
|
|
9
8
|
OP_AND,
|
|
10
9
|
OP_ARRAY_MAP,
|
|
11
10
|
OP_BADD,
|
|
12
11
|
OP_EQ,
|
|
13
12
|
OP_EXTRACT,
|
|
14
|
-
OP_MUL,
|
|
15
13
|
OP_NOT,
|
|
16
14
|
OP_OR,
|
|
17
|
-
OP_SEQ_CONCAT,
|
|
18
15
|
OP_SLEQ,
|
|
19
16
|
OP_ULEQ,
|
|
20
|
-
OP_XOR,
|
|
21
17
|
SORT_BOOL,
|
|
22
18
|
} from "./ast";
|
|
23
|
-
import {
|
|
19
|
+
import { isAssociativeOp } from "./ast-util";
|
|
24
20
|
import { release } from "./expr-ref";
|
|
25
21
|
import type { Goal } from "./goal";
|
|
26
22
|
import { ObjMap } from "./hashtable";
|
|
@@ -30,8 +26,6 @@ const CONVERTED = 0;
|
|
|
30
26
|
const UNSAT = 1;
|
|
31
27
|
const UNDEF = 2;
|
|
32
28
|
|
|
33
|
-
const ASSOCIATIVE_OPS = new Set([OP_AND, OP_OR, OP_XOR, OP_ADD, OP_MUL, OP_SEQ_CONCAT]);
|
|
34
|
-
|
|
35
29
|
interface Interval {
|
|
36
30
|
lo: bigint;
|
|
37
31
|
hi: bigint;
|
|
@@ -466,7 +460,7 @@ class BvBoundChkRewriter extends RewriterTpl {
|
|
|
466
460
|
const funcDecl = this.manager.funcDecls[decl];
|
|
467
461
|
return funcDecl.op === OP_ARRAY_MAP
|
|
468
462
|
? this.isFlatAssoc(funcDecl.parameters[0])
|
|
469
|
-
:
|
|
463
|
+
: isAssociativeOp(funcDecl.op);
|
|
470
464
|
}
|
|
471
465
|
|
|
472
466
|
isRewritingPatterns() {
|