tla-ts 0.0.10-dev.3a85c3a9e → 0.0.10-dev.45c0eaef5

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 (260) 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 +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +18 -4
  7. package/dist/index.d.ts +18 -4
  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 +56 -56
  14. package/dist/prove.js +79 -79
  15. package/dist/run.cjs +40 -44
  16. package/dist/run.js +42 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +97 -92
  20. package/dist/transfer.js +97 -92
  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 +31 -3
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -107
  29. package/src/check.ts +535 -281
  30. package/src/cli/runtime-invariants.ts +20 -56
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +21 -7
  33. package/src/cli/tlc.ts +31 -11
  34. package/src/cli/xml-exporter.ts +1 -1
  35. package/src/codegen.ts +23 -10
  36. package/src/coverage.ts +255 -18
  37. package/src/dependencies.ts +68 -15
  38. package/src/dfid.ts +101 -36
  39. package/src/environment.ts +131 -41
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -13
  43. package/src/instances.ts +135 -11
  44. package/src/java-hash.ts +14 -0
  45. package/src/java-overrides.ts +2 -2
  46. package/src/levels.ts +675 -236
  47. package/src/lexer.ts +12 -2
  48. package/src/liveness-checker.ts +204 -62
  49. package/src/liveness.ts +55 -10
  50. package/src/obligations/index.ts +1 -1
  51. package/src/obligations/normalize.ts +1 -4
  52. package/src/obligations/printer.ts +5 -5
  53. package/src/obligations/source.ts +2 -0
  54. package/src/parallel-worker.ts +8 -2
  55. package/src/parallel.ts +5 -0
  56. package/src/parser.ts +180 -149
  57. package/src/prover/isabelle/isar/attrib.ts +4 -4
  58. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  59. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  60. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  61. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  62. package/src/prover/isabelle/pure/term.ts +3 -3
  63. package/src/prover/prep/md5.ts +26 -29
  64. package/src/prover/smt/rewrite.ts +2 -7
  65. package/src/prover/smt/simplify.ts +1 -1
  66. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  67. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  68. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  69. package/src/prover/smt/solver/ast-lt.ts +1 -1
  70. package/src/prover/smt/solver/ast.ts +66 -14
  71. package/src/prover/smt/solver/auf-solver.ts +23 -12
  72. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  73. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  74. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  75. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  76. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  77. package/src/prover/smt/solver/card2bv.ts +35 -18
  78. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  79. package/src/prover/smt/solver/context.ts +84 -15
  80. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  81. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  82. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  83. package/src/prover/smt/solver/diff-neq.ts +1 -2
  84. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  85. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  86. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  87. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  88. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  89. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  90. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  91. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  92. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  93. package/src/prover/smt/solver/euf/mam.ts +1 -5
  94. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  95. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  96. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  97. package/src/prover/smt/solver/factor.ts +36 -14
  98. package/src/prover/smt/solver/fd-solver.ts +608 -139
  99. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  100. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  101. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  102. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  103. package/src/prover/smt/solver/goal.ts +6 -3
  104. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  105. package/src/prover/smt/solver/hashtable.ts +4 -0
  106. package/src/prover/smt/solver/internalizer.ts +1 -1
  107. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  108. package/src/prover/smt/solver/lp/containers.ts +7 -1
  109. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  110. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  111. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  112. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  113. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  114. package/src/prover/smt/solver/lp/nex.ts +2 -1
  115. package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
  116. package/src/prover/smt/solver/lp/nla-core.ts +26 -6
  117. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
  118. package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
  119. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  120. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  121. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  122. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  123. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  124. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  125. package/src/prover/smt/solver/maxcore.ts +2 -1
  126. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  127. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  128. package/src/prover/smt/solver/model-checker.ts +1 -1
  129. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  130. package/src/prover/smt/solver/model-generator.ts +85 -43
  131. package/src/prover/smt/solver/mpf.ts +2 -4
  132. package/src/prover/smt/solver/mus.ts +2 -3
  133. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  134. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  135. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  136. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  137. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  138. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  139. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  140. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  141. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  142. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  143. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  144. package/src/prover/smt/solver/nlqsat.ts +1 -1
  145. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  146. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  147. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  148. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  149. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  150. package/src/prover/smt/solver/nlsat/solver.ts +74 -71
  151. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  152. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  153. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  154. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  155. package/src/prover/smt/solver/nnf.ts +6 -2
  156. package/src/prover/smt/solver/opt-context.ts +21 -7
  157. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  158. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  159. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  160. package/src/prover/smt/solver/opt-solver.ts +10 -6
  161. package/src/prover/smt/solver/optsmt.ts +1 -1
  162. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  163. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  164. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  165. package/src/prover/smt/solver/probes.ts +88 -23
  166. package/src/prover/smt/solver/proto-model.ts +8 -8
  167. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  168. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  169. package/src/prover/smt/solver/qe-lite.ts +2 -2
  170. package/src/prover/smt/solver/qe.ts +3 -2
  171. package/src/prover/smt/solver/qsat.ts +23 -8
  172. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  173. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  174. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  175. package/src/prover/smt/solver/rewriter.ts +31 -25
  176. package/src/prover/smt/solver/rlimit.ts +20 -3
  177. package/src/prover/smt/solver/sat/config.ts +1 -1
  178. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  179. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  180. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  181. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  182. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  183. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  184. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  185. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  186. package/src/prover/smt/solver/sat/solver.ts +27 -47
  187. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  188. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  189. package/src/prover/smt/solver/seq-derive.ts +4 -7
  190. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  191. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  192. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  193. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  194. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  195. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  196. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  197. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  198. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  199. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  200. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  201. package/src/prover/smt/solver/smt-setup.ts +106 -13
  202. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  203. package/src/prover/smt/solver/smtlib-script.ts +713 -210
  204. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  205. package/src/prover/smt/solver/solver.ts +18 -3
  206. package/src/prover/smt/solver/tactic.ts +350 -195
  207. package/src/prover/smt/solver/theory-bv.ts +13 -3
  208. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  209. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  210. package/src/prover/smt/solver/theory-lra-internalize.ts +10 -0
  211. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  212. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  213. package/src/prover/smt/solver/theory-lra.ts +1 -1
  214. package/src/prover/smt/solver/theory-pb.ts +24 -7
  215. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  216. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  217. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  218. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  219. package/src/prover/tlapm/cache.ts +8 -8
  220. package/src/prover/zenon/equality-rules.ts +24 -0
  221. package/src/prover/zenon/expr.ts +21 -0
  222. package/src/prover/zenon/index-table.ts +7 -2
  223. package/src/prover/zenon/isar-case.ts +1 -1
  224. package/src/prover/zenon/isar.ts +2 -2
  225. package/src/prover/zenon/phrase.ts +1 -1
  226. package/src/prover/zenon/rules.ts +2 -1
  227. package/src/resolve.ts +1274 -258
  228. package/src/runtime.ts +25 -2
  229. package/src/sany/builtins.ts +10 -10
  230. package/src/sany/generation.ts +5 -15
  231. package/src/sany/generator-def-entries.ts +123 -36
  232. package/src/sany/generator-definitions.ts +5 -3
  233. package/src/sany/generator-expressions.ts +60 -37
  234. package/src/sany/generator-proofs.ts +18 -12
  235. package/src/sany/generator.ts +12 -6
  236. package/src/sany/lexer.ts +15 -7
  237. package/src/sany/modules.ts +4 -2
  238. package/src/sany/nodes.ts +1 -1
  239. package/src/sany/selectors.ts +11 -6
  240. package/src/sany/xml.ts +2 -3
  241. package/src/search.ts +348 -153
  242. package/src/simulate.ts +250 -185
  243. package/src/spec-description.ts +15 -7
  244. package/src/standard-definitions.ts +5 -0
  245. package/src/standard-modules.ts +56 -22
  246. package/src/subexpressions.ts +564 -138
  247. package/src/successors.ts +50 -20
  248. package/src/symmetry.ts +2 -1
  249. package/src/tlc/jar-data.ts +10 -0
  250. package/src/tlc/messages.ts +3 -3
  251. package/src/tlc/order.ts +14 -3
  252. package/src/tlc/random.ts +2 -1
  253. package/src/tlc/replay.ts +147 -46
  254. package/src/tlc/tlc-operators.ts +10 -8
  255. package/src/tlc/tlcext-operators.ts +87 -26
  256. package/src/tlc/trace-spec.ts +11 -25
  257. package/src/trace-liveness.ts +529 -0
  258. package/src/typed-tier.ts +52 -31
  259. package/src/typescript/types.ts +2 -2
  260. package/src/values.ts +150 -79
package/src/search.ts CHANGED
@@ -17,7 +17,11 @@ import type {
17
17
  import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
18
18
  import {
19
19
  addCoverageRelation,
20
+ buildCoverage,
21
+ createCoverage,
22
+ createCoverageEnvironment,
20
23
  getCoverageLabel,
24
+ getCoverageReport,
21
25
  runAtCoverageNode,
22
26
  type Coverage,
23
27
  type CoverageKind,
@@ -28,9 +32,12 @@ import {
28
32
  isExpressionImpure,
29
33
  isImpureDefinition,
30
34
  } from "./dependencies";
31
- import { createEnvironment, type ResolvedModuleOperator } from "./environment";
32
35
  import {
33
- isStackOverflow,
36
+ createEnvironment,
37
+ type ResolvedModuleOperator,
38
+ type RuntimeInvariant,
39
+ } from "./environment";
40
+ import {
34
41
  TlaConfigError,
35
42
  TlaEvaluationError,
36
43
  TlaModuleError,
@@ -49,6 +56,7 @@ import {
49
56
  type Context,
50
57
  type Environment,
51
58
  type Scope,
59
+ type State,
52
60
  } from "./evaluate";
53
61
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
54
62
  import type { JavaOverride } from "./java-overrides";
@@ -63,10 +71,12 @@ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty
63
71
  import { getLiveExpressions } from "./liveness-checker";
64
72
  import { prettyPrint } from "./pretty-print";
65
73
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
74
+ import { createIncompleteSuccessorError, type SuccessorGenerator } from "./successors";
66
75
  import {
67
76
  getSpecDescription,
68
77
  getSpecificationValue,
69
78
  getSubscriptVariables,
79
+ type SpecAction,
70
80
  type SpecDescription,
71
81
  } from "./spec-description";
72
82
  import { getRepresentative, getSymmetryGroup, type Images } from "./symmetry";
@@ -79,14 +89,17 @@ import {
79
89
  withHeadline,
80
90
  } from "./tlc/messages";
81
91
  import { createTlcOrder } from "./tlc/order";
92
+ import { getPrimedRanges, walkSuccessors } from "./tlc/replay";
82
93
  import { getTlcFingerprint, getTlcFingerprints, setFingerprintPolynomial } from "./tlc/fingerprint";
83
94
  import type { TlcVersion } from "./tlc/version";
84
95
  import {
96
+ createModelValue,
85
97
  formatValue,
86
98
  freezeStringOrder,
87
99
  getWrittenPairs,
88
100
  isFunctionValue,
89
101
  isUpdatedElementOf,
102
+ markNormalized,
90
103
  setAliasName,
91
104
  setStringOrder,
92
105
  setValueOptions,
@@ -95,26 +108,34 @@ import {
95
108
  type Value,
96
109
  } from "./values";
97
110
 
98
- interface EnvironmentSettings extends Pick<
99
- CheckOptions,
100
- | "source"
101
- | "loadModule"
102
- | "loadClass"
103
- | "readFile"
104
- | "writeFile"
105
- | "makeDirectory"
106
- | "seed"
107
- | "isTool"
108
- | "traceSpec"
109
- | "isSanyReported"
110
- | "isWarningEnabled"
111
- | "version"
112
- | "moduleOperators"
113
- | "fingerprintPolynomial"
114
- | "maxSetSize"
115
- | "isLazyValueExpanded"
116
- | "isViewPrinted"
117
- > {}
111
+ export interface CliSettings {
112
+ readLine?: () => string | undefined;
113
+ runtimeInvariants?: RuntimeInvariant[];
114
+ }
115
+
116
+ interface EnvironmentSettings
117
+ extends
118
+ Pick<
119
+ CheckOptions,
120
+ | "source"
121
+ | "loadModule"
122
+ | "loadClass"
123
+ | "readFile"
124
+ | "writeFile"
125
+ | "makeDirectory"
126
+ | "seed"
127
+ | "isTool"
128
+ | "traceSpec"
129
+ | "isSanyReported"
130
+ | "isWarningEnabled"
131
+ | "version"
132
+ | "moduleOperators"
133
+ | "fingerprintPolynomial"
134
+ | "maxSetSize"
135
+ | "isLazyValueExpanded"
136
+ | "isViewPrinted"
137
+ >,
138
+ CliSettings {}
118
139
 
119
140
  interface NamedExpression {
120
141
  name: string;
@@ -200,14 +221,7 @@ const isLiteralDefinition = (definition: Definition) =>
200
221
 
201
222
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
202
223
  if (environment.constants.has(name)) return environment.constants.get(name);
203
- if (!isConstantLevel(definition, environment) || isLiteralDefinition(definition))
204
- return undefined;
205
- try {
206
- return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
207
- } catch (error) {
208
- if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
209
- throw error;
210
- }
224
+ return isLiteralDefinition(definition) ? undefined : getStartupValue(definition, environment);
211
225
  };
212
226
 
213
227
  const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
@@ -374,12 +388,20 @@ const getSpecification = (
374
388
  let isUntaggedFound = false;
375
389
  expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
376
390
  const conjunct = item.expression;
377
- if (isConstantTrue(item, environment, "spec")) return;
391
+ // TLC takes a state-level definition of the spec whole as an initial predicate.
392
+ const isInitial = item.path.some((name) => {
393
+ const expanded = getDefinition(name, environment);
394
+ return (
395
+ expanded?.kind === "Operator" &&
396
+ getLevel(expanded.body, undefined, environment) === VARIABLE_LEVEL
397
+ );
398
+ });
399
+ if (!isInitial && isConstantTrue(item, environment, "spec")) return;
378
400
  const variableIndex =
379
401
  conjunct.kind === "Identifier" && !isLocallyResolved(conjunct)
380
402
  ? environment.variableIndex.get(conjunct.name)
381
403
  : undefined;
382
- if (conjunct.kind === "Identifier" && variableIndex !== undefined) {
404
+ if (!isInitial && conjunct.kind === "Identifier" && variableIndex !== undefined) {
383
405
  const range = variableLocations[variableIndex].range;
384
406
  throw new TlaConfigError(
385
407
  `The operator ${conjunct.name}, which equals ${range ? formatRange(range) : conjunct.name},\ncannot be used as a spec`,
@@ -644,22 +666,28 @@ const getPredicate = (expression: Expression, environment: Environment) => {
644
666
  };
645
667
 
646
668
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
647
- named.flatMap((item) =>
648
- getConjuncts(item.expression, environment).map((expression) => {
649
- const variables =
650
- item.scope === undefined ? getReadVariables(expression, environment) : undefined;
651
- return {
652
- name: item.name,
653
- expression,
654
- scope: item.scope,
655
- variables,
656
- membership: getMembership(expression, variables, environment),
657
- predicate: getPredicate(item.expression, environment),
658
- };
659
- }),
660
- );
669
+ named.flatMap((item) => {
670
+ const predicate = getPredicate(item.expression, environment);
671
+ const isImpure =
672
+ item.scope === undefined && getReadVariables(predicate, environment) === undefined;
673
+ // TLC evaluates an invariant whole, so one that prints isn't split into conjuncts.
674
+ return (isImpure ? [predicate] : getConjuncts(item.expression, environment)).map(
675
+ (expression) => {
676
+ const variables =
677
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
678
+ return {
679
+ name: item.name,
680
+ expression,
681
+ scope: item.scope,
682
+ variables,
683
+ membership: getMembership(expression, variables, environment),
684
+ predicate,
685
+ };
686
+ },
687
+ );
688
+ });
661
689
 
662
- const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
690
+ const isUnchangedFor = (stateCheck: StateCheck, state: State, parent: Value[] | undefined) => {
663
691
  const variables = stateCheck.variables;
664
692
  if (!parent || !variables) return false;
665
693
  for (let index = 0; index < variables.length; index++) {
@@ -677,31 +705,42 @@ const isWideConfigValue = (value: ConfigValue): boolean =>
677
705
  ? WIDE_CHARACTER.test(value.value)
678
706
  : value.kind === "Set" && value.elements.some(isWideConfigValue);
679
707
 
680
- const isWideExpression = (expression: Expression): boolean =>
681
- (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
682
- (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
683
- getChildren(expression).some(isWideExpression);
708
+ const isWideExpression = (expression: Expression, checked: Set<Expression>): boolean => {
709
+ if (expression.kind === "Selection") {
710
+ if (checked.has(expression.expression)) return false;
711
+ checked.add(expression.expression);
712
+ }
713
+ return (
714
+ (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
715
+ (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
716
+ getChildren(expression).some((child) => isWideExpression(child, checked))
717
+ );
718
+ };
684
719
 
685
720
  // TLC fingerprints a string by the low byte of each character, so it merges states whose strings differ only above U+00FF.
686
- const hasWideString = (config: ModelConfig, environment: Environment) =>
687
- config.constants.some(
688
- (constant) =>
689
- isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
690
- ) ||
691
- [...environment.definitions.values()].some(
692
- (definition) =>
693
- isWideExpression(definition.body) ||
694
- (definition.kind === "Function" &&
695
- definition.bounds.some((bound) => isWideExpression(bound.set))),
721
+ const hasWideString = (config: ModelConfig, environment: Environment) => {
722
+ const checked = new Set<Expression>();
723
+ return (
724
+ config.constants.some(
725
+ (constant) =>
726
+ isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
727
+ ) ||
728
+ [...environment.definitions.values()].some(
729
+ (definition) =>
730
+ isWideExpression(definition.body, checked) ||
731
+ (definition.kind === "Function" &&
732
+ definition.bounds.some((bound) => isWideExpression(bound.set, checked))),
733
+ )
696
734
  );
735
+ };
697
736
 
698
737
  export interface Search {
699
738
  properties: Properties;
700
739
  toRecord: (state: Value[]) => Record<string, Value>;
701
740
  evaluateAlias: (
702
741
  alias: string,
703
- state: Value[],
704
- next: Value[] | undefined,
742
+ state: State,
743
+ next: State | undefined,
705
744
  isTool: boolean,
706
745
  ) => Record<string, Value>;
707
746
  spec: Specification;
@@ -726,22 +765,23 @@ export interface Search {
726
765
  }
727
766
  | undefined;
728
767
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
729
- getViolatedInvariants: (state: Value[]) => StateCheck[];
768
+ forEachViolatedInvariant: (state: Value[], onViolated: (invariant: StateCheck) => void) => void;
730
769
  checkReplayedInitialState: (
731
770
  state: Value[],
732
771
  tracing: Environment,
733
772
  addFingerprint: () => void,
734
- ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
773
+ onViolated: (violation: Pick<InitialStateViolation, "status" | "name">) => void,
774
+ ) => void;
735
775
  checkReplayedSuccessor: (
736
776
  state: Value[],
737
777
  next: Value[],
738
778
  tracing: Environment,
739
779
  addFingerprint: () => boolean,
740
780
  ) => boolean;
741
- satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
781
+ satisfiesConstraints: (state: State, parent?: Value[]) => boolean;
742
782
  findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
743
783
  findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
744
- satisfiesActionConstraints: (state: Value[], next: Value[]) => boolean;
784
+ satisfiesActionConstraints: (state: Value[], next: State) => boolean;
745
785
  getExcludingConstraints: (state: Value[], next: Value[]) => string[];
746
786
  trackStatePossible: (state: Value[]) => void;
747
787
  trackActionPossible: (state: Value[], next: Value[]) => void;
@@ -771,8 +811,8 @@ export const getIncompleteSuccessorMessage = (
771
811
 
772
812
  export const getContext = (
773
813
  environment: Environment,
774
- state: Value[] | undefined,
775
- next: Value[] | undefined,
814
+ state: State | undefined,
815
+ next: State | undefined,
776
816
  scope?: Scope,
777
817
  ) => ({ environment, scope, state, next });
778
818
 
@@ -805,7 +845,7 @@ const getExpectedBoolean = (expression: Expression, environment: Environment) =>
805
845
 
806
846
  const holdsAsConjunct = (check: StateCheck, context: Context) =>
807
847
  holdsLikeTlc(check.expression, context, (expression, environment) => {
808
- holdsLikeTlc(check.predicate, context);
848
+ if (check.predicate !== check.expression) holdsLikeTlc(check.predicate, context);
809
849
  return getExpectedBoolean(expression, environment);
810
850
  });
811
851
 
@@ -853,7 +893,12 @@ export const createCheckEnvironment = (
853
893
  isStringOrderFrozen = false,
854
894
  ) => {
855
895
  const order = createTlcOrder(options.source, options.loadModule);
856
- setStringOrder(order.getStringOrder(config));
896
+ setStringOrder(
897
+ order.getStringOrder(
898
+ config,
899
+ (options.runtimeInvariants ?? []).flatMap((invariant) => invariant.module ?? []),
900
+ ),
901
+ );
857
902
  setValueOptions(options);
858
903
  setFingerprintPolynomial(options.fingerprintPolynomial ?? 0);
859
904
  if (isStringOrderFrozen) freezeStringOrder();
@@ -875,6 +920,8 @@ export const createCheckEnvironment = (
875
920
  isWarningEnabled: options.isWarningEnabled,
876
921
  version: options.version,
877
922
  moduleOperators: options.moduleOperators,
923
+ readLine: options.readLine,
924
+ runtimeInvariants: options.runtimeInvariants,
878
925
  });
879
926
  return { order, specification };
880
927
  };
@@ -887,7 +934,13 @@ export const prepareSearch = (options: CheckOptions) => {
887
934
  const created = createCheckEnvironment(config, options, options.onPrint ?? console.log);
888
935
  const specification = created.specification;
889
936
  reportStartup(specification, config, options.onProgress);
890
- const environment = specification.environment;
937
+ const coverage =
938
+ options.coverage === undefined
939
+ ? undefined
940
+ : createCoverage(specification.environment.variables.length);
941
+ const environment = coverage
942
+ ? createCoverageEnvironment(specification.environment, coverage)
943
+ : specification.environment;
891
944
  let description: SpecDescription | undefined;
892
945
  const getDescription = () =>
893
946
  (description ??= getSpecDescription(config, environment, specification.instanceActions));
@@ -900,10 +953,75 @@ export const prepareSearch = (options: CheckOptions) => {
900
953
  () => created.order.getDeclarationOrder("variable"),
901
954
  options.onProgress,
902
955
  specification.moduleOperators,
956
+ specification.runtimeInvariants,
903
957
  );
904
- return { config, specification, environment, search, getDescription };
958
+ const getCoverage = () =>
959
+ coverage &&
960
+ getCoverageReport(
961
+ coverage,
962
+ environment,
963
+ specification.variableLocations,
964
+ search?.getTlcOrder() ?? [],
965
+ );
966
+ return { config, specification, environment, search, getDescription, coverage, getCoverage };
967
+ };
968
+
969
+ export interface CoveredAction extends SpecAction {
970
+ node: number;
971
+ }
972
+
973
+ export const STOP_WALK = new Error("The walk stopped");
974
+
975
+ export const addActionCoverage = (
976
+ coverage: Coverage,
977
+ environment: Environment,
978
+ description: SpecDescription,
979
+ ) => {
980
+ const addRelations = (kind: "init" | "next", actions: SpecAction[]) =>
981
+ actions.map((action): CoveredAction => ({
982
+ ...action,
983
+ node: addCoverageRelation(
984
+ coverage,
985
+ kind,
986
+ getCoverageLabel(action.name, action.expression, environment),
987
+ action.expression,
988
+ action.scope,
989
+ ),
990
+ }));
991
+ const inits = addRelations("init", description.inits);
992
+ const actions = addRelations("next", description.actions);
993
+ buildCoverage(coverage, environment, getPrimedRanges(actions, environment));
994
+ return { inits, actions };
905
995
  };
906
996
 
997
+ export const walkCoveredSuccessors = (
998
+ coverage: Coverage,
999
+ action: CoveredAction,
1000
+ state: Value[],
1001
+ environment: Environment,
1002
+ onState: (successor: Value[]) => void,
1003
+ onIncomplete = (partial: State, name: string | undefined): void => {
1004
+ throw createIncompleteSuccessorError(partial, name, environment);
1005
+ },
1006
+ generator?: SuccessorGenerator,
1007
+ ) =>
1008
+ walkSuccessors(
1009
+ action,
1010
+ action.node,
1011
+ state,
1012
+ environment,
1013
+ (successor) => {
1014
+ coverage.primary[action.node]++;
1015
+ onState(successor);
1016
+ },
1017
+ (partial) => {
1018
+ coverage.primary[action.node]++;
1019
+ onIncomplete(partial, action.name);
1020
+ return true;
1021
+ },
1022
+ generator,
1023
+ );
1024
+
907
1025
  export const reportAssumptionViolation = (
908
1026
  assumptions: Assumption[],
909
1027
  environment: Environment,
@@ -940,6 +1058,7 @@ export const createSearch = (
940
1058
  getVariableOrder: () => string[],
941
1059
  onProgress?: CheckOptions["onProgress"],
942
1060
  moduleOperators: ResolvedModuleOperator[] = [],
1061
+ runtimeInvariants: RuntimeInvariant[] = [],
943
1062
  ): Search | undefined => {
944
1063
  const getModuleOperators = (kind: ResolvedModuleOperator["kind"]) =>
945
1064
  moduleOperators
@@ -968,12 +1087,12 @@ export const createSearch = (
968
1087
  text: `Implied-temporal checking is a tautology.\nThe temporal formula ${live} at ${formatRange(liveRange)} equals\nthe fairness constraints of the behavior specification ${specName} at ${formatRange(specRange)}.\nTherefore, checking whether ${specName} => ${live} using TLC will never result in a violation of ${live}.`,
969
1088
  });
970
1089
  }
971
- const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
972
- const invariantPredicates = [
973
- ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
974
- ];
1090
+ const checkedInvariants = getStateChecks(
1091
+ [...configInvariants, ...properties.invariants],
1092
+ environment,
1093
+ );
975
1094
  const isCheckingBehaviors =
976
- invariants.length > 0 ||
1095
+ checkedInvariants.length > 0 ||
977
1096
  properties.actionProperties.length > 0 ||
978
1097
  properties.liveness.length > 0;
979
1098
  if (
@@ -991,6 +1110,22 @@ export const createSearch = (
991
1110
  if (spec.next === undefined && isCheckingBehaviors) {
992
1111
  throw new TlaConfigError("The configuration file did not specify the next state predicate.");
993
1112
  }
1113
+ const runtimeChecks = getStateChecks(
1114
+ runtimeInvariants.map((invariant) => {
1115
+ const definition = getDefinition(invariant.name, environment);
1116
+ return {
1117
+ name: invariant.name,
1118
+ expression:
1119
+ definition?.kind === "Operator" ? definition.body : createIdentifier(invariant.name),
1120
+ scope: undefined,
1121
+ };
1122
+ }),
1123
+ environment,
1124
+ );
1125
+ const invariants = [...checkedInvariants, ...runtimeChecks];
1126
+ const invariantPredicates = [
1127
+ ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
1128
+ ];
994
1129
  const namedConstraints = getNamedExpressions(
995
1130
  "constraint",
996
1131
  [...config.constraints, ...getModuleOperators("constraint").map((operator) => operator.name)],
@@ -1015,8 +1150,20 @@ export const createSearch = (
1015
1150
  ...getCoveredChecks("invariant", configInvariants),
1016
1151
  ...getCoveredChecks("invariant", properties.invariants, false),
1017
1152
  ];
1153
+ const coveredInvariantChecks = new Map(
1154
+ [...configInvariants, ...properties.invariants].map((item, index) => [
1155
+ getPredicate(item.expression, environment),
1156
+ coveredInvariants[index],
1157
+ ]),
1158
+ );
1018
1159
  const coveredActionConstraints = getCoveredChecks("constraint", actionConstraints);
1019
1160
  const coveredConstraints = getCoveredChecks("constraint", namedConstraints);
1161
+ const coveredConstraintChecks = new Map(
1162
+ coveredConstraints.map((check) => [check.expression, check]),
1163
+ );
1164
+ const constraintPredicates = [
1165
+ ...new Map(constraints.map((constraint) => [constraint.predicate, constraint])).values(),
1166
+ ];
1020
1167
  const coveredInitialPredicates = getCoveredChecks("implied", properties.initialPredicates, false);
1021
1168
  const coveredActionProperties = getCoveredChecks(
1022
1169
  "implied",
@@ -1026,8 +1173,8 @@ export const createSearch = (
1026
1173
  const evaluateCovered = (
1027
1174
  covered: Coverage,
1028
1175
  check: CoveredCheck,
1029
- state: Value[],
1030
- next: Value[] | undefined,
1176
+ state: State,
1177
+ next: State | undefined,
1031
1178
  ) => {
1032
1179
  try {
1033
1180
  return runAtCoverageNode(covered, check.node, () =>
@@ -1037,10 +1184,15 @@ export const createSearch = (
1037
1184
  return undefined;
1038
1185
  }
1039
1186
  };
1040
- const isCoveredHeld = (checks: CoveredCheck[], state: Value[], next?: Value[]) =>
1041
- coverage !== undefined &&
1042
- checks.every((check) => evaluateCovered(coverage, check, state, next) === true);
1043
- const satisfiesCovered = (checks: CoveredCheck[], state: Value[], next?: Value[]) => {
1187
+ const holdsReplayed = (
1188
+ covered: CoveredCheck | undefined,
1189
+ expression: Expression,
1190
+ context: Context,
1191
+ ) =>
1192
+ coverage && covered
1193
+ ? runAtCoverageNode(coverage, covered.node, () => holdsLikeTlc(covered.expression, context))
1194
+ : holdsLikeTlc(expression, context);
1195
+ const satisfiesCovered = (checks: CoveredCheck[], state: State, next?: State) => {
1044
1196
  if (!coverage) return undefined;
1045
1197
  for (const check of checks) {
1046
1198
  const value = evaluateCovered(coverage, check, state, next);
@@ -1095,9 +1247,15 @@ export const createSearch = (
1095
1247
  };
1096
1248
  const getViewValue = (expression: Expression, state: Value[]) =>
1097
1249
  evaluate(expression, getContext(environment, state, undefined));
1250
+ const getRepresentativeState = (state: Value[]) => {
1251
+ // TLC's TLCStateMut#fingerPrint deep-normalizes a state before it evaluates the view.
1252
+ if (view !== undefined) state.forEach(markNormalized);
1253
+ return symmetryGroup === undefined
1254
+ ? state
1255
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
1256
+ };
1098
1257
  const getTlcStateFingerprint = (state: Value[]) => {
1099
- const representative =
1100
- symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, getTlcOrder());
1258
+ const representative = getRepresentativeState(state);
1101
1259
  return getTlcFingerprint(
1102
1260
  view === undefined
1103
1261
  ? getTlcOrder().map((index) => representative[index])
@@ -1105,15 +1263,16 @@ export const createSearch = (
1105
1263
  );
1106
1264
  };
1107
1265
  const findFailedInitialPredicate = (state: Value[]) =>
1108
- isCoveredHeld(coveredInitialPredicates, state)
1109
- ? undefined
1110
- : properties.initialPredicates.find(
1111
- (predicate) =>
1112
- !holdsLikeTlc(
1113
- predicate.expression,
1114
- getContext(environment, state, undefined, predicate.scope),
1115
- ),
1116
- );
1266
+ properties.initialPredicates.find((predicate, index) => {
1267
+ const value =
1268
+ coverage && evaluateCovered(coverage, coveredInitialPredicates[index], state, undefined);
1269
+ return typeof value === "boolean"
1270
+ ? !value
1271
+ : !holdsLikeTlc(
1272
+ predicate.expression,
1273
+ getContext(environment, state, undefined, predicate.scope),
1274
+ );
1275
+ });
1117
1276
  const violatingStates = new WeakSet<Value[]>();
1118
1277
  const isViolated = (invariant: StateCheck, state: Value[], parent: Value[] | undefined) => {
1119
1278
  const checkedParent = parent && !violatingStates.has(parent) ? parent : undefined;
@@ -1137,6 +1296,21 @@ export const createSearch = (
1137
1296
  );
1138
1297
  }
1139
1298
  };
1299
+ const isPredicateViolated = (
1300
+ predicate: StateCheck,
1301
+ state: Value[],
1302
+ parent: Value[] | undefined,
1303
+ ) => {
1304
+ const covered = coveredInvariantChecks.get(predicate.predicate);
1305
+ const value =
1306
+ coverage && covered ? evaluateCovered(coverage, covered, state, undefined) : undefined;
1307
+ return typeof value === "boolean"
1308
+ ? !value
1309
+ : invariants.some(
1310
+ (invariant) =>
1311
+ invariant.predicate === predicate.predicate && isViolated(invariant, state, parent),
1312
+ );
1313
+ };
1140
1314
  const isFingerprintedLikeTlc = hasWideString(config, environment);
1141
1315
  runtime.getFingerprint = getTlcStateFingerprint;
1142
1316
  const findUnwitnessedPossible = () => {
@@ -1172,7 +1346,7 @@ export const createSearch = (
1172
1346
  )
1173
1347
  .join("")
1174
1348
  : prettyPrint(formatValue(getViewValue(expression, state)));
1175
- const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: Value[]) =>
1349
+ const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: State) =>
1176
1350
  holdsLikeTlc(
1177
1351
  constraint.expression,
1178
1352
  getContext(environment, state, next),
@@ -1186,19 +1360,22 @@ export const createSearch = (
1186
1360
  ? record
1187
1361
  : setViewText(record, () => getViewText(view.expression, state));
1188
1362
  };
1363
+ runtime.toRecord = toRecord;
1189
1364
  return {
1190
1365
  properties,
1191
1366
  spec,
1192
1367
  toRecord,
1193
1368
  evaluateAlias: (alias, state, next, isTool) => {
1369
+ const getStateRecord = () =>
1370
+ toRecord(state.map((value) => value ?? createModelValue("null")));
1194
1371
  try {
1195
1372
  getConfigDefinition("alias", alias, environment);
1196
1373
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
1197
1374
  const record = toAliasRecord(value);
1198
- return record === undefined ? toRecord(state) : setAliasName(record, alias);
1375
+ return record === undefined ? getStateRecord() : setAliasName(record, alias);
1199
1376
  } catch (error) {
1200
1377
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1201
- return { ...toRecord(state), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1378
+ return { ...getStateRecord(), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1202
1379
  }
1203
1380
  },
1204
1381
  isSymmetric: symmetryGroup !== undefined,
@@ -1282,64 +1459,81 @@ export const createSearch = (
1282
1459
  },
1283
1460
  getFingerprintState: (state) => {
1284
1461
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1285
- const representative =
1286
- symmetryGroup === undefined
1287
- ? state
1288
- : getRepresentative(state, symmetryGroup, getTlcOrder());
1462
+ const representative = getRepresentativeState(state);
1289
1463
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
1290
1464
  },
1291
1465
  findViolatedInvariant: (state, parent) => {
1292
- if (isCoveredHeld(coveredInvariants, state)) return undefined;
1293
- const violated = invariants.find((invariant) => isViolated(invariant, state, parent));
1466
+ const violated =
1467
+ coverage === undefined
1468
+ ? invariants.find((invariant) => isViolated(invariant, state, parent))
1469
+ : invariantPredicates.find((predicate) => isPredicateViolated(predicate, state, parent));
1294
1470
  if (violated) violatingStates.add(state);
1295
1471
  return violated;
1296
1472
  },
1297
- getViolatedInvariants: (state) => {
1298
- const violated = invariantPredicates.filter((predicate) =>
1299
- invariants.some(
1300
- (invariant) =>
1301
- invariant.predicate === predicate.predicate && isViolated(invariant, state, undefined),
1473
+ forEachViolatedInvariant: (state, onViolated) => {
1474
+ for (const predicate of invariantPredicates) {
1475
+ if (!isPredicateViolated(predicate, state, undefined)) continue;
1476
+ violatingStates.add(state);
1477
+ onViolated(predicate);
1478
+ }
1479
+ },
1480
+ checkReplayedInitialState: (state, tracing, addFingerprint, onViolated) => {
1481
+ const holdsIn = (
1482
+ covered: CoveredCheck | undefined,
1483
+ expression: Expression,
1484
+ scope: Scope | undefined,
1485
+ ) => holdsReplayed(covered, expression, getContext(tracing, state, undefined, scope));
1486
+ const isInModel = constraintPredicates.every((constraint) =>
1487
+ holdsIn(
1488
+ coveredConstraintChecks.get(constraint.predicate),
1489
+ constraint.predicate,
1490
+ constraint.scope,
1302
1491
  ),
1303
1492
  );
1304
- if (violated.length > 0) violatingStates.add(state);
1305
- return violated;
1306
- },
1307
- checkReplayedInitialState: (state, tracing, addFingerprint) => {
1308
- const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1309
- holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1310
- if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1311
- addFingerprint();
1493
+ if (isInModel) addFingerprint();
1494
+ for (const invariant of invariantPredicates) {
1495
+ const covered = coveredInvariantChecks.get(invariant.predicate);
1496
+ if (holdsIn(covered, invariant.predicate, invariant.scope)) continue;
1497
+ onViolated({ status: "invariant-violation", name: invariant.name });
1312
1498
  }
1313
- const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1314
- if (invariant) return { status: "invariant-violation", name: invariant.name };
1315
1499
  const predicate = properties.initialPredicates.find(
1316
- (check) => !holdsIn(check.expression, check.scope),
1500
+ (check, index) => !holdsIn(coveredInitialPredicates[index], check.expression, check.scope),
1317
1501
  );
1318
- return predicate && { status: "liveness-violation", name: predicate.name };
1502
+ if (predicate) onViolated({ status: "liveness-violation", name: predicate.name });
1319
1503
  },
1320
1504
  checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1321
1505
  const isInModel =
1322
- constraints.every((constraint) =>
1323
- holdsLikeTlc(
1506
+ constraintPredicates.every((constraint) =>
1507
+ holdsReplayed(
1508
+ coveredConstraintChecks.get(constraint.predicate),
1324
1509
  constraint.predicate,
1325
1510
  getContext(tracing, next, undefined, constraint.scope),
1326
1511
  ),
1327
1512
  ) &&
1328
- actionConstraints.every((constraint) =>
1329
- holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
1513
+ actionConstraints.every((constraint, index) =>
1514
+ holdsReplayed(
1515
+ coveredActionConstraints[index],
1516
+ constraint.expression,
1517
+ getContext(tracing, state, next, constraint.scope),
1518
+ ),
1330
1519
  );
1331
1520
  // TLC checks the invariants of a successor it has not seen, even outside the model.
1332
1521
  const isUnseen = isInModel ? addFingerprint() : true;
1333
1522
  return (
1334
1523
  (!isUnseen ||
1335
1524
  invariantPredicates.every((invariant) =>
1336
- holdsLikeTlc(
1525
+ holdsReplayed(
1526
+ coveredInvariantChecks.get(invariant.predicate),
1337
1527
  invariant.predicate,
1338
1528
  getContext(tracing, next, undefined, invariant.scope),
1339
1529
  ),
1340
1530
  )) &&
1341
- actionProperties.every((property) =>
1342
- holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
1531
+ actionProperties.every((property, index) =>
1532
+ holdsReplayed(
1533
+ coveredActionProperties[index],
1534
+ property.box,
1535
+ getContext(tracing, state, next, property.scope),
1536
+ ),
1343
1537
  )
1344
1538
  );
1345
1539
  },
@@ -1352,31 +1546,32 @@ export const createSearch = (
1352
1546
  ),
1353
1547
  findFailedInitialPredicate,
1354
1548
  findViolatedActionProperty: (state, next) =>
1355
- isCoveredHeld(coveredActionProperties, state, next)
1356
- ? undefined
1357
- : actionProperties.find((property) => {
1358
- try {
1359
- return (
1360
- !holdsLikeTlc(
1361
- property.action,
1362
- getContext(environment, state, next, property.scope),
1363
- () =>
1364
- `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1365
- ) &&
1366
- !holds(
1367
- property.unchanged,
1368
- getContext(environment, state, next, property.scope),
1369
- "a subscript",
1370
- )
1371
- );
1372
- } catch (error) {
1373
- throw withHeadline(
1374
- withNextStateExitCode(error),
1375
- MESSAGE_CODE.actionPropertyEvaluationFailed,
1376
- `Evaluating action property ${property.name} failed.`,
1377
- );
1378
- }
1379
- }),
1549
+ actionProperties.find((property, index) => {
1550
+ const value =
1551
+ coverage && evaluateCovered(coverage, coveredActionProperties[index], state, next);
1552
+ if (typeof value === "boolean") return !value;
1553
+ try {
1554
+ return (
1555
+ !holdsLikeTlc(
1556
+ property.action,
1557
+ getContext(environment, state, next, property.scope),
1558
+ () =>
1559
+ `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1560
+ ) &&
1561
+ !holds(
1562
+ property.unchanged,
1563
+ getContext(environment, state, next, property.scope),
1564
+ "a subscript",
1565
+ )
1566
+ );
1567
+ } catch (error) {
1568
+ throw withHeadline(
1569
+ withNextStateExitCode(error),
1570
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
1571
+ `Evaluating action property ${property.name} failed.`,
1572
+ );
1573
+ }
1574
+ }),
1380
1575
  satisfiesActionConstraints: (state, next) =>
1381
1576
  satisfiesCovered(coveredActionConstraints, state, next) ??
1382
1577
  actionConstraints.every((constraint) => holdsActionConstraint(constraint, state, next)),