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
|
@@ -13,7 +13,6 @@ import {
|
|
|
13
13
|
OP_FPA_TO_SBV,
|
|
14
14
|
OP_FPA_TO_UBV,
|
|
15
15
|
OP_IMPLIES,
|
|
16
|
-
OP_ITE,
|
|
17
16
|
OP_ULEQ,
|
|
18
17
|
SORT_BOOL,
|
|
19
18
|
} from "./ast";
|
|
@@ -182,15 +181,12 @@ export class TheoryFpa extends Theory {
|
|
|
182
181
|
context.setVarTheory(boolVar, this.id);
|
|
183
182
|
for (let index = 0; index < manager.getNumArgs(atom); index++)
|
|
184
183
|
context.internalize(manager.getArg(atom, index), false);
|
|
185
|
-
manager.
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
},
|
|
192
|
-
() => [],
|
|
193
|
-
);
|
|
184
|
+
const outer = manager.beginTemporaries();
|
|
185
|
+
const bvAtom = this.rewriter.convert(this.theoryRewriter, atom);
|
|
186
|
+
manager.releaseLater(bvAtom);
|
|
187
|
+
const withSideConditions = this.rewrite(manager.mkAnd([bvAtom, this.mkSideConditions()]));
|
|
188
|
+
this.assertCnstr(manager.mkEq(atom, withSideConditions));
|
|
189
|
+
manager.endTemporaries(outer);
|
|
194
190
|
return true;
|
|
195
191
|
}
|
|
196
192
|
|
|
@@ -202,14 +198,12 @@ export class TheoryFpa extends Theory {
|
|
|
202
198
|
const node = context.getEnode(term) ?? context.mkEnode(term, false, false, true);
|
|
203
199
|
if (this.isAttachedToVar(node)) return true;
|
|
204
200
|
this.attachNewThVar(node);
|
|
205
|
-
if (CONVERTED_OPS.has(manager.getOp(term)))
|
|
206
|
-
manager.
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
() => [],
|
|
212
|
-
);
|
|
201
|
+
if (CONVERTED_OPS.has(manager.getOp(term))) {
|
|
202
|
+
const outer = manager.beginTemporaries();
|
|
203
|
+
this.assertCnstr(manager.mkEq(term, this.convert(term)));
|
|
204
|
+
this.assertCnstr(this.mkSideConditions());
|
|
205
|
+
manager.endTemporaries(outer);
|
|
206
|
+
}
|
|
213
207
|
if (!context.relevancy.isEnabled) this.relevantEh(term);
|
|
214
208
|
return true;
|
|
215
209
|
}
|
|
@@ -219,14 +213,12 @@ export class TheoryFpa extends Theory {
|
|
|
219
213
|
if (this.isAttachedToVar(node)) return;
|
|
220
214
|
this.attachNewThVar(node);
|
|
221
215
|
const owner = node.owner;
|
|
222
|
-
if (manager.isRmSort(manager.sorts[owner]) && manager.getOp(owner) !== OP_FPA_BV2RM)
|
|
223
|
-
manager.
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
() => [],
|
|
229
|
-
);
|
|
216
|
+
if (manager.isRmSort(manager.sorts[owner]) && manager.getOp(owner) !== OP_FPA_BV2RM) {
|
|
217
|
+
const outer = manager.beginTemporaries();
|
|
218
|
+
const limit = manager.mkBvNumeral(4n, 3);
|
|
219
|
+
this.assertCnstr(mkBvApp(manager, OP_ULEQ, [this.converter.wrap(owner), limit]));
|
|
220
|
+
manager.endTemporaries(outer);
|
|
221
|
+
}
|
|
230
222
|
if (!this.context.relevancy.isEnabled) this.relevantEh(owner);
|
|
231
223
|
}
|
|
232
224
|
|
|
@@ -244,57 +236,48 @@ export class TheoryFpa extends Theory {
|
|
|
244
236
|
const secondExpr = this.getExpr(second);
|
|
245
237
|
if (manager.getOp(firstExpr) === OP_FPA_BVWRAP || manager.getOp(secondExpr) === OP_FPA_BVWRAP)
|
|
246
238
|
return;
|
|
247
|
-
manager.
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
},
|
|
260
|
-
() => [],
|
|
261
|
-
);
|
|
239
|
+
const outer = manager.beginTemporaries();
|
|
240
|
+
const firstConverted = this.convert(firstExpr);
|
|
241
|
+
const secondConverted = this.convert(secondExpr);
|
|
242
|
+
const isFloatPair = this.isFloat(firstExpr) && this.isFloat(secondExpr);
|
|
243
|
+
const eq = isFloatPair
|
|
244
|
+
? this.converter.mkEq(firstConverted, secondConverted)
|
|
245
|
+
: manager.mkEq(firstConverted, secondConverted);
|
|
246
|
+
const condition = this.rewrite(isNegated ? manager.mkNot(eq) : eq);
|
|
247
|
+
const exprEq = manager.mkEq(firstExpr, secondExpr);
|
|
248
|
+
this.assertCnstr(manager.mkEq(isNegated ? manager.mkNot(exprEq) : exprEq, condition));
|
|
249
|
+
this.assertCnstr(this.mkSideConditions());
|
|
250
|
+
manager.endTemporaries(outer);
|
|
262
251
|
}
|
|
263
252
|
|
|
264
253
|
override assignEh(boolVar: BoolVar, isTrue: boolean) {
|
|
265
254
|
const manager = this.manager;
|
|
266
255
|
const expr = this.context.boolVar2Expr[boolVar];
|
|
267
|
-
manager.
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
},
|
|
275
|
-
() => [],
|
|
276
|
-
);
|
|
256
|
+
const outer = manager.beginTemporaries();
|
|
257
|
+
const converted = manager.mkAnd([this.convert(expr), this.mkSideConditions()]);
|
|
258
|
+
const constraint = isTrue
|
|
259
|
+
? manager.mkApp(OP_IMPLIES, [expr, converted], SORT_BOOL)
|
|
260
|
+
: manager.mkApp(OP_IMPLIES, [converted, expr], SORT_BOOL);
|
|
261
|
+
this.assertCnstr(this.rewrite(constraint));
|
|
262
|
+
manager.endTemporaries(outer);
|
|
277
263
|
}
|
|
278
264
|
|
|
279
265
|
override relevantEh(expr: number) {
|
|
280
266
|
const manager = this.manager;
|
|
281
267
|
const op = manager.getOp(expr);
|
|
282
268
|
if (!this.isFloat(expr)) {
|
|
283
|
-
if (manager.getFamily(expr) === FAMILY_FPA && CONVERTED_OPS.has(op))
|
|
284
|
-
manager.
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
() => [],
|
|
290
|
-
);
|
|
269
|
+
if (manager.getFamily(expr) === FAMILY_FPA && CONVERTED_OPS.has(op)) {
|
|
270
|
+
const outer = manager.beginTemporaries();
|
|
271
|
+
this.assertCnstr(manager.mkEq(expr, this.convert(expr)));
|
|
272
|
+
this.assertCnstr(this.mkSideConditions());
|
|
273
|
+
manager.endTemporaries(outer);
|
|
274
|
+
}
|
|
291
275
|
return;
|
|
292
276
|
}
|
|
293
277
|
if (op === OP_FPA_FP) return;
|
|
294
|
-
manager.
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
);
|
|
278
|
+
const outer = manager.beginTemporaries();
|
|
279
|
+
this.assertValueConstraints(expr);
|
|
280
|
+
manager.endTemporaries(outer);
|
|
298
281
|
}
|
|
299
282
|
|
|
300
283
|
private assertValueConstraints(expr: number) {
|
|
@@ -361,21 +344,6 @@ export class TheoryFpa extends Theory {
|
|
|
361
344
|
super.popScopeEh(numScopes);
|
|
362
345
|
}
|
|
363
346
|
|
|
364
|
-
private getIteValue(expr: number) {
|
|
365
|
-
const context = this.context;
|
|
366
|
-
const manager = this.manager;
|
|
367
|
-
let current = expr;
|
|
368
|
-
while (manager.getOp(current) === OP_ITE && context.isEInternalized(current)) {
|
|
369
|
-
const root = context.getEnode(current)?.root;
|
|
370
|
-
const thenExpr = manager.getArg(current, 1);
|
|
371
|
-
const elseExpr = manager.getArg(current, 2);
|
|
372
|
-
if (context.getEnode(thenExpr)?.root === root) current = thenExpr;
|
|
373
|
-
else if (context.getEnode(elseExpr)?.root === root) current = elseExpr;
|
|
374
|
-
else break;
|
|
375
|
-
}
|
|
376
|
-
return current;
|
|
377
|
-
}
|
|
378
|
-
|
|
379
347
|
override mkValue(node: Enode): number | DependentValue | undefined {
|
|
380
348
|
const context = this.context;
|
|
381
349
|
const manager = this.manager;
|
|
@@ -694,19 +694,23 @@ export class TheoryPb extends Theory {
|
|
|
694
694
|
override popScopeEh(numScopes: number) {
|
|
695
695
|
let newLim = this.ineqsLim.length - numScopes;
|
|
696
696
|
let size = this.ineqsLim[newLim];
|
|
697
|
-
|
|
698
|
-
const boolVar = this.ineqsTrail
|
|
699
|
-
this.
|
|
697
|
+
for (let index = this.ineqsTrail.length - 1; index >= size; index--) {
|
|
698
|
+
const boolVar = this.ineqsTrail[index];
|
|
699
|
+
const ineq = this.ineqs[boolVar];
|
|
700
|
+
if (ineq !== undefined) this.clearIneqWatch(ineq);
|
|
700
701
|
this.ineqs[boolVar] = undefined;
|
|
701
702
|
}
|
|
703
|
+
this.ineqsTrail.length = size;
|
|
702
704
|
this.ineqsLim.length = newLim;
|
|
703
705
|
newLim = this.cardLim.length - numScopes;
|
|
704
706
|
size = this.cardLim[newLim];
|
|
705
|
-
|
|
706
|
-
const boolVar = this.cardTrail
|
|
707
|
-
this.
|
|
707
|
+
for (let index = this.cardTrail.length - 1; index >= size; index--) {
|
|
708
|
+
const boolVar = this.cardTrail[index];
|
|
709
|
+
const card = this.cards[boolVar];
|
|
710
|
+
if (card !== undefined) this.clearCardWatch(card);
|
|
708
711
|
this.cards[boolVar] = undefined;
|
|
709
712
|
}
|
|
713
|
+
this.cardTrail.length = size;
|
|
710
714
|
this.cardLim.length = newLim;
|
|
711
715
|
super.popScopeEh(numScopes);
|
|
712
716
|
}
|
|
@@ -112,8 +112,8 @@ export class TheoryRecfun extends Theory {
|
|
|
112
112
|
for (const expr of exprs) this.keep(expr);
|
|
113
113
|
this.propagationQueue.push({ kind, exprs });
|
|
114
114
|
this.context.pushTrail(() => {
|
|
115
|
-
|
|
116
|
-
|
|
115
|
+
this.propagationQueue.pop();
|
|
116
|
+
for (const expr of exprs) this.manager.decRef(expr);
|
|
117
117
|
});
|
|
118
118
|
}
|
|
119
119
|
|
|
@@ -218,8 +218,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
|
|
|
218
218
|
private collectVars(seq: number, vars: number[]) {
|
|
219
219
|
const manager = this.manager;
|
|
220
220
|
const todo = [seq];
|
|
221
|
-
|
|
222
|
-
const expr = todo.pop()!;
|
|
221
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
223
222
|
if (manager.getOp(expr) === OP_SEQ_CONCAT) {
|
|
224
223
|
todo.push(...manager.getArgs(expr));
|
|
225
224
|
continue;
|
|
@@ -257,8 +256,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
|
|
|
257
256
|
const manager = this.manager;
|
|
258
257
|
const todo = [term];
|
|
259
258
|
let length = 0;
|
|
260
|
-
|
|
261
|
-
const expr = todo.pop()!;
|
|
259
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
262
260
|
if (this.isConcat(expr)) {
|
|
263
261
|
todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
|
|
264
262
|
continue;
|
|
@@ -508,8 +506,7 @@ export abstract class TheorySeqRegex extends TheorySeqSolve {
|
|
|
508
506
|
if (this.hasLength(seq)) return true;
|
|
509
507
|
const todo = [seq];
|
|
510
508
|
let hasVar = false;
|
|
511
|
-
|
|
512
|
-
const expr = todo.pop()!;
|
|
509
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
513
510
|
if (this.isConcat(expr)) {
|
|
514
511
|
todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
|
|
515
512
|
continue;
|
|
@@ -360,11 +360,11 @@ export abstract class TheorySeqSolve extends TheorySeqState {
|
|
|
360
360
|
this.propagateEq(deps, front, ls[0], rs[0], true);
|
|
361
361
|
return true;
|
|
362
362
|
}
|
|
363
|
-
const back = this.reduceLength(ls.
|
|
363
|
+
const back = this.reduceLength(ls[ls.length - 1], rs[rs.length - 1]);
|
|
364
364
|
if (back !== undefined) {
|
|
365
365
|
const deps = this.mkJoinLiterals(inputDeps, back);
|
|
366
366
|
this.eqs.push(this.mkDepEq(this.eqId++, ls.slice(0, -1), rs.slice(0, -1), deps));
|
|
367
|
-
this.propagateEq(deps, back, ls.
|
|
367
|
+
this.propagateEq(deps, back, ls[ls.length - 1], rs[rs.length - 1], true);
|
|
368
368
|
return true;
|
|
369
369
|
}
|
|
370
370
|
const getLength = (expr: number) => this.getLengthValue(expr);
|
|
@@ -404,7 +404,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
|
|
|
404
404
|
const sumBack = (first: number, others: readonly number[], isStrict: boolean) => {
|
|
405
405
|
const firstLength = getLength(first);
|
|
406
406
|
if (firstLength === undefined) return undefined;
|
|
407
|
-
let total = getLength(others.
|
|
407
|
+
let total = getLength(others[others.length - 1]);
|
|
408
408
|
if (total === undefined) return undefined;
|
|
409
409
|
if (isStrict ? firstLength.compare(total) <= 0 : firstLength.compare(total) < 0)
|
|
410
410
|
return undefined;
|
|
@@ -417,7 +417,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
|
|
|
417
417
|
return firstLength.equals(total) && index > 0 ? index : undefined;
|
|
418
418
|
};
|
|
419
419
|
if (ls.length > 1) {
|
|
420
|
-
const index = sumBack(ls.
|
|
420
|
+
const index = sumBack(ls[ls.length - 1], rs, false);
|
|
421
421
|
if (
|
|
422
422
|
index !== undefined &&
|
|
423
423
|
index < rs.length &&
|
|
@@ -426,7 +426,7 @@ export abstract class TheorySeqSolve extends TheorySeqState {
|
|
|
426
426
|
return true;
|
|
427
427
|
}
|
|
428
428
|
if (rs.length > 1) {
|
|
429
|
-
const index = sumBack(rs.
|
|
429
|
+
const index = sumBack(rs[rs.length - 1], ls, true);
|
|
430
430
|
if (
|
|
431
431
|
index !== undefined &&
|
|
432
432
|
index < ls.length &&
|
|
@@ -348,7 +348,6 @@ export abstract class TheorySeqState extends Theory {
|
|
|
348
348
|
protected intStrings: number[] = [];
|
|
349
349
|
protected hasLengthSet = new Set<number>();
|
|
350
350
|
protected lengths: number[] = [];
|
|
351
|
-
protected lengthLimitMap = new Map<number, number>();
|
|
352
351
|
protected lengthLimits: number[] = [];
|
|
353
352
|
protected replay: (() => void)[] = [];
|
|
354
353
|
protected strRewriter: Rewriter;
|
|
@@ -600,8 +599,7 @@ export abstract class TheorySeqState extends Theory {
|
|
|
600
599
|
const manager = this.manager;
|
|
601
600
|
let value = Rational.zero;
|
|
602
601
|
const todo = [input];
|
|
603
|
-
|
|
604
|
-
const expr = todo.pop()!;
|
|
602
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
605
603
|
const op = manager.getOp(expr);
|
|
606
604
|
const chars = manager.getString(expr);
|
|
607
605
|
if (this.isConcat(expr)) todo.push(manager.getArg(expr, 0), manager.getArg(expr, 1));
|
|
@@ -748,8 +746,13 @@ export abstract class TheorySeqState extends Theory {
|
|
|
748
746
|
isAddingToEqs = true,
|
|
749
747
|
) {
|
|
750
748
|
const context = this.context;
|
|
749
|
+
const manager = this.manager;
|
|
750
|
+
manager.incRef(firstExpr);
|
|
751
|
+
manager.incRef(secondExpr);
|
|
751
752
|
const first = this.ensureEnodeOf(firstExpr);
|
|
752
753
|
const second = this.ensureEnodeOf(secondExpr);
|
|
754
|
+
manager.decRef(secondExpr);
|
|
755
|
+
manager.decRef(firstExpr);
|
|
753
756
|
if (first.root === second.root) return false;
|
|
754
757
|
context.markAsRelevant(first.owner);
|
|
755
758
|
context.markAsRelevant(second.owner);
|
|
@@ -3,7 +3,6 @@ import { SmtUnsupportedError } from "../../../errors";
|
|
|
3
3
|
import {
|
|
4
4
|
FAMILY_SEQ,
|
|
5
5
|
OP_EQ,
|
|
6
|
-
OP_ITE,
|
|
7
6
|
OP_SEQ_AT,
|
|
8
7
|
OP_SEQ_CONTAINS,
|
|
9
8
|
OP_SEQ_EXTRACT,
|
|
@@ -79,29 +78,26 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
79
78
|
finalCheckEh() {
|
|
80
79
|
if (!this.hasSeq) return FC_DONE;
|
|
81
80
|
this.isNewPropagation = false;
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
() => this.finalCheckRegex(),
|
|
103
|
-
];
|
|
104
|
-
if (checks.some((check) => check())) return FC_CONTINUE;
|
|
81
|
+
if (this.simplifyAndSolveEqs()) return FC_CONTINUE;
|
|
82
|
+
if (this.checkEquationConflict()) return FC_CONTINUE;
|
|
83
|
+
if (this.checkLts()) return FC_CONTINUE;
|
|
84
|
+
if (this.solveNqs(0)) return FC_CONTINUE;
|
|
85
|
+
if (this.checkFixedLength(true, false)) return FC_CONTINUE;
|
|
86
|
+
if (this.checkFixedLength(false, false)) return FC_CONTINUE;
|
|
87
|
+
if (this.checkFixedLength(false, true)) return FC_CONTINUE;
|
|
88
|
+
if (this.checkContains()) return FC_CONTINUE;
|
|
89
|
+
if (this.checkIntString()) return FC_CONTINUE;
|
|
90
|
+
if (this.reduceLengthEq()) return FC_CONTINUE;
|
|
91
|
+
if (this.branchUnitVariable()) return FC_CONTINUE;
|
|
92
|
+
if (this.branchBinaryVariable()) return FC_CONTINUE;
|
|
93
|
+
if (this.branchVariable()) return FC_CONTINUE;
|
|
94
|
+
if (this.checkLengthCoherence()) return FC_CONTINUE;
|
|
95
|
+
if (!this.checkExtensionality()) return FC_CONTINUE;
|
|
96
|
+
if (this.branchNqs()) return FC_CONTINUE;
|
|
97
|
+
if (this.branchItos()) return FC_CONTINUE;
|
|
98
|
+
if (this.checkFixedLength(false, true)) return FC_CONTINUE;
|
|
99
|
+
if (this.solveRecfuns()) return FC_CONTINUE;
|
|
100
|
+
if (this.finalCheckRegex()) return FC_CONTINUE;
|
|
105
101
|
if (this.unhandledExpr !== undefined) return FC_GIVEUP;
|
|
106
102
|
return this.eqs.size === 0 && this.ncs.size === 0 ? FC_DONE : FC_GIVEUP;
|
|
107
103
|
}
|
|
@@ -140,8 +136,9 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
140
136
|
if (op === OP_STRING_UBVTOS || op === OP_STRING_SBVTOS)
|
|
141
137
|
throw new SmtUnsupportedError("str.from_ubv in the theory of sequences");
|
|
142
138
|
if (op === OP_SEQ_LENGTH) this.mkVar(this.ensureEnodeOf(manager.getArg(term, 0)));
|
|
143
|
-
|
|
144
|
-
|
|
139
|
+
const existing = context.getEnode(term);
|
|
140
|
+
if (existing !== undefined) {
|
|
141
|
+
this.mkVar(existing);
|
|
145
142
|
return true;
|
|
146
143
|
}
|
|
147
144
|
const isBool = manager.isBool(term);
|
|
@@ -155,10 +152,7 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
155
152
|
context.setVarTheory(context.mkBoolVar(term), this.id);
|
|
156
153
|
context.markAsRelevant(term);
|
|
157
154
|
}
|
|
158
|
-
|
|
159
|
-
? context.getEnode(term)!
|
|
160
|
-
: context.mkEnode(term, false, isBool, true);
|
|
161
|
-
this.mkVar(node);
|
|
155
|
+
this.mkVar(context.getEnode(term) ?? context.mkEnode(term, false, isBool, true));
|
|
162
156
|
if (!context.relevancy.isEnabled) this.relevantEh(term);
|
|
163
157
|
return true;
|
|
164
158
|
}
|
|
@@ -389,8 +383,7 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
389
383
|
private addLengthLimit(input: number, limit: number, isSearching: boolean) {
|
|
390
384
|
const manager = this.manager;
|
|
391
385
|
const todo = [input];
|
|
392
|
-
|
|
393
|
-
const expr = todo.pop()!;
|
|
386
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
394
387
|
if (this.isConcat(expr)) {
|
|
395
388
|
todo.push(...manager.getArgs(expr));
|
|
396
389
|
continue;
|
|
@@ -810,16 +803,16 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
810
803
|
minSeq = limit.seq;
|
|
811
804
|
}
|
|
812
805
|
}
|
|
813
|
-
if (minLimit < MAX_UNFOLDING) {
|
|
806
|
+
if (minSeq !== undefined && minLimit < MAX_UNFOLDING) {
|
|
814
807
|
this.maxUnfoldingDepth++;
|
|
815
808
|
let limit = minLimit * 2;
|
|
816
|
-
if (this.isSeq(minSeq
|
|
817
|
-
limit = Math.max(this.getMinLength(minSeq
|
|
818
|
-
const lower = this.lowerBound2(minSeq
|
|
809
|
+
if (this.isSeq(minSeq)) {
|
|
810
|
+
limit = Math.max(this.getMinLength(minSeq), limit);
|
|
811
|
+
const lower = this.lowerBound2(minSeq);
|
|
819
812
|
if (lower !== undefined && !lower.isNegative() && lower.num <= 0xffffffffn)
|
|
820
813
|
limit = Math.max(Number(lower.num), limit);
|
|
821
814
|
}
|
|
822
|
-
this.addLengthLimit(minSeq
|
|
815
|
+
this.addLengthLimit(minSeq, limit, false);
|
|
823
816
|
return true;
|
|
824
817
|
}
|
|
825
818
|
if (hasMaxUnfolding) {
|
|
@@ -860,21 +853,6 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
860
853
|
this.rep.popScope(1);
|
|
861
854
|
}
|
|
862
855
|
|
|
863
|
-
private getIteValue(input: number) {
|
|
864
|
-
const context = this.context;
|
|
865
|
-
const manager = this.manager;
|
|
866
|
-
let expr = input;
|
|
867
|
-
while (this.isOp(expr, OP_ITE) && context.isEInternalized(expr)) {
|
|
868
|
-
const root = context.getEnode(expr)!.root;
|
|
869
|
-
const thenExpr = manager.getArg(expr, 1);
|
|
870
|
-
const elseExpr = manager.getArg(expr, 2);
|
|
871
|
-
if (context.getEnode(thenExpr)!.root === root) expr = thenExpr;
|
|
872
|
-
else if (context.getEnode(elseExpr)!.root === root) expr = elseExpr;
|
|
873
|
-
else break;
|
|
874
|
-
}
|
|
875
|
-
return expr;
|
|
876
|
-
}
|
|
877
|
-
|
|
878
856
|
mkValue(node: Enode): number | DependentValue {
|
|
879
857
|
const manager = this.manager;
|
|
880
858
|
const context = this.context;
|
|
@@ -882,8 +860,8 @@ export class TheorySeq extends TheorySeqRegex {
|
|
|
882
860
|
if (!this.isSeq(expr)) return this.mkValueOf(expr);
|
|
883
861
|
const concats: number[] = [];
|
|
884
862
|
const todo = [expr];
|
|
885
|
-
|
|
886
|
-
const current = this.rep.find(this.getIteValue(this.rep.find(
|
|
863
|
+
for (let next = todo.pop(); next !== undefined; next = todo.pop()) {
|
|
864
|
+
const current = this.rep.find(this.getIteValue(this.rep.find(next)));
|
|
887
865
|
if (this.isConcat(current)) todo.push(manager.getArg(current, 1), manager.getArg(current, 0));
|
|
888
866
|
else concats.push(current);
|
|
889
867
|
}
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
// Ported from Z3 (src/smt/smt_theory.h, src/smt/smt_theory.cpp), MIT license, see z3-license.txt.
|
|
2
2
|
import { shrink } from "./array";
|
|
3
|
-
import type
|
|
3
|
+
import { type AstManager, OP_ITE } from "./ast";
|
|
4
4
|
import type { Context } from "./context";
|
|
5
5
|
import type { Enode } from "./enode";
|
|
6
6
|
import { type BoolVar, FALSE_LITERAL, type Literal, negate, TRUE_LITERAL } from "./literal";
|
|
@@ -86,6 +86,21 @@ export abstract class Theory {
|
|
|
86
86
|
return node;
|
|
87
87
|
}
|
|
88
88
|
|
|
89
|
+
protected getIteValue(expr: number) {
|
|
90
|
+
const context = this.context;
|
|
91
|
+
const manager = this.manager;
|
|
92
|
+
let current = expr;
|
|
93
|
+
while (manager.getOp(current) === OP_ITE && context.isEInternalized(current)) {
|
|
94
|
+
const root = context.getEnode(current)?.root;
|
|
95
|
+
const thenExpr = manager.getArg(current, 1);
|
|
96
|
+
const elseExpr = manager.getArg(current, 2);
|
|
97
|
+
if (context.getEnode(thenExpr)?.root === root) current = thenExpr;
|
|
98
|
+
else if (context.getEnode(elseExpr)?.root === root) current = elseExpr;
|
|
99
|
+
else break;
|
|
100
|
+
}
|
|
101
|
+
return current;
|
|
102
|
+
}
|
|
103
|
+
|
|
89
104
|
abstract internalizeAtom(atom: number, isGateContext: boolean): boolean;
|
|
90
105
|
|
|
91
106
|
abstract internalizeTerm(term: number): boolean;
|
|
@@ -47,8 +47,8 @@ const getSharedApps = (manager: AstManager, forms: readonly number[]) => {
|
|
|
47
47
|
return shared;
|
|
48
48
|
};
|
|
49
49
|
|
|
50
|
-
const getOrderedById = (first: number, second: number) =>
|
|
51
|
-
first > second ? [second, first] : [first, second];
|
|
50
|
+
const getOrderedById = (manager: AstManager, first: number, second: number) =>
|
|
51
|
+
manager.ids[first] > manager.ids[second] ? [second, first] : [first, second];
|
|
52
52
|
|
|
53
53
|
const getProductNext = (sizes: readonly number[], iterator: number[]) => {
|
|
54
54
|
for (let index = 0; index < sizes.length; index++) {
|
|
@@ -168,7 +168,7 @@ export const tseitinCnf = (manager: AstManager, goal: Goal) => {
|
|
|
168
168
|
if (!manager.isNot(arg)) return null;
|
|
169
169
|
const inner = manager.getArg(arg, 0);
|
|
170
170
|
if (isShared(inner) || !isOrOf(inner, 2)) return null;
|
|
171
|
-
ors.push(getOrderedById(manager.getArg(inner, 0), manager.getArg(inner, 1)));
|
|
171
|
+
ors.push(getOrderedById(manager, manager.getArg(inner, 0), manager.getArg(inner, 1)));
|
|
172
172
|
}
|
|
173
173
|
const [[a1, a2], [b1, b2], [c1, c2]] = ors;
|
|
174
174
|
if (
|
|
@@ -118,7 +118,7 @@ export const replaceFreeVars = (
|
|
|
118
118
|
...data,
|
|
119
119
|
body: children[0],
|
|
120
120
|
patterns: children.slice(1, 1 + data.patterns.length),
|
|
121
|
-
noPatterns:
|
|
121
|
+
noPatterns: children.slice(1 + data.patterns.length),
|
|
122
122
|
});
|
|
123
123
|
frames.pop();
|
|
124
124
|
cache.set(frame.shift * numNodes + current, result);
|
|
@@ -177,7 +177,7 @@ export class UnusedVarsEliminator {
|
|
|
177
177
|
manager.kinds[expr] === KIND_QUANTIFIER && !manager.isLambda(expr)
|
|
178
178
|
? manager.getQuantifier(expr)
|
|
179
179
|
: null;
|
|
180
|
-
const kept = data === null ? expr : manager.
|
|
180
|
+
const kept = data === null ? expr : manager.isGroundApp(data.body) ? data.body : -1;
|
|
181
181
|
if (kept !== -1 || data === null) {
|
|
182
182
|
manager.incRef(kept);
|
|
183
183
|
return kept;
|
package/src/prover/smt/table.ts
CHANGED
|
@@ -130,7 +130,7 @@ export const TYPED_SYMBOLS = [
|
|
|
130
130
|
"TIntLteq",
|
|
131
131
|
];
|
|
132
132
|
|
|
133
|
-
export type AxiomArgument = number | string | AxiomArgument[];
|
|
133
|
+
export type AxiomArgument = number | bigint | string | AxiomArgument[];
|
|
134
134
|
|
|
135
135
|
export interface Axiom {
|
|
136
136
|
name: string;
|
|
@@ -151,7 +151,8 @@ export const axiom = (
|
|
|
151
151
|
formula,
|
|
152
152
|
});
|
|
153
153
|
|
|
154
|
-
export const getAxiomKey = (entry: Axiom) =>
|
|
154
|
+
export const getAxiomKey = (entry: Axiom) =>
|
|
155
|
+
`${entry.name} ${JSON.stringify(entry.args, (_key, value: unknown) => (typeof value === "bigint" ? `${value}n` : value))}`;
|
|
155
156
|
|
|
156
157
|
const getAxiomRank = (entry: Axiom) => {
|
|
157
158
|
const constant = CONSTANT_AXIOMS.indexOf(entry.name);
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
// Ported from Zenon's main.ml, as shipped in tlapm. Copyright 1997 INRIA, see LICENSE.
|
|
2
2
|
|
|
3
3
|
import { TlaZenonError } from "../../errors";
|
|
4
|
-
import type { DecideOptions } from "../verdict";
|
|
4
|
+
import type { DecideOptions, Decision } from "../verdict";
|
|
5
5
|
import { checkProof } from "./check/check";
|
|
6
6
|
import { createRelations } from "./eqrel";
|
|
7
7
|
import { createExpressions } from "./expr";
|
|
@@ -87,16 +87,14 @@ export const runZenon = (text: string, options: DecideOptions): ZenonRun => {
|
|
|
87
87
|
};
|
|
88
88
|
};
|
|
89
89
|
|
|
90
|
-
|
|
90
|
+
const FAILURE_ERRORS = new Map<ZenonRun["failure"], string>([
|
|
91
|
+
["exhausted", "Zenon error: exhausted search space without finding a proof\n"],
|
|
92
|
+
["memory limit", "Zenon error: could not find a proof within the memory size limit\n"],
|
|
93
|
+
]);
|
|
91
94
|
|
|
92
|
-
const
|
|
93
|
-
exhausted: "Zenon error: exhausted search space without finding a proof\n",
|
|
94
|
-
"memory limit": "Zenon error: could not find a proof within the memory size limit\n",
|
|
95
|
-
};
|
|
96
|
-
|
|
97
|
-
export const decideZenon = (text: string, options: DecideOptions): ZenonDecision => {
|
|
95
|
+
export const decideZenon = (text: string, options: DecideOptions): Omit<Decision, "timeUsedMs"> => {
|
|
98
96
|
const run = runZenon(text, options);
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
97
|
+
return run.isar === undefined
|
|
98
|
+
? { verdict: "unknown", errorOutput: FAILURE_ERRORS.get(run.failure) }
|
|
99
|
+
: { verdict: "unsat", output: run.isar };
|
|
102
100
|
};
|
package/src/prover/zenon/node.ts
CHANGED
|
@@ -158,18 +158,19 @@ const canInstantiate = (meta: Expr, expression: Expr): boolean => {
|
|
|
158
158
|
};
|
|
159
159
|
|
|
160
160
|
// A list cell and a node record take 3 and 6 words, and each block has a header word.
|
|
161
|
-
const getNodeWords = (node: Node) =>
|
|
162
|
-
|
|
163
|
-
(words, branch) => words + 3 * branch.length,
|
|
161
|
+
const getNodeWords = (node: Node) => {
|
|
162
|
+
let words =
|
|
164
163
|
3 +
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
);
|
|
164
|
+
6 +
|
|
165
|
+
3 * node.conclusions.length +
|
|
166
|
+
1 +
|
|
167
|
+
node.rule.args.length +
|
|
168
|
+
(typeof node.priority === "object" ? 2 : 0) +
|
|
169
|
+
1 +
|
|
170
|
+
node.branches.length;
|
|
171
|
+
for (const branch of node.branches) words += 3 * branch.length;
|
|
172
|
+
return words;
|
|
173
|
+
};
|
|
173
174
|
|
|
174
175
|
export const insertNode = (previous: Queue, node: Node): Queue => {
|
|
175
176
|
const queue = { ...previous, nodeWords: previous.nodeWords + getNodeWords(node) };
|
|
@@ -316,7 +316,7 @@ export const getSubsetNodes = (literal: Literal): Item[] | undefined => {
|
|
|
316
316
|
]);
|
|
317
317
|
}
|
|
318
318
|
if (isApp(right, "TLA.cap", 2)) {
|
|
319
|
-
//
|
|
319
|
+
// Deviation from Zenon: ext_tla.ml builds both subsets from the second set, which is unsound.
|
|
320
320
|
const first = exprs.eapp("TLA.subseteq", [left, right.args[0]]);
|
|
321
321
|
const second = exprs.eapp("TLA.subseteq", [left, right.args[1]]);
|
|
322
322
|
return isNegated
|