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.
Files changed (196) hide show
  1. package/dist/deciders.cjs +37 -36
  2. package/dist/deciders.js +55 -54
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +3 -0
  5. package/dist/index.d.ts +3 -0
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove.cjs +146 -58
  10. package/dist/prove.js +142 -54
  11. package/dist/run.cjs +45 -43
  12. package/dist/run.js +47 -45
  13. package/dist/transfer.cjs +39 -36
  14. package/dist/transfer.js +23 -20
  15. package/dist/worker.cjs +1 -1
  16. package/dist/worker.js +1 -1
  17. package/package.json +1 -1
  18. package/src/ast.ts +3 -3
  19. package/src/check.ts +203 -33
  20. package/src/cli/tlapm.ts +261 -68
  21. package/src/dependencies.ts +23 -2
  22. package/src/errors.ts +1 -1
  23. package/src/exit-codes.ts +1 -0
  24. package/src/liveness-checker.ts +530 -201
  25. package/src/liveness.ts +47 -32
  26. package/src/obligations/anonymize.ts +2 -4
  27. package/src/obligations/index.ts +5 -3
  28. package/src/obligations/pragma.ts +2 -2
  29. package/src/parallel.ts +2 -2
  30. package/src/parser.ts +151 -42
  31. package/src/prover/deciders.ts +1 -8
  32. package/src/prover/isabelle/isar/attrib.ts +86 -45
  33. package/src/prover/isabelle/isar/context.ts +25 -22
  34. package/src/prover/isabelle/isar/induct.ts +2 -5
  35. package/src/prover/isabelle/isar/method.ts +5 -7
  36. package/src/prover/isabelle/isar/proof.ts +33 -16
  37. package/src/prover/isabelle/isar/rule-cases.ts +6 -14
  38. package/src/prover/isabelle/isar/theory.ts +16 -17
  39. package/src/prover/isabelle/isar/toplevel.ts +46 -52
  40. package/src/prover/isabelle/provers/classical.ts +1 -1
  41. package/src/prover/ocaml.ts +4 -1
  42. package/src/prover/prep/action.ts +1 -0
  43. package/src/prover/prep/methods.ts +50 -3
  44. package/src/prover/prep/normalize.ts +4 -1
  45. package/src/prover/prove.ts +58 -32
  46. package/src/prover/ptl/decide.ts +43 -63
  47. package/src/prover/smt/data.ts +51 -45
  48. package/src/prover/smt/encode.ts +1 -2
  49. package/src/prover/smt/rewrite.ts +1 -0
  50. package/src/prover/smt/solver/aig-tactic.ts +25 -15
  51. package/src/prover/smt/solver/arith-rewriter.ts +3 -5
  52. package/src/prover/smt/solver/asserted-formulas.ts +1 -1
  53. package/src/prover/smt/solver/ast-util.ts +3 -1
  54. package/src/prover/smt/solver/ast.ts +110 -152
  55. package/src/prover/smt/solver/bound-manager.ts +39 -28
  56. package/src/prover/smt/solver/bv-bound-chk.ts +2 -8
  57. package/src/prover/smt/solver/bv-rewriter.ts +14 -16
  58. package/src/prover/smt/solver/bv1-blast.ts +1 -9
  59. package/src/prover/smt/solver/cg-table.ts +19 -14
  60. package/src/prover/smt/solver/check-logic.ts +6 -1
  61. package/src/prover/smt/solver/context.ts +20 -10
  62. package/src/prover/smt/solver/demodulator.ts +2 -2
  63. package/src/prover/smt/solver/dependent-expr-state.ts +16 -0
  64. package/src/prover/smt/solver/distribute-forall.ts +1 -10
  65. package/src/prover/smt/solver/dom-simplify.ts +1 -1
  66. package/src/prover/smt/solver/dt2bv-tactic.ts +2 -7
  67. package/src/prover/smt/solver/e-matching.ts +6 -6
  68. package/src/prover/smt/solver/elim-uncnstr.ts +3 -14
  69. package/src/prover/smt/solver/enode.ts +15 -1
  70. package/src/prover/smt/solver/euf/array-internalize.ts +19 -8
  71. package/src/prover/smt/solver/euf/dt-solver.ts +19 -19
  72. package/src/prover/smt/solver/euf/egraph.ts +65 -32
  73. package/src/prover/smt/solver/euf/euf-solver.ts +35 -18
  74. package/src/prover/smt/solver/euf/fpa-solver.ts +37 -51
  75. package/src/prover/smt/solver/euf/mam.ts +6 -48
  76. package/src/prover/smt/solver/euf/q-ematch.ts +21 -94
  77. package/src/prover/smt/solver/euf/q-mbi.ts +4 -2
  78. package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -1
  79. package/src/prover/smt/solver/euf/q-solver.ts +2 -0
  80. package/src/prover/smt/solver/euf/th-solver.ts +1 -1
  81. package/src/prover/smt/solver/factor.ts +1 -11
  82. package/src/prover/smt/solver/fd-solver.ts +1 -2
  83. package/src/prover/smt/solver/fm-tactic.ts +19 -13
  84. package/src/prover/smt/solver/fpa-rewriter.ts +3 -1
  85. package/src/prover/smt/solver/fpa2bv-converter.ts +10 -6
  86. package/src/prover/smt/solver/internalizer.ts +41 -2
  87. package/src/prover/smt/solver/lia2pb.ts +18 -4
  88. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  89. package/src/prover/smt/solver/lp/nla-powers.ts +144 -107
  90. package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -17
  91. package/src/prover/smt/solver/macro-finder.ts +1 -1
  92. package/src/prover/smt/solver/mam-compiler.ts +13 -13
  93. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -11
  94. package/src/prover/smt/solver/maxcore.ts +4 -12
  95. package/src/prover/smt/solver/maxlex.ts +0 -7
  96. package/src/prover/smt/solver/maxsmt-base.ts +7 -0
  97. package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -11
  98. package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -0
  99. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -9
  100. package/src/prover/smt/solver/model-evaluator.ts +9 -5
  101. package/src/prover/smt/solver/model-macro-solver.ts +3 -3
  102. package/src/prover/smt/solver/muz/dl-context.ts +57 -3
  103. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -20
  104. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -1
  105. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -10
  106. package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -13
  107. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -2
  108. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -2
  109. package/src/prover/smt/solver/muz/dl-rule.ts +93 -29
  110. package/src/prover/smt/solver/muz/hnf.ts +6 -5
  111. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +178 -0
  112. package/src/prover/smt/solver/muz/horn-tactic.ts +14 -3
  113. package/src/prover/smt/solver/muz/rule-properties.ts +194 -36
  114. package/src/prover/smt/solver/muz/spacer-context.ts +102 -84
  115. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -2
  116. package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -3
  117. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +2 -7
  118. package/src/prover/smt/solver/muz/spacer-util.ts +2 -2
  119. package/src/prover/smt/solver/muz/substitution.ts +88 -37
  120. package/src/prover/smt/solver/nlqsat.ts +2 -2
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +1 -2
  122. package/src/prover/smt/solver/nlsat/explain.ts +5 -0
  123. package/src/prover/smt/solver/nlsat/solver.ts +36 -25
  124. package/src/prover/smt/solver/opt-context.ts +9 -8
  125. package/src/prover/smt/solver/opt-nlsat.ts +68 -58
  126. package/src/prover/smt/solver/opt-solver.ts +16 -7
  127. package/src/prover/smt/solver/optsmt.ts +12 -9
  128. package/src/prover/smt/solver/pattern-inference.ts +2 -2
  129. package/src/prover/smt/solver/pb-rewriter.ts +13 -13
  130. package/src/prover/smt/solver/poly-rewriter.ts +2 -2
  131. package/src/prover/smt/solver/probes.ts +1 -1
  132. package/src/prover/smt/solver/propagate-values.ts +4 -0
  133. package/src/prover/smt/solver/proto-model.ts +5 -5
  134. package/src/prover/smt/solver/purify-arith.ts +50 -15
  135. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -1
  136. package/src/prover/smt/solver/qe-mbp.ts +13 -23
  137. package/src/prover/smt/solver/qe.ts +45 -53
  138. package/src/prover/smt/solver/qsat.ts +70 -90
  139. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -9
  140. package/src/prover/smt/solver/quasi-macros.ts +9 -18
  141. package/src/prover/smt/solver/rational.ts +17 -0
  142. package/src/prover/smt/solver/recfun-decl-plugin.ts +33 -19
  143. package/src/prover/smt/solver/recfun-rewriter.ts +1 -1
  144. package/src/prover/smt/solver/rewriter-tpl.ts +6 -2
  145. package/src/prover/smt/solver/rewriter.ts +1 -1
  146. package/src/prover/smt/solver/sat/asymm-branch.ts +59 -46
  147. package/src/prover/smt/solver/sat/clause-use-list.ts +0 -6
  148. package/src/prover/smt/solver/sat/clause.ts +1 -3
  149. package/src/prover/smt/solver/sat/config.ts +3 -3
  150. package/src/prover/smt/solver/sat/consequences.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +1 -1
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -12
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -15
  154. package/src/prover/smt/solver/sat/pb-solver.ts +49 -23
  155. package/src/prover/smt/solver/sat/probing.ts +22 -19
  156. package/src/prover/smt/solver/sat/sat2goal.ts +9 -10
  157. package/src/prover/smt/solver/sat/simplifier.ts +15 -56
  158. package/src/prover/smt/solver/sat/solver.ts +20 -19
  159. package/src/prover/smt/solver/sat/watch-list.ts +7 -0
  160. package/src/prover/smt/solver/seq-decl-plugin.ts +7 -7
  161. package/src/prover/smt/solver/seq-derive.ts +6 -7
  162. package/src/prover/smt/solver/seq-eq-solver.ts +7 -7
  163. package/src/prover/smt/solver/seq-range-predicate.ts +14 -1
  164. package/src/prover/smt/solver/seq-re-rewriter.ts +1 -10
  165. package/src/prover/smt/solver/seq-re-util.ts +1 -2
  166. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-live.ts +4 -4
  168. package/src/prover/smt/solver/seq-rewriter.ts +1 -4
  169. package/src/prover/smt/solver/smt-setup.ts +15 -9
  170. package/src/prover/smt/solver/smtlib-parser.ts +1174 -579
  171. package/src/prover/smt/solver/smtlib-script.ts +866 -728
  172. package/src/prover/smt/solver/tactic.ts +66 -14
  173. package/src/prover/smt/solver/theory-array.ts +25 -58
  174. package/src/prover/smt/solver/theory-bv.ts +13 -50
  175. package/src/prover/smt/solver/theory-fpa.ts +46 -78
  176. package/src/prover/smt/solver/theory-pb.ts +10 -6
  177. package/src/prover/smt/solver/theory-recfun.ts +2 -2
  178. package/src/prover/smt/solver/theory-seq-regex.ts +3 -6
  179. package/src/prover/smt/solver/theory-seq-solve.ts +5 -5
  180. package/src/prover/smt/solver/theory-seq-state.ts +6 -3
  181. package/src/prover/smt/solver/theory-seq.ts +32 -54
  182. package/src/prover/smt/solver/theory.ts +16 -1
  183. package/src/prover/smt/solver/tseitin-cnf.ts +3 -3
  184. package/src/prover/smt/solver/var-subst.ts +2 -2
  185. package/src/prover/smt/table.ts +3 -2
  186. package/src/prover/zenon/decide.ts +9 -11
  187. package/src/prover/zenon/node.ts +12 -11
  188. package/src/prover/zenon/tla/sets.ts +1 -1
  189. package/src/search.ts +131 -16
  190. package/src/successors.ts +1 -1
  191. package/src/symmetry.ts +2 -2
  192. package/src/tableau.ts +2 -2
  193. package/src/tlc/fingerprint.ts +81 -9
  194. package/src/tlc/summary.ts +29 -14
  195. package/src/typed-tier.ts +6535 -0
  196. package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
@@ -11,7 +11,6 @@ import {
11
11
  OP_LE,
12
12
  OP_MOD,
13
13
  OP_MUL,
14
- OP_NUM,
15
14
  OP_SUB,
16
15
  OP_UMINUS,
17
16
  SORT_BOOL,
@@ -20,6 +19,7 @@ import {
20
19
  } from "../ast";
21
20
  import { isAppOf, mkNot } from "../ast-util";
22
21
  import { Rational } from "../rational";
22
+ import { getBinaryArgs, getNumeral } from "./mbp-plugin";
23
23
 
24
24
  export interface SolvePlugin {
25
25
  readonly family: number;
@@ -33,14 +33,6 @@ interface SignedExpr {
33
33
  expr: number;
34
34
  }
35
35
 
36
- const getBinaryArgs = (manager: AstManager, expr: number, op: number) =>
37
- isAppOf(manager, expr, op) && manager.getNumArgs(expr) === 2
38
- ? [manager.getArg(expr, 0), manager.getArg(expr, 1)]
39
- : undefined;
40
-
41
- const getNumeral = (manager: AstManager, expr: number) =>
42
- isAppOf(manager, expr, OP_NUM) ? manager.getRationalValue(expr) : undefined;
43
-
44
36
  const isZero = (manager: AstManager, expr: number) => getNumeral(manager, expr)?.isZero() === true;
45
37
 
46
38
  export const mkArithSolvePlugin = (
@@ -32,6 +32,7 @@ import {
32
32
  SORT_BOOL,
33
33
  } from "./ast";
34
34
  import type { AstManager } from "./ast";
35
+ import { DEFAULT_BV_OPTIONS } from "./bv-rewriter";
35
36
  import { isConsideredUninterpreted } from "./fpa-decl-plugin";
36
37
  import { FuncInterp, getManagerSomeValue } from "./proto-model";
37
38
  import type { ProtoModel } from "./proto-model";
@@ -61,7 +62,10 @@ export class ModelEvaluator extends RewriterTpl {
61
62
  private model: ProtoModel,
62
63
  ) {
63
64
  super(manager);
64
- this.rewriter = new Rewriter(manager, TACTIC_REWRITER_OPTIONS);
65
+ this.rewriter = new Rewriter(manager, {
66
+ ...TACTIC_REWRITER_OPTIONS,
67
+ bv: { ...DEFAULT_BV_OPTIONS, isHiDiv0: manager.isHiDiv0, isMkbv2num: true },
68
+ });
65
69
  this.rewriter.releaseResult = () => this.setLastResult(-1);
66
70
  }
67
71
 
@@ -124,7 +128,7 @@ export class ModelEvaluator extends RewriterTpl {
124
128
  if (interp === undefined) return -1;
125
129
  if (interp.isPartial()) interp.setElse(model.getSomeValue(sort));
126
130
  const result = this.substitute(interp.getInterp() as number, args);
127
- return manager.isGround(result) ? { expr: result, depth: Infinity } : result;
131
+ return manager.isGroundApp(result) ? { expr: result, depth: Infinity } : result;
128
132
  }
129
133
  const rewritten = this.rewriter.reduceAppCore(decl, args);
130
134
  const reduced =
@@ -192,7 +196,7 @@ export class ModelEvaluator extends RewriterTpl {
192
196
  model.registerFunc(decl, created);
193
197
  return value;
194
198
  }
195
- if (!manager.isGround(args[0])) return manager.mkApp(decl, args, sort);
199
+ if (!manager.isGroundApp(args[0])) return manager.mkApp(decl, args, sort);
196
200
  }
197
201
  if (op === OP_DT_CONSTRUCTOR) return manager.mkApp(decl, args, sort);
198
202
  if (interp === undefined) return -1;
@@ -221,11 +225,11 @@ export class ModelEvaluator extends RewriterTpl {
221
225
  );
222
226
  const elseExpr = interp?.elseExpr ?? null;
223
227
  if (interp === undefined || elseExpr === null) return undefined;
224
- let isGround = manager.isGround(elseExpr);
228
+ let isGround = manager.isGroundApp(elseExpr);
225
229
  for (const entry of interp.entries) {
226
230
  if (entry.result === elseExpr) continue;
227
231
  const store = [...entry.args, entry.result];
228
- isGround &&= store.every((arg) => manager.isGround(arg));
232
+ isGround &&= store.every((arg) => manager.isGroundApp(arg));
229
233
  stores.push(store);
230
234
  }
231
235
  return isGround ? { stores, elseExpr, areUnique } : undefined;
@@ -117,7 +117,7 @@ const getHintHeadVars = (manager: AstManager, expr: number) => {
117
117
  const isVarsOfSubset = (manager: AstManager, expr: number, vars: number[]) => {
118
118
  const visited = new Set<number>();
119
119
  const visit = (current: number): boolean => {
120
- if (manager.isGround(current) || visited.has(current)) return true;
120
+ if (manager.isGroundApp(current) || visited.has(current)) return true;
121
121
  visited.add(current);
122
122
  const kind = manager.kinds[current];
123
123
  if (kind === KIND_VAR) return vars.includes(current);
@@ -555,7 +555,7 @@ const collectNgFuncDecls = (manager: AstManager, expr: number) => {
555
555
  visit(manager.getArg(current, index));
556
556
  if (
557
557
  manager.getNumArgs(current) > 0 &&
558
- !manager.isGround(current) &&
558
+ !manager.isGroundApp(current) &&
559
559
  isUserApp(manager, current)
560
560
  )
561
561
  decls.add(manager.decls[current]);
@@ -592,7 +592,7 @@ const nonAufMacroSolver = (manager: AstManager, model: ProtoModel, getInfo: GetI
592
592
  const isBetterMacro = (first: CondMacro, second: CondMacro | null) => {
593
593
  if (second === null || !first.isHint) return true;
594
594
  if (!second.isHint) return false;
595
- return manager.isGround(first.def) && !manager.isGround(second.def);
595
+ return manager.isGroundApp(first.def) && !manager.isGroundApp(second.def);
596
596
  };
597
597
  const getMacroFor = (decl: number, quantifier: number) => {
598
598
  let result: CondMacro | null = null;
@@ -11,6 +11,9 @@ import {
11
11
  SORT_BOOL,
12
12
  SORT_SIZE_INFINITE,
13
13
  } from "../ast";
14
+ import type { Definition } from "../goal";
15
+ import { ModelEvaluator } from "../model-evaluator";
16
+ import { FuncInterp, type ProtoModel } from "../proto-model";
14
17
  import { type RewriterOptions, Rewriter } from "../rewriter";
15
18
  import { RefVector } from "../ref-vector";
16
19
  import { applyQeLiteToConjuncts } from "../qe-lite";
@@ -56,8 +59,45 @@ export class FpParams {
56
59
  }
57
60
  }
58
61
 
62
+ export type ModelConverter = (model: ProtoModel) => ProtoModel;
63
+
64
+ // generic_model_converter::operator() over predicates, where a definition of -1 hides the
65
+ // declaration.
66
+ const applyDefinitions = (definitions: readonly Definition[], model: ProtoModel) => {
67
+ const manager = model.manager;
68
+ let evaluator = new ModelEvaluator(manager, model);
69
+ evaluator.setModelCompletion(true);
70
+ for (let index = definitions.length - 1; index >= 0; index--) {
71
+ const definition = definitions[index];
72
+ if (definition.def === -1) {
73
+ model.unregisterDecl(definition.decl);
74
+ continue;
75
+ }
76
+ const value = evaluator.rewrite(definition.def);
77
+ const arity = manager.funcDecls[definition.decl].domain.length;
78
+ const oldInterp = model.funcInterps.get(definition.decl);
79
+ const old = arity === 0 ? model.constInterps.get(definition.decl) : oldInterp?.elseExpr;
80
+ if (old !== value) {
81
+ if (arity === 0) model.registerConst(definition.decl, value);
82
+ else {
83
+ const interp = new FuncInterp(manager, arity);
84
+ interp.setElse(value);
85
+ model.registerFunc(definition.decl, interp);
86
+ }
87
+ }
88
+ manager.decRef(value);
89
+ if (old === value || (arity === 0 ? old === undefined : oldInterp === undefined)) continue;
90
+ evaluator.release();
91
+ evaluator = new ModelEvaluator(manager, model);
92
+ evaluator.setModelCompletion(true);
93
+ }
94
+ evaluator.release();
95
+ return model;
96
+ };
97
+
59
98
  export interface Engine {
60
99
  query(query: number): number;
100
+ getModel(): ProtoModel;
61
101
  }
62
102
 
63
103
  type EngineFactory = (context: DatalogContext, engine: number) => Engine;
@@ -77,12 +117,13 @@ export class DatalogContext {
77
117
  private engineType = ENGINE_LAST;
78
118
  private engine: Engine | undefined;
79
119
  readonly rewriter: Rewriter;
80
- hasModelConverter = false;
120
+ // m_mc: the converters since the last query, or undefined before one.
121
+ modelConverters: ModelConverter[] | undefined;
81
122
 
82
123
  constructor(
83
124
  readonly manager: AstManager,
84
125
  readonly params: FpParams,
85
- rewriterOptions: RewriterOptions,
126
+ readonly rewriterOptions: RewriterOptions,
86
127
  private engineFactory: EngineFactory,
87
128
  ) {
88
129
  this.ruleManager = new RuleManager(manager, this);
@@ -288,12 +329,25 @@ export class DatalogContext {
288
329
  }
289
330
 
290
331
  query(query: number) {
291
- this.hasModelConverter = true;
332
+ this.modelConverters = [];
292
333
  this.getEngine(query);
293
334
  this.flushAddRules();
294
335
  return this.ensureEngine(query).query(query);
295
336
  }
296
337
 
338
+ addGenericModelConverter(definitions: readonly Definition[]) {
339
+ if (this.modelConverters === undefined) return;
340
+ for (const definition of definitions) {
341
+ this.manager.incDeclRef(definition.decl);
342
+ if (definition.def !== -1) this.manager.incRef(definition.def);
343
+ }
344
+ this.modelConverters.push((model) => applyDefinitions(definitions, model));
345
+ }
346
+
347
+ getModel() {
348
+ return this.ensureEngine().getModel();
349
+ }
350
+
297
351
  // engine_base::query over one relation.
298
352
  relQuery(relation: number) {
299
353
  const manager = this.manager;
@@ -1,6 +1,9 @@
1
1
  // Ported from Z3 (src/muz/transforms/dl_mk_coi_filter.cpp, src/muz/dataflow/dataflow.h,
2
2
  // src/muz/dataflow/reachability.h), MIT license, see z3-license.txt.
3
+ import { ObjHashtable, ObjMap } from "../hashtable";
3
4
  import type { DatalogContext } from "./dl-context";
5
+ import type { Rule } from "./dl-rule";
6
+ import { HornSubsumeModelConverter } from "./horn-subsume-model-converter";
4
7
  import { RuleSet } from "./dl-rule-set";
5
8
  import type { RuleTransformerPlugin } from "./dl-rule-transformer";
6
9
 
@@ -15,30 +18,50 @@ export class MkCoiFilter implements RuleTransformerPlugin {
15
18
  return this.bottomUp(topDown ?? source) ?? topDown;
16
19
  }
17
20
 
18
- // The predicates whose rules can derive a fact: a rule fires once its positive predicates can.
19
- private getBottomUpReachable(source: RuleSet) {
21
+ // dataflow_engine<reachability_info>::run_bottom_up: whether the rules of a predicate can
22
+ // derive a fact, for the predicates the engine reached.
23
+ private runBottomUp(source: RuleSet) {
20
24
  const manager = this.context.manager;
21
- const reachable = new Set<number>();
22
- let isChanged = true;
23
- while (isChanged) {
24
- isChanged = false;
25
- for (const rule of source.rules) {
26
- const head = rule.getDecl(manager);
27
- if (reachable.has(head)) continue;
28
- let isFiring = true;
29
- for (let index = 0; isFiring && index < rule.positiveSize; index++)
30
- isFiring = reachable.has(rule.getTailDecl(manager, index));
31
- if (!isFiring) continue;
32
- reachable.add(head);
33
- isChanged = true;
25
+ const getHash = (decl: number) => manager.getDeclHash(decl);
26
+ const facts = new ObjMap<boolean>(getHash);
27
+ const body2rules = new Map<number, Rule[]>();
28
+ const todos = [new ObjHashtable(getHash), new ObjHashtable(getHash)];
29
+ let todoIndex = 0;
30
+ for (const rule of source.rules) {
31
+ for (let index = 0; index < rule.uninterpretedSize; index++) {
32
+ const decl = rule.getTailDecl(manager, index);
33
+ const users = body2rules.get(decl);
34
+ if (users === undefined) body2rules.set(decl, [rule]);
35
+ else users.push(rule);
34
36
  }
37
+ const head = rule.getDecl(manager);
38
+ if (rule.positiveSize !== 0 || facts.get(head) === true) continue;
39
+ facts.set(head, true);
40
+ todos[todoIndex].add(head);
35
41
  }
36
- return reachable;
42
+ while (todos[todoIndex].size > 0) {
43
+ for (const decl of todos[todoIndex])
44
+ for (const rule of body2rules.get(decl) ?? []) {
45
+ const head = rule.getDecl(manager);
46
+ if (!facts.has(head)) facts.set(head, false);
47
+ if (facts.get(head) === true) continue;
48
+ let isFiring = true;
49
+ for (let index = 0; isFiring && index < rule.positiveSize; index++)
50
+ isFiring = facts.get(rule.getTailDecl(manager, index)) === true;
51
+ if (!isFiring) continue;
52
+ facts.set(head, true);
53
+ todos[1 - todoIndex].add(head);
54
+ }
55
+ todos[todoIndex] = new ObjHashtable(getHash);
56
+ todoIndex = 1 - todoIndex;
57
+ }
58
+ return facts;
37
59
  }
38
60
 
39
61
  private bottomUp(source: RuleSet) {
40
62
  const manager = this.context.manager;
41
- const reachable = this.getBottomUpReachable(source);
63
+ const facts = this.runBottomUp(source);
64
+ const unreachable = new ObjHashtable((decl) => manager.getDeclHash(decl));
42
65
  const result = new RuleSet(this.context);
43
66
  result.inheritPredicates(source);
44
67
  for (const rule of source.rules) {
@@ -46,7 +69,8 @@ export class MkCoiFilter implements RuleTransformerPlugin {
46
69
  let newTail: number[] | undefined;
47
70
  let newNegated: boolean[] = [];
48
71
  for (let index = 0; index < rule.uninterpretedSize; index++) {
49
- const isReachable = reachable.has(rule.getTailDecl(manager, index));
72
+ const isReachable = facts.get(rule.getTailDecl(manager, index)) === true;
73
+ if (!isReachable) unreachable.add(rule.getTailDecl(manager, index));
50
74
  if (rule.isNegated[index]) {
51
75
  if (!isReachable && newTail === undefined) {
52
76
  newTail = rule.tail.slice(0, index);
@@ -73,6 +97,12 @@ export class MkCoiFilter implements RuleTransformerPlugin {
73
97
  }
74
98
  if (result.rules.length === source.rules.length) return undefined;
75
99
  result.close();
100
+ if (this.context.modelConverters !== undefined) {
101
+ for (const [decl, isReachable] of facts) if (!isReachable) unreachable.add(decl);
102
+ this.context.addGenericModelConverter(
103
+ [...unreachable].map((decl) => ({ decl, def: manager.falseExpr })),
104
+ );
105
+ }
76
106
  return result;
77
107
  }
78
108
 
@@ -103,6 +133,7 @@ export class MkCoiFilter implements RuleTransformerPlugin {
103
133
  const result = new RuleSet(this.context);
104
134
  result.inheritPredicates(source);
105
135
  const seen = new Set<number>();
136
+ const prunedPreds = new ObjHashtable((decl) => manager.getDeclHash(decl));
106
137
  for (const rule of source.rules) {
107
138
  const predicate = rule.getDecl(manager);
108
139
  if (seen.has(predicate)) continue;
@@ -111,11 +142,28 @@ export class MkCoiFilter implements RuleTransformerPlugin {
111
142
  for (const kept of source.getPredicateRules(predicate)) result.addRule(kept);
112
143
  continue;
113
144
  }
114
- if (!this.context.hasModelConverter) continue;
145
+ if (this.context.modelConverters === undefined) continue;
115
146
  for (const pruned of source.getPredicateRules(predicate))
116
147
  for (let index = 0; index < pruned.uninterpretedSize; index++)
117
148
  if (pruned.getTailDecl(manager, index) !== predicate) return undefined;
149
+ prunedPreds.add(predicate);
118
150
  }
119
- return result.rules.length === source.rules.length ? undefined : result;
151
+ if (result.rules.length === source.rules.length) return undefined;
152
+ if (this.context.modelConverters !== undefined && prunedPreds.size > 0) {
153
+ const horn = new HornSubsumeModelConverter(this.context);
154
+ this.context.addGenericModelConverter(
155
+ [...prunedPreds].map((decl) => ({
156
+ decl,
157
+ def: manager.mkOr(
158
+ source
159
+ .getPredicateRules(decl)
160
+ .map((rule) =>
161
+ horn.mkHorn(rule.head, manager.mkAnd(rule.tail.slice(rule.uninterpretedSize))),
162
+ ),
163
+ ),
164
+ })),
165
+ );
166
+ }
167
+ return result;
120
168
  }
121
169
  }
@@ -24,7 +24,13 @@ class BlastTermIte extends RewriterTpl {
24
24
  reduceApp(decl: number, args: number[], sort: number): number | Rewrite {
25
25
  const manager = this.manager;
26
26
  if (decl === OP_ITE) return -1;
27
- if (this.initTermSize > 0 && this.maxInflation * this.initTermSize < this.numFresh) return -1;
27
+ // The product wraps as Z3's unsigned one does.
28
+ if (
29
+ this.maxInflation < 0xffffffff &&
30
+ this.initTermSize > 0 &&
31
+ Math.imul(this.maxInflation, this.initTermSize) >>> 0 < this.numFresh
32
+ )
33
+ return -1;
28
34
  for (let index = 0; index < args.length; index++) {
29
35
  const arg = args[index];
30
36
  if (manager.sorts[arg] === SORT_BOOL || manager.getOp(arg) !== OP_ITE) continue;
@@ -1,10 +1,12 @@
1
1
  // Ported from Z3 (src/muz/transforms/dl_mk_rule_inliner.cpp), MIT license, see z3-license.txt.
2
2
  import { SmtUnsupportedError } from "../../../../errors";
3
+ import { L_FALSE, L_UNDEF } from "../lbool";
3
4
  import type { DatalogContext } from "./dl-context";
4
5
  import { MkInterpTailSimplifier } from "./dl-mk-interp-tail-simplifier";
5
6
  import { getRuleVars, type Rule } from "./dl-rule";
6
7
  import { RuleSet } from "./dl-rule-set";
7
8
  import { removeDuplicateTails, type RuleTransformerPlugin } from "./dl-rule-transformer";
9
+ import { HornSubsumeModelConverter } from "./horn-subsume-model-converter";
8
10
  import { Substitution } from "./substitution";
9
11
 
10
12
  class RuleUnifier {
@@ -50,7 +52,7 @@ class RuleUnifier {
50
52
  this.subst.apply(target.head, 0, this.deltas),
51
53
  tail,
52
54
  isNegated,
53
- `${target.name};${source.name}`,
55
+ `${target.getNameText()};${source.getNameText()}`,
54
56
  ),
55
57
  true,
56
58
  );
@@ -58,9 +60,6 @@ class RuleUnifier {
58
60
  }
59
61
  }
60
62
 
61
- const hasQuantifier = (context: DatalogContext, rule: Rule) =>
62
- context.ruleManager.hasQuantifiers(rule);
63
-
64
63
  // The rules at a position of a head or tail, and which of them can still be expanded or removed.
65
64
  class Visitor {
66
65
  readonly positions = new Map<number, number[]>();
@@ -98,6 +97,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
98
97
  private tailVisitor = new Visitor();
99
98
  // Z3 throws has_new_quantifier when it would inline a rule that has a quantifier.
100
99
  private hasNewQuantifier = false;
100
+ private modelConverter: HornSubsumeModelConverter | undefined;
101
101
 
102
102
  constructor(
103
103
  private context: DatalogContext,
@@ -109,7 +109,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
109
109
 
110
110
  private tryToInlineRule(target: Rule, source: Rule, tailIndex: number): Rule | undefined {
111
111
  this.context.ruleManager.normVars(target);
112
- if (hasQuantifier(this.context, source)) {
112
+ if (this.context.ruleManager.hasQuantifiers(source)) {
113
113
  this.hasNewQuantifier = true;
114
114
  return undefined;
115
115
  }
@@ -213,10 +213,18 @@ export class MkRuleInliner implements RuleTransformerPlugin {
213
213
  if (this.forbidMultipleMultipliers(source, candidates))
214
214
  candidates = this.createAllowedRuleSet(source);
215
215
  for (const stratum of candidates.getStrats())
216
- for (const rule of candidates.getPredicateRules(stratum.values().next().value as number))
216
+ for (const rule of candidates.getPredicateRules(stratum.values().next().value as number)) {
217
217
  this.transformRule(source, rule, this.inlinedRules);
218
+ // Z3 does not catch the has_new_quantifier that plan_inlining throws, and aborts.
219
+ if (this.hasNewQuantifier)
220
+ throw new SmtUnsupportedError("inlining a rule with a quantifier");
221
+ }
222
+ for (const rule of this.inlinedRules.rules) this.modelConverter?.delRule(rule, L_UNDEF);
218
223
  }
219
224
 
225
+ // Deviation from Z3: transform_rule keeps a rule that has a quantifier without inlining the rest
226
+ // of its tail, although the rules of those predicates are dropped, so Z3 answers unreachable for
227
+ // a reachable query (dl_mk_rule_inliner.cpp). The rest of the tail is inlined here.
220
228
  private transformRule(source: RuleSet, original: Rule, target: RuleSet) {
221
229
  const manager = this.context.manager;
222
230
  let isModified = false;
@@ -239,6 +247,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
239
247
  if (result !== undefined) todo.push(result);
240
248
  }
241
249
  }
250
+ if (isModified) this.modelConverter?.delRule(original, L_UNDEF);
242
251
  return isModified;
243
252
  }
244
253
 
@@ -253,6 +262,10 @@ export class MkRuleInliner implements RuleTransformerPlugin {
253
262
  isDone = true;
254
263
  if (this.hasNewQuantifier) break;
255
264
  }
265
+ if (isDone)
266
+ for (const rule of source.rules)
267
+ if (this.isInliningAllowed(source, rule.getDecl(manager)))
268
+ this.modelConverter?.delRule(rule, L_UNDEF);
256
269
  return isDone;
257
270
  }
258
271
 
@@ -297,9 +310,15 @@ export class MkRuleInliner implements RuleTransformerPlugin {
297
310
  candidate = predicateRule;
298
311
  }
299
312
  if (isAmbiguous) continue;
300
- if (candidate === undefined) return null;
313
+ if (candidate === undefined) {
314
+ this.modelConverter?.delRule(rule, L_FALSE);
315
+ return null;
316
+ }
301
317
  if (!this.isOrientedRewriter(candidate, rules)) continue;
302
- return this.tryToInlineRule(rule, candidate, index) ?? null;
318
+ const inlined = this.tryToInlineRule(rule, candidate, index);
319
+ if (inlined !== undefined) return inlined;
320
+ this.modelConverter?.delRule(rule, L_FALSE);
321
+ return null;
303
322
  }
304
323
  return undefined;
305
324
  }
@@ -384,6 +403,7 @@ export class MkRuleInliner implements RuleTransformerPlugin {
384
403
  canExpand[index] = canExpand[other];
385
404
  if (tailUnifiers.length === 1) {
386
405
  isValid[other] = false;
406
+ this.modelConverter?.delRule(otherRule, L_UNDEF);
387
407
  this.delRule(otherRule, other);
388
408
  }
389
409
  }
@@ -397,8 +417,14 @@ export class MkRuleInliner implements RuleTransformerPlugin {
397
417
 
398
418
  apply(source: RuleSet) {
399
419
  if (source.rules.length === 0) return undefined;
400
- if (source.rules.some((rule) => hasQuantifier(this.context, rule))) return undefined;
420
+ if (source.rules.some((rule) => this.context.ruleManager.hasQuantifiers(rule)))
421
+ return undefined;
401
422
  this.hasNewQuantifier = false;
423
+ this.modelConverter =
424
+ this.context.modelConverters === undefined
425
+ ? undefined
426
+ : new HornSubsumeModelConverter(this.context);
427
+ const converter = this.modelConverter;
402
428
  let isDone = false;
403
429
  let result = new RuleSet(this.context);
404
430
  if (this.context.params.getBool("xform.inline_eager", true)) {
@@ -422,6 +448,9 @@ export class MkRuleInliner implements RuleTransformerPlugin {
422
448
  }
423
449
  }
424
450
  if (this.hasNewQuantifier) throw new SmtUnsupportedError("inlining a rule with a quantifier");
425
- return isDone ? result : undefined;
451
+ if (!isDone) return undefined;
452
+ if (converter !== undefined)
453
+ this.context.modelConverters?.push((model) => converter.apply(model));
454
+ return result;
426
455
  }
427
456
  }
@@ -1,8 +1,10 @@
1
1
  // Ported from Z3 (src/muz/transforms/dl_mk_slice.cpp), MIT license, see z3-license.txt.
2
2
  import { getSymbolName, KIND_VAR, OP_EQ, OP_ITE, SORT_BOOL } from "../ast";
3
3
  import { flattenAndVector } from "../ast-util";
4
+ import { ObjMap } from "../hashtable";
5
+ import { FuncInterp, ProtoModel } from "../proto-model";
4
6
  import { RefVector } from "../ref-vector";
5
- import { getFreeVarSorts } from "../var-subst";
7
+ import { getFreeVarSorts, VarSubst } from "../var-subst";
6
8
  import type { DatalogContext } from "./dl-context";
7
9
  import type { Rule } from "./dl-rule";
8
10
  import { RuleSet } from "./dl-rule-set";
@@ -10,14 +12,19 @@ import type { RuleTransformerPlugin } from "./dl-rule-transformer";
10
12
 
11
13
  export class MkSlice implements RuleTransformerPlugin {
12
14
  readonly priority = 1;
13
- private sliceable = new Map<number, boolean[]>();
15
+ private sliceable: ObjMap<boolean[]>;
14
16
  private input: boolean[] = [];
15
17
  private output: boolean[] = [];
16
18
  private isVarSliceable: boolean[] = [];
17
19
  private solvedVars: number[] = [];
18
20
  readonly predicates = new Map<number, number>();
21
+ // slice_model_converter::m_slice2old
22
+ private slice2old: ObjMap<number>;
19
23
 
20
- constructor(private context: DatalogContext) {}
24
+ constructor(private context: DatalogContext) {
25
+ this.sliceable = new ObjMap((decl) => context.manager.getDeclHash(decl));
26
+ this.slice2old = new ObjMap((decl) => context.manager.getDeclHash(decl));
27
+ }
21
28
 
22
29
  private getPredicateSlice(predicate: number) {
23
30
  const existing = this.sliceable.get(predicate);
@@ -82,7 +89,7 @@ export class MkSlice implements RuleTransformerPlugin {
82
89
  const manager = this.context.manager;
83
90
  if (manager.getOp(expr) === OP_ITE) {
84
91
  const thenEq = this.getEq(manager.getArg(expr, 1));
85
- const elseEq = this.getEq(manager.getArg(expr, 2));
92
+ const elseEq = thenEq === undefined ? undefined : this.getEq(manager.getArg(expr, 2));
86
93
  if (thenEq !== undefined && elseEq !== undefined && thenEq.index === elseEq.index)
87
94
  return {
88
95
  index: thenEq.index,
@@ -95,11 +102,13 @@ export class MkSlice implements RuleTransformerPlugin {
95
102
  }
96
103
  if (manager.kinds[expr] === KIND_VAR)
97
104
  return { index: manager.values[expr], value: manager.trueExpr };
98
- if (manager.isNot(expr) && manager.kinds[manager.getArg(expr, 0)] === KIND_VAR)
99
- return { index: manager.values[manager.getArg(expr, 0)], value: manager.falseExpr };
100
- if (manager.getOp(expr) !== OP_EQ) return undefined;
101
- const left = manager.getArg(expr, 0);
102
- const right = manager.getArg(expr, 1);
105
+ // is_not rebinds the expression to its argument, so the equation under a negation is solved.
106
+ const atom = manager.isNot(expr) ? manager.getArg(expr, 0) : expr;
107
+ if (atom !== expr && manager.kinds[atom] === KIND_VAR)
108
+ return { index: manager.values[atom], value: manager.falseExpr };
109
+ if (manager.getOp(atom) !== OP_EQ) return undefined;
110
+ const left = manager.getArg(atom, 0);
111
+ const right = manager.getArg(atom, 1);
103
112
  if (manager.kinds[left] === KIND_VAR) return { index: manager.values[left], value: right };
104
113
  if (manager.kinds[right] === KIND_VAR) return { index: manager.values[right], value: left };
105
114
  return undefined;
@@ -214,6 +223,7 @@ export class MkSlice implements RuleTransformerPlugin {
214
223
  );
215
224
  this.predicates.set(predicate, sliced);
216
225
  target.inheritPredicate(source, predicate, sliced);
226
+ this.slice2old.set(sliced, predicate);
217
227
  } else if (source.isOutputPredicate(predicate)) {
218
228
  target.setOutputPredicate(predicate);
219
229
  hasOutput = true;
@@ -246,16 +256,14 @@ export class MkSlice implements RuleTransformerPlugin {
246
256
  return;
247
257
  }
248
258
  this.initVars(rule);
259
+ const head = this.updatePredicate(rule.head);
249
260
  const tail = rule.tail
250
261
  .slice(0, rule.uninterpretedSize)
251
262
  .map((atom) => this.updatePredicate(atom));
252
263
  const conjs = this.getTailConjs(rule);
253
264
  tail.push(...conjs.items);
254
265
  const ruleManager = this.context.ruleManager;
255
- const updated = ruleManager.fixUnboundVars(
256
- ruleManager.mk(this.updatePredicate(rule.head), tail, [], rule.name),
257
- false,
258
- );
266
+ const updated = ruleManager.fixUnboundVars(ruleManager.mk(head, tail, [], rule.name), false);
259
267
  conjs.reset();
260
268
  target.addRule(updated);
261
269
  }
@@ -273,6 +281,61 @@ export class MkSlice implements RuleTransformerPlugin {
273
281
  this.declarePredicates(source, result);
274
282
  if (this.predicates.size === 0) return undefined;
275
283
  for (const rule of source.rules) this.updateRule(rule, result);
284
+ const slice2old = this.slice2old;
285
+ const sliceable = new Map([...this.sliceable].map((entry) => [entry[0], [...entry[1]]]));
286
+ this.context.modelConverters?.push((model) => this.convertModel(model, slice2old, sliceable));
276
287
  return result;
277
288
  }
289
+
290
+ // slice_model_converter::operator(): the interpretation of a sliced predicate over the
291
+ // arguments of the predicate it was sliced from.
292
+ private convertModel(
293
+ model: ProtoModel,
294
+ slice2old: ObjMap<number>,
295
+ sliceable: ReadonlyMap<number, boolean[]>,
296
+ ) {
297
+ const manager = this.context.manager;
298
+ const oldModel = new ProtoModel(manager);
299
+ const varSubst = new VarSubst(manager, false);
300
+ for (const [sliced, predicate] of slice2old) {
301
+ // Z3 drops the interpretation of a predicate that has every argument sliced.
302
+ if (manager.funcDecls[sliced].domain.length === 0) continue;
303
+ const slice = sliceable.get(predicate) ?? [];
304
+ const domain = manager.funcDecls[predicate].domain;
305
+ const subst = domain
306
+ .map((sort, index) => manager.mkVar(index, sort))
307
+ .filter((_, index) => !slice[index]);
308
+ const interp = model.funcInterps.get(sliced);
309
+ if (interp === undefined) continue;
310
+ const oldInterp = new FuncInterp(manager, slice.length);
311
+ if (interp.elseExpr !== null) {
312
+ const elseExpr = varSubst.apply(interp.elseExpr, subst);
313
+ oldInterp.setElse(elseExpr);
314
+ manager.decRef(elseExpr);
315
+ }
316
+ for (const entry of interp.entries) {
317
+ let next = 0;
318
+ const args = domain.map((sort, index) =>
319
+ slice[index] ? manager.mkVar(index, sort) : varSubst.apply(entry.args[next++], subst),
320
+ );
321
+ const result = varSubst.apply(entry.result, subst);
322
+ oldInterp.insertEntry(args, result);
323
+ manager.decRef(result);
324
+ args.forEach((arg, index) => {
325
+ if (!slice[index]) manager.decRef(arg);
326
+ });
327
+ }
328
+ oldModel.registerFunc(predicate, oldInterp);
329
+ }
330
+ for (const decl of model.getConstDecls()) {
331
+ const value = model.constInterps.get(decl);
332
+ if (value !== undefined && !slice2old.has(decl)) oldModel.registerConst(decl, value);
333
+ }
334
+ for (const decl of model.getFuncDecls()) {
335
+ const interp = model.funcInterps.get(decl);
336
+ if (interp !== undefined && !slice2old.has(decl)) oldModel.registerFunc(decl, interp.copy());
337
+ }
338
+ varSubst.release();
339
+ return oldModel;
340
+ }
278
341
  }