tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

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 (235) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +13 -3
  7. package/dist/index.d.ts +13 -3
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
@@ -2,7 +2,7 @@ import { FAMILY_BASIC, FAMILY_USER, SORT_BOOL } from "./ast";
2
2
  import type { Context } from "./context";
3
3
  import { Enode } from "./enode";
4
4
  import { FuncInterp, ProtoModel } from "./proto-model";
5
- import type { DependentValue } from "./theory";
5
+ import type { DependentValue, ExtraFreshValue } from "./theory";
6
6
 
7
7
  export interface GeneratedModel {
8
8
  model: ProtoModel;
@@ -19,6 +19,9 @@ const isIncludedFuncInterp = (context: Context, decl: number) => {
19
19
  return context.getTheory(family)?.includeFuncInterp(decl) ?? true;
20
20
  };
21
21
 
22
+ const GREY = 1;
23
+ const BLACK = 2;
24
+
22
25
  export const mkModel = (context: Context): GeneratedModel => {
23
26
  const manager = context.manager;
24
27
  const model = new ProtoModel(manager);
@@ -34,58 +37,95 @@ export const mkModel = (context: Context): GeneratedModel => {
34
37
  context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr,
35
38
  );
36
39
  }
37
- const root2value = new Map<Enode, number>();
38
- const freshRoots: Enode[] = [];
39
- const dependentValues = new Map<Enode, DependentValue>();
40
+ const roots: Enode[] = [];
41
+ const procs = new Map<Enode, number | DependentValue>();
42
+ const freshRoots = new Set<Enode>();
43
+ const extraFreshValues = new Set<ExtraFreshValue>();
40
44
  for (const node of context.enodes) {
41
45
  if (node.root !== node) continue;
42
46
  const expr = node.owner;
43
47
  if (!context.isRelevant(expr) && !manager.isValue(expr)) continue;
48
+ roots.push(node);
44
49
  const sort = manager.sorts[expr];
45
50
  const theory = context.getTheory(manager.getSortFamily(sort));
46
51
  if (sort === SORT_BOOL)
47
- root2value.set(node, context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr);
48
- else if (manager.isModelValue(expr)) root2value.set(node, expr);
52
+ procs.set(node, context.findAssignment(expr) > 0 ? manager.trueExpr : manager.falseExpr);
53
+ else if (manager.isModelValue(expr)) procs.set(node, expr);
49
54
  else if (theory !== undefined && theory.buildModels()) {
50
- const value = node.getThVar(theory.id) < 0 ? undefined : theory.mkValue(node);
51
- if (value === undefined) freshRoots.push(node);
52
- else if (typeof value === "number")
53
- root2value.set(node, manager.isValue(expr) ? expr : value);
54
- else dependentValues.set(node, value);
55
- } else {
56
- const value = model.getFreshValue(sort) ?? model.getSomeValue(sort);
57
- root2value.set(node, manager.isValue(expr) ? expr : value);
58
- }
55
+ const proc = node.getThVar(theory.id) < 0 ? undefined : theory.mkValue(node);
56
+ if (proc === undefined) {
57
+ const freshValue: ExtraFreshValue = { sort, value: undefined };
58
+ freshRoots.add(node);
59
+ extraFreshValues.add(freshValue);
60
+ procs.set(node, { dependencies: [freshValue], mkValue: (values) => values[0] });
61
+ } else {
62
+ if (typeof proc !== "number")
63
+ for (const dependency of proc.dependencies)
64
+ if (!(dependency instanceof Enode)) extraFreshValues.add(dependency);
65
+ procs.set(node, proc);
66
+ }
67
+ } else procs.set(node, model.getFreshValue(sort) ?? model.getSomeValue(sort));
59
68
  }
60
- for (const value of root2value.values()) model.registerValue(value);
61
- // A value that depends on others comes after them, and before the fresh values of its sort.
62
- const getFreshValue = (node: Enode) => {
63
- const sort = manager.sorts[node.owner];
64
- const freshValue = model.getFreshValue(sort) ?? model.getSomeValue(sort);
65
- const value = manager.isValue(node.owner) ? node.owner : freshValue;
66
- root2value.set(node, value);
67
- return value;
69
+ const colors = new Map<Enode | ExtraFreshValue, number>();
70
+ const traversedSorts = new Set<number>();
71
+ const sortedSources: (Enode | ExtraFreshValue)[] = [];
72
+ const todo: (Enode | ExtraFreshValue)[] = [];
73
+ const visitChild = (source: Enode | ExtraFreshValue) => {
74
+ if (!colors.has(source)) todo.push(source);
68
75
  };
69
- const getDependentValue = (node: Enode): number => {
70
- const existing = root2value.get(node);
71
- if (existing !== undefined) return existing;
72
- const dependent = dependentValues.get(node);
73
- if (dependent === undefined) return getFreshValue(node);
74
- dependentValues.delete(node);
75
- const values = dependent.dependencies.map((dependency) => {
76
- if (dependency instanceof Enode) return getDependentValue(dependency.root);
77
- dependency.value ??=
78
- model.getFreshValue(dependency.sort) ?? model.getSomeValue(dependency.sort);
79
- return dependency.value;
80
- });
81
- // A class whose root is a value, such as a constant array, takes it after its dependencies.
82
- const value = manager.isValue(node.owner) ? node.owner : dependent.mkValue(values);
83
- model.registerValue(value);
84
- root2value.set(node, value);
85
- return value;
76
+ const processSource = (source: Enode | ExtraFreshValue) => {
77
+ if (colors.get(source) === BLACK) return;
78
+ todo.push(source);
79
+ while (todo.length > 0) {
80
+ const current = todo[todo.length - 1];
81
+ const color = colors.get(current);
82
+ if (color === BLACK) todo.pop();
83
+ else if (color === GREY) {
84
+ colors.set(current, BLACK);
85
+ sortedSources.push(current);
86
+ } else {
87
+ colors.set(current, GREY);
88
+ if (current instanceof Enode) {
89
+ const proc = procs.get(current);
90
+ if (proc !== undefined && typeof proc !== "number")
91
+ for (const dependency of proc.dependencies)
92
+ visitChild(dependency instanceof Enode ? dependency.root : dependency);
93
+ } else if (!traversedSorts.has(current.sort)) {
94
+ for (const root of roots)
95
+ if (manager.sorts[root.owner] === current.sort && !freshRoots.has(root))
96
+ visitChild(root);
97
+ traversedSorts.add(current.sort);
98
+ }
99
+ }
100
+ }
86
101
  };
87
- for (const node of dependentValues.keys()) getDependentValue(node);
88
- for (const node of freshRoots) if (!root2value.has(node)) getFreshValue(node);
102
+ for (const freshValue of extraFreshValues) processSource(freshValue);
103
+ for (const root of freshRoots) processSource(root);
104
+ for (const root of roots) processSource(root);
105
+ const root2value = new Map<Enode, number>();
106
+ for (const source of sortedSources) {
107
+ if (!(source instanceof Enode)) {
108
+ source.value = model.getFreshValue(source.sort) ?? undefined;
109
+ continue;
110
+ }
111
+ const expr = source.owner;
112
+ const sort = manager.sorts[expr];
113
+ const proc = procs.get(source) ?? model.getFreshValue(sort) ?? model.getSomeValue(sort);
114
+ const value = manager.isValue(expr)
115
+ ? expr
116
+ : typeof proc === "number"
117
+ ? proc
118
+ : proc.mkValue(
119
+ proc.dependencies.map((dependency) =>
120
+ dependency instanceof Enode
121
+ ? (root2value.get(dependency.root) ??
122
+ model.getSomeValue(manager.sorts[dependency.owner]))
123
+ : (dependency.value ?? model.getSomeValue(dependency.sort)),
124
+ ),
125
+ );
126
+ model.registerValue(value);
127
+ root2value.set(source, value);
128
+ }
89
129
  const getValue = (node: Enode) =>
90
130
  root2value.get(node.root) ?? model.getSomeValue(manager.sorts[node.owner]);
91
131
  for (const node of context.enodes)
@@ -104,7 +144,9 @@ export const mkModel = (context: Context): GeneratedModel => {
104
144
  interp = new FuncInterp(manager, node.numArgs);
105
145
  model.registerFunc(node.decl, interp);
106
146
  }
107
- const args = Array.from({ length: node.numArgs }, (_, index) => getValue(node.getArg(index)));
147
+ const args = Array.from({ length: node.numArgs }, (_value, index) =>
148
+ getValue(node.getArg(index)),
149
+ );
108
150
  if (interp.getEntry(args) === undefined) interp.insertNewEntry(args, getValue(node));
109
151
  }
110
152
  for (const theory of context.theories) theory.finalizeModel();
@@ -44,9 +44,9 @@ const getRoot = (value: bigint) => {
44
44
  return low * low === value ? { root: low, isExact: true } : { root: low + 1n, isExact: false };
45
45
  };
46
46
 
47
- export const mkBotExp = (ebits: number) => -(2 ** (ebits - 1) - 1);
47
+ const mkBotExp = (ebits: number) => -(2 ** (ebits - 1) - 1);
48
48
 
49
- export const mkTopExp = (ebits: number) => 2 ** (ebits - 1);
49
+ const mkTopExp = (ebits: number) => 2 ** (ebits - 1);
50
50
 
51
51
  export const mkMinExp = (ebits: number) => mkBotExp(ebits) + 1;
52
52
 
@@ -98,8 +98,6 @@ export const isPzero = (value: Mpf) => !value.sign && isZero(value);
98
98
 
99
99
  export const isNeg = (value: Mpf) => value.sign && !isNan(value);
100
100
 
101
- export const isPos = (value: Mpf) => !value.sign && !isNan(value);
102
-
103
101
  export const isDenormal = (value: Mpf) => !isZero(value) && hasBotExp(value);
104
102
 
105
103
  export const isNormal = (value: Mpf) => !(hasTopExp(value) || isDenormal(value) || isZero(value));
@@ -10,7 +10,7 @@ export class Mus {
10
10
 
11
11
  constructor(
12
12
  private manager: AstManager,
13
- private solver: MaxsatSolver,
13
+ private solver: Pick<MaxsatSolver, "checkSat" | "getUnsatCore">,
14
14
  ) {
15
15
  this.lit2expr = new RefVector(manager);
16
16
  this.trail = new RefVector(manager);
@@ -33,8 +33,7 @@ export class Mus {
33
33
  return L_TRUE;
34
34
  }
35
35
  let unknown = [...literals];
36
- while (unknown.length > 0) {
37
- const literal = unknown.pop() as number;
36
+ for (let literal = unknown.pop(); literal !== undefined; literal = unknown.pop()) {
38
37
  const notLiteral = mkNot(this.manager, literal);
39
38
  this.trail.push(notLiteral);
40
39
  const status = this.solver.checkSat([...mus.items, ...unknown, notLiteral]);
@@ -10,16 +10,16 @@ import {
10
10
  SORT_SIZE_INFINITE,
11
11
  } from "../ast";
12
12
  import type { Definition } from "../goal";
13
- import { ModelEvaluator } from "../model-evaluator";
14
- import { FuncInterp, type ProtoModel } from "../proto-model";
13
+ import type { ProtoModel } from "../proto-model";
15
14
  import { type RewriterOptions, Rewriter } from "../rewriter";
16
15
  import { RefVector } from "../ref-vector";
17
16
  import { applyQeLiteToConjuncts } from "../qe-lite";
17
+ import { applyDefinitions } from "../tactic";
18
18
  import { BindVariables, mkExists, type Rule, RuleManager, getUsedVars } from "./dl-rule";
19
19
  import { RuleSet } from "./dl-rule-set";
20
20
  import { RuleProperties } from "./rule-properties";
21
21
 
22
- const ENGINE_DATALOG = 0;
22
+ export const ENGINE_DATALOG = 0;
23
23
  export const ENGINE_SPACER = 1;
24
24
  const ENGINE_BMC = 2;
25
25
  const ENGINE_QBMC = 3;
@@ -38,9 +38,13 @@ const ENGINE_NAMES = new Map([
38
38
  ["ddnf", ENGINE_DDNF],
39
39
  ]);
40
40
 
41
- // The fp module's parameters, which Z3 keeps as global parameters across resets.
41
+ // As in Z3, these are copied when the context is made, so a later fp option doesn't apply.
42
42
  export class FpParams {
43
- constructor(private parameters: ReadonlyMap<string, string>) {}
43
+ private parameters: ReadonlyMap<string, string>;
44
+
45
+ constructor(parameters: ReadonlyMap<string, string>) {
46
+ this.parameters = new Map(parameters);
47
+ }
44
48
 
45
49
  getBool(name: string, defaultValue: boolean) {
46
50
  const value = this.parameters.get(`fp.${name}`);
@@ -59,40 +63,6 @@ export class FpParams {
59
63
 
60
64
  export type ModelConverter = (model: ProtoModel) => ProtoModel;
61
65
 
62
- // generic_model_converter::operator() over predicates, where a definition of -1 hides the
63
- // declaration.
64
- const applyDefinitions = (definitions: readonly Definition[], model: ProtoModel) => {
65
- const manager = model.manager;
66
- let evaluator = new ModelEvaluator(manager, model);
67
- evaluator.setModelCompletion(true);
68
- for (let index = definitions.length - 1; index >= 0; index--) {
69
- const definition = definitions[index];
70
- if (definition.def === -1) {
71
- model.unregisterDecl(definition.decl);
72
- continue;
73
- }
74
- const value = evaluator.rewrite(definition.def);
75
- const arity = manager.funcDecls[definition.decl].domain.length;
76
- const oldInterp = model.funcInterps.get(definition.decl);
77
- const old = arity === 0 ? model.constInterps.get(definition.decl) : oldInterp?.elseExpr;
78
- if (old !== value) {
79
- if (arity === 0) model.registerConst(definition.decl, value);
80
- else {
81
- const interp = new FuncInterp(manager, arity);
82
- interp.setElse(value);
83
- model.registerFunc(definition.decl, interp);
84
- }
85
- }
86
- manager.decRef(value);
87
- if (old === value || (arity === 0 ? old === undefined : oldInterp === undefined)) continue;
88
- evaluator.release();
89
- evaluator = new ModelEvaluator(manager, model);
90
- evaluator.setModelCompletion(true);
91
- }
92
- evaluator.release();
93
- return model;
94
- };
95
-
96
66
  export interface Engine {
97
67
  query(query: number): number;
98
68
  getModel(): ProtoModel;
@@ -108,7 +78,7 @@ export class DatalogContext {
108
78
  private isBindingVariables = true;
109
79
  ruleSet: RuleSet;
110
80
  private ruleFmls: number[] = [];
111
- private ruleNames: string[] = [];
81
+ private ruleNames: (string | undefined)[] = [];
112
82
  private ruleFmlsHead = 0;
113
83
  readonly background: number[] = [];
114
84
  private isClosed = false;
@@ -117,6 +87,7 @@ export class DatalogContext {
117
87
  readonly rewriter: Rewriter;
118
88
  // m_mc: the converters since the last query, or undefined before one.
119
89
  modelConverters: ModelConverter[] | undefined;
90
+ isBounded = false;
120
91
 
121
92
  constructor(
122
93
  readonly manager: AstManager,
@@ -176,7 +147,7 @@ export class DatalogContext {
176
147
  return result;
177
148
  }
178
149
 
179
- addRule(fml: number, name = "") {
150
+ addRule(fml: number, name?: string) {
180
151
  this.manager.incRef(fml);
181
152
  this.ruleFmls.push(fml);
182
153
  this.ruleNames.push(name);
@@ -212,7 +183,13 @@ export class DatalogContext {
212
183
  const properties = this.ruleProperties;
213
184
  switch (this.getEngine()) {
214
185
  case ENGINE_DATALOG:
215
- throw new SmtUnsupportedError("the datalog engine");
186
+ properties.collect(rules);
187
+ properties.checkQuantifierFree();
188
+ properties.checkUninterpretedFree();
189
+ properties.checkNestedFree();
190
+ properties.checkInfiniteSorts();
191
+ properties.checkBackgroundFree();
192
+ break;
216
193
  case ENGINE_SPACER:
217
194
  properties.collect(rules);
218
195
  properties.checkExistentialTail();
@@ -328,6 +305,7 @@ export class DatalogContext {
328
305
 
329
306
  query(query: number) {
330
307
  this.modelConverters = [];
308
+ this.isBounded = false;
331
309
  this.getEngine(query);
332
310
  this.flushAddRules();
333
311
  return this.ensureEngine(query).query(query);
@@ -362,7 +340,7 @@ export class DatalogContext {
362
340
  : mkExists(
363
341
  manager,
364
342
  [...domain].reverse(),
365
- domain.map((_, index) => String(index)).reverse(),
343
+ domain.map((_value, index) => String(index)).reverse(),
366
344
  atom,
367
345
  );
368
346
  manager.incRef(query);
@@ -395,7 +373,7 @@ export class DatalogContext {
395
373
  ...conjs.items.map((conj) => this.ruleManager.ensureApp(conj)),
396
374
  ];
397
375
  const isNegated = tail.map(
398
- (_, index) => index < rule.uninterpretedSize && rule.isNegated[index],
376
+ (_value, index) => index < rule.uninterpretedSize && rule.isNegated[index],
399
377
  );
400
378
  const reduced = this.ruleManager.mk(rule.head, tail, isNegated, rule.name);
401
379
  conjs.reset();
@@ -91,7 +91,7 @@ export class MkCoiFilter implements RuleTransformerPlugin {
91
91
  newTail.push(rule.tail[index]);
92
92
  newNegated.push(false);
93
93
  }
94
- result.addRule(this.context.ruleManager.mk(rule.head, newTail, newNegated, "", false));
94
+ result.addRule(this.context.ruleManager.mk(rule.head, newTail, newNegated, undefined, false));
95
95
  }
96
96
  if (result.rules.length === source.rules.length) return undefined;
97
97
  result.close();
@@ -213,7 +213,7 @@ export class MkSlice implements RuleTransformerPlugin {
213
213
  const manager = this.context.manager;
214
214
  let hasOutput = false;
215
215
  for (const [predicate, slice] of this.sliceable) {
216
- const domain = manager.funcDecls[predicate].domain.filter((_, index) => !slice[index]);
216
+ const domain = manager.funcDecls[predicate].domain.filter((_value, index) => !slice[index]);
217
217
  if (domain.length < slice.length) {
218
218
  const sliced = this.context.mkFreshHeadPredicate(
219
219
  getSymbolName(manager.funcDecls[predicate].name),
@@ -238,7 +238,7 @@ export class MkSlice implements RuleTransformerPlugin {
238
238
  const slice = this.getPredicateSlice(manager.decls[atom]);
239
239
  return manager.mkApp(
240
240
  sliced,
241
- manager.getArgs(atom).filter((_, index) => !slice[index]),
241
+ manager.getArgs(atom).filter((_value, index) => !slice[index]),
242
242
  SORT_BOOL,
243
243
  );
244
244
  }
@@ -303,7 +303,7 @@ export class MkSlice implements RuleTransformerPlugin {
303
303
  const domain = manager.funcDecls[predicate].domain;
304
304
  const subst = domain
305
305
  .map((sort, index) => manager.mkVar(index, sort))
306
- .filter((_, index) => !slice[index]);
306
+ .filter((_value, index) => !slice[index]);
307
307
  const interp = model.funcInterps.get(sliced);
308
308
  if (interp === undefined) continue;
309
309
  const oldInterp = new FuncInterp(manager, slice.length);
@@ -47,7 +47,7 @@ export class Rule {
47
47
  readonly isNegated: boolean[],
48
48
  readonly uninterpretedSize: number,
49
49
  readonly positiveSize: number,
50
- readonly name: string,
50
+ readonly name: string | undefined,
51
51
  ) {}
52
52
 
53
53
  getDecl(manager: AstManager) {
@@ -64,9 +64,8 @@ export class Rule {
64
64
  return false;
65
65
  }
66
66
 
67
- // symbol::str of the name, where the empty name is the null symbol.
68
67
  getNameText() {
69
- return this.name === "" ? "<null>" : this.name;
68
+ return this.name ?? "<null>";
70
69
  }
71
70
 
72
71
  display(context: DatalogContext) {
@@ -225,20 +224,20 @@ export class RuleManager {
225
224
  return expr;
226
225
  }
227
226
 
228
- mkRule(fml: number, rules: RuleSet, name = "") {
227
+ mkRule(fml: number, rules: RuleSet, name?: string) {
229
228
  const bound = this.context.bindVars(fml, true);
230
229
  if (this.manager.hasLabelFlags[bound]) throw new SmtUnsupportedError("labels in Horn rules");
231
230
  this.mkRuleCore(bound, rules, name);
232
231
  }
233
232
 
234
- private mkRuleCore(fml: number, rules: RuleSet, name: string) {
233
+ private mkRuleCore(fml: number, rules: RuleSet, name: string | undefined) {
235
234
  this.hnf.setName(name);
236
235
  const fmls = this.hnf.apply(fml);
237
236
  for (const predicate of this.hnf.freshPredicates) this.context.registerPredicate(predicate);
238
237
  for (const horn of fmls) this.mkHornRule(horn, rules, name);
239
238
  }
240
239
 
241
- private mkHornRule(fml: number, rules: RuleSet, name: string) {
240
+ private mkHornRule(fml: number, rules: RuleSet, name: string | undefined) {
242
241
  const manager = this.manager;
243
242
  const body: number[] = [];
244
243
  const extracted = this.extractHorn(fml, body);
@@ -307,7 +306,7 @@ export class RuleManager {
307
306
  head: number,
308
307
  tail: readonly number[],
309
308
  isNegated: readonly boolean[],
310
- name = "",
309
+ name?: string,
311
310
  isNormalizing = true,
312
311
  ) {
313
312
  const manager = this.manager;
@@ -382,7 +381,7 @@ export class RuleManager {
382
381
  return mkForall(
383
382
  manager,
384
383
  sorts,
385
- sorts.map((_, index) => getVarName(index)),
384
+ sorts.map((_value, index) => getVarName(index)),
386
385
  matrix,
387
386
  );
388
387
  }
@@ -479,7 +478,7 @@ export class RuleManager {
479
478
  const preQuant = this.pin(varSubst.apply(unboundTail, subst));
480
479
  varSubst.release();
481
480
  sorts.reverse();
482
- const names = sorts.map((_, index) => String(sorts.length - 1 - index));
481
+ const names = sorts.map((_value, index) => String(sorts.length - 1 - index));
483
482
  const quantified = this.pin(mkExists(manager, sorts, names, preQuant));
484
483
  let fixed = isTryingQe ? this.pin(simplifyQuantifiers(manager, quantified)) : quantified;
485
484
  if (manager.kinds[fixed] !== KIND_APP) fixed = this.pin(manager.mkEq(fixed, manager.trueExpr));
@@ -25,8 +25,8 @@ export class Hnf {
25
25
 
26
26
  constructor(private manager: AstManager) {}
27
27
 
28
- setName(name: string) {
29
- this.name = name === "" ? "P" : name;
28
+ setName(name: string | undefined) {
29
+ this.name = name ?? "P";
30
30
  }
31
31
 
32
32
  private isPredicate(expr: number) {
@@ -64,7 +64,7 @@ export class HornSubsumeModelConverter {
64
64
  const quantified = manager.mkQuantifier({
65
65
  kind: QUANTIFIER_EXISTS,
66
66
  sorts: sorts.reverse(),
67
- names: sorts.map((_, index) => sorts.length - index - 1),
67
+ names: sorts.map((_value, index) => sorts.length - index - 1),
68
68
  body: substituted,
69
69
  patterns: [],
70
70
  noPatterns: [],
@@ -17,7 +17,7 @@ import { L_FALSE, L_TRUE } from "../lbool";
17
17
  import { RefVector } from "../ref-vector";
18
18
  import type { RewriterOptions } from "../rewriter";
19
19
  import { getFreeVarSorts } from "../var-subst";
20
- import { DatalogContext, ENGINE_SPACER, FpParams } from "./dl-context";
20
+ import { DatalogContext, ENGINE_DATALOG, ENGINE_SPACER, FpParams } from "./dl-context";
21
21
  import { mkForall, mkPp } from "./dl-rule";
22
22
  import { SpacerDlInterface } from "./spacer-dl-interface";
23
23
 
@@ -27,6 +27,19 @@ export const createDatalogContext = (
27
27
  rewriterOptions: RewriterOptions,
28
28
  ) =>
29
29
  new DatalogContext(manager, new FpParams(parameters), rewriterOptions, (context, engine) => {
30
+ if (engine === ENGINE_DATALOG)
31
+ return {
32
+ // rel_context::query checks the rules with the query's before the saturation the port lacks.
33
+ query: (query) => {
34
+ context.ruleManager.mkQuery(query, context.getRules());
35
+ context.ensureClosed();
36
+ context.getRules();
37
+ throw new SmtUnsupportedError("the datalog engine");
38
+ },
39
+ getModel: () => {
40
+ throw new SmtUnsupportedError("the datalog engine");
41
+ },
42
+ };
30
43
  if (engine !== ENGINE_SPACER) throw new SmtUnsupportedError("the bmc engine");
31
44
  return new SpacerDlInterface(context);
32
45
  });
@@ -138,7 +151,7 @@ class HornTactic {
138
151
  );
139
152
  if (sorts.length === 0) return formula;
140
153
  sorts.reverse();
141
- const names = sorts.map((_, index) => String(sorts.length - index - 1));
154
+ const names = sorts.map((_value, index) => String(sorts.length - index - 1));
142
155
  const result = mkForall(manager, sorts, names, formula);
143
156
  manager.incRef(result);
144
157
  return result;
@@ -277,6 +277,28 @@ export class RuleProperties {
277
277
  );
278
278
  }
279
279
 
280
+ checkQuantifierFree() {
281
+ const first = this.quantifiers.entries().next();
282
+ if (first.done !== true)
283
+ throw new SmtTacticError(
284
+ `cannot process quantifier in rule ${first.value[1].display(this.context)}`,
285
+ );
286
+ }
287
+
288
+ checkNestedFree() {
289
+ const rules = this.interpretedPredicateRules;
290
+ if (rules.length > 0)
291
+ throw new SmtTacticError(`Rule contains nested predicates ${rules[0].display(this.context)}`);
292
+ }
293
+
294
+ checkInfiniteSorts() {
295
+ const rules = this.infiniteSortRules;
296
+ if (rules.length > 0)
297
+ throw new SmtTacticError(
298
+ `Rule contains infinite sorts in rule ${rules[rules.length - 1].display(this.context)}`,
299
+ );
300
+ }
301
+
280
302
  checkExistsFree() {
281
303
  for (const entry of this.quantifiers)
282
304
  if (this.manager.getQuantifier(entry[0]).kind === QUANTIFIER_EXISTS)
@@ -53,7 +53,6 @@ export class Lemma {
53
53
  ctp: ProtoModel | undefined;
54
54
  level: number;
55
55
  bumped = 0;
56
- weakness: number;
57
56
  isBlocked = false;
58
57
 
59
58
  constructor(
@@ -63,7 +62,6 @@ export class Lemma {
63
62
  pob?: Pob,
64
63
  ) {
65
64
  this.level = level;
66
- this.weakness = pob === undefined ? 65535 : pob.weakness;
67
65
  this.pob = pob;
68
66
  if (body !== -1) this.body = context.normalizer.normalize(body);
69
67
  }
@@ -298,7 +296,6 @@ class Derivation {
298
296
 
299
297
  constructor(
300
298
  readonly parent: Pob,
301
- readonly rule: Rule,
302
299
  private trans: number,
303
300
  private evars: number[],
304
301
  ) {}
@@ -1142,6 +1139,7 @@ export class SpacerContext {
1142
1139
  this.pobQueue.incLevel();
1143
1140
  level = this.pobQueue.maxLevel;
1144
1141
  }
1142
+ this.datalogContext.isBounded = true;
1145
1143
  return L_UNDEF;
1146
1144
  }
1147
1145
 
@@ -1372,7 +1370,7 @@ export class SpacerContext {
1372
1370
  ];
1373
1371
  phi = pt.mbp(vars, phi, model, this.isUsingGroundPob);
1374
1372
  if (this.isUsingGpdr && predicates.length > 1) return gpdrCreateSplitChildren();
1375
- const derivation = new Derivation(pob, rule, phi, vars);
1373
+ const derivation = new Derivation(pob, phi, vars);
1376
1374
  for (let index = 0; index < predicates.length; index++) {
1377
1375
  const premisePt = this.getPredTransformer(predicates[index]);
1378
1376
  const summary = premisePt.getOriginSummary(
@@ -210,6 +210,7 @@ export const gpdrSolveCore = (context: SpacerContext) => {
210
210
  if (reachable !== L_FALSE) return reachable;
211
211
  if (level > 0 && context.propagate(context.expandedLevel, level)) return L_FALSE;
212
212
  }
213
+ context.datalogContext.isBounded = true;
213
214
  return L_UNDEF;
214
215
  };
215
216
 
@@ -128,7 +128,7 @@ export class IucSolver {
128
128
  const result = kernel.check(this.assumptions);
129
129
  this.lastModel = undefined;
130
130
  if (result === L_TRUE) {
131
- this.lastModel = kernel.context.getModel();
131
+ this.lastModel = kernel.context.getSatModel();
132
132
  this.lastModel.incRef();
133
133
  }
134
134
  this.lastCore = result === L_FALSE ? [...kernel.context.unsatCore] : [];
@@ -429,7 +429,7 @@ class Nlqsat {
429
429
 
430
430
  private mkModel() {
431
431
  const manager = this.manager;
432
- const model = new ProtoModel(manager);
432
+ const model = new ProtoModel(manager).mkModel();
433
433
  for (const [term, variable] of this.t2x) {
434
434
  if (!manager.isUninterpretedConst(term) || !this.freeVars.has(term)) continue;
435
435
  const value = this.rmodel0[variable] ?? new Anum(Rational.zero);