tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e5c8dc315

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 (263) 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 +78 -78
  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 -93
  29. package/src/check.ts +518 -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 +18 -4
  33. package/src/cli/tlc.ts +18 -12
  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 +155 -66
  40. package/src/errors.ts +7 -0
  41. package/src/evaluate.ts +424 -135
  42. package/src/exit-codes.ts +28 -14
  43. package/src/instances.ts +152 -25
  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 +179 -60
  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/ackermannize-bv-tactic.ts +3 -2
  67. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  68. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  69. package/src/prover/smt/solver/asserted-formulas.ts +171 -58
  70. package/src/prover/smt/solver/ast-lt.ts +1 -1
  71. package/src/prover/smt/solver/ast.ts +66 -14
  72. package/src/prover/smt/solver/auf-solver.ts +23 -12
  73. package/src/prover/smt/solver/bit-blast-tactic.ts +28 -2
  74. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  75. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  76. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  77. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  78. package/src/prover/smt/solver/bv1-blast.ts +1 -1
  79. package/src/prover/smt/solver/card2bv.ts +35 -18
  80. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  81. package/src/prover/smt/solver/context.ts +84 -15
  82. package/src/prover/smt/solver/ctx-simplify.ts +9 -4
  83. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  84. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  85. package/src/prover/smt/solver/diff-neq.ts +9 -8
  86. package/src/prover/smt/solver/dt2bv-tactic.ts +66 -28
  87. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  88. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  89. package/src/prover/smt/solver/elim-uncnstr.ts +31 -28
  90. package/src/prover/smt/solver/eq2bv-tactic.ts +15 -6
  91. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  92. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  93. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  94. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  95. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  96. package/src/prover/smt/solver/euf/mam.ts +1 -5
  97. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  98. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  99. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  100. package/src/prover/smt/solver/factor.ts +36 -14
  101. package/src/prover/smt/solver/fd-solver.ts +608 -139
  102. package/src/prover/smt/solver/fix-dl-var.ts +2 -3
  103. package/src/prover/smt/solver/fm-tactic.ts +9 -7
  104. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  105. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  106. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  107. package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -1
  108. package/src/prover/smt/solver/goal.ts +6 -3
  109. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  110. package/src/prover/smt/solver/hashtable.ts +4 -0
  111. package/src/prover/smt/solver/internalizer.ts +1 -1
  112. package/src/prover/smt/solver/lia2pb.ts +1 -1
  113. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  114. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  115. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  116. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  117. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  118. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  119. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  120. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  121. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  122. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  123. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  124. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  125. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  126. package/src/prover/smt/solver/maxcore.ts +2 -1
  127. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  128. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  129. package/src/prover/smt/solver/model-checker.ts +1 -1
  130. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  131. package/src/prover/smt/solver/model-generator.ts +85 -43
  132. package/src/prover/smt/solver/mpf.ts +2 -4
  133. package/src/prover/smt/solver/mus.ts +2 -3
  134. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  135. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  136. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  137. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  138. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  139. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  140. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  141. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  142. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  143. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  144. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  145. package/src/prover/smt/solver/nlqsat.ts +2 -1
  146. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  147. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  148. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  149. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  150. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  151. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  152. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  153. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  154. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  155. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  156. package/src/prover/smt/solver/nnf.ts +6 -2
  157. package/src/prover/smt/solver/normalize-bounds.ts +2 -2
  158. package/src/prover/smt/solver/occf.ts +1 -1
  159. package/src/prover/smt/solver/opt-context.ts +21 -7
  160. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  161. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  162. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  163. package/src/prover/smt/solver/opt-solver.ts +10 -6
  164. package/src/prover/smt/solver/optsmt.ts +1 -1
  165. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  166. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  167. package/src/prover/smt/solver/pb2bv-tactic.ts +9 -3
  168. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  169. package/src/prover/smt/solver/probes.ts +88 -23
  170. package/src/prover/smt/solver/proto-model.ts +8 -8
  171. package/src/prover/smt/solver/purify-arith.ts +51 -49
  172. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  173. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  174. package/src/prover/smt/solver/qe-lite.ts +2 -2
  175. package/src/prover/smt/solver/qe.ts +3 -2
  176. package/src/prover/smt/solver/qsat.ts +23 -8
  177. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  178. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  179. package/src/prover/smt/solver/reduce-args.ts +2 -2
  180. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  181. package/src/prover/smt/solver/rewriter.ts +31 -25
  182. package/src/prover/smt/solver/rlimit.ts +7 -3
  183. package/src/prover/smt/solver/sat/config.ts +1 -1
  184. package/src/prover/smt/solver/sat/goal2sat.ts +75 -12
  185. package/src/prover/smt/solver/sat/inc-sat-solver.ts +149 -47
  186. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  187. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  188. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  189. package/src/prover/smt/solver/sat/sat-tactic.ts +54 -25
  190. package/src/prover/smt/solver/sat/sat2goal.ts +75 -50
  191. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  192. package/src/prover/smt/solver/sat/solver.ts +27 -47
  193. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  194. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  195. package/src/prover/smt/solver/seq-derive.ts +2 -2
  196. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  197. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  198. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  199. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  200. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  201. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  202. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  203. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  204. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  205. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  206. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  207. package/src/prover/smt/solver/smt-setup.ts +106 -13
  208. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  209. package/src/prover/smt/solver/smtlib-script.ts +718 -213
  210. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  211. package/src/prover/smt/solver/solver.ts +18 -4
  212. package/src/prover/smt/solver/tactic.ts +389 -199
  213. package/src/prover/smt/solver/theory-bv.ts +13 -3
  214. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  215. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  216. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  217. package/src/prover/smt/solver/theory-lra-propagate.ts +12 -3
  218. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  219. package/src/prover/smt/solver/theory-lra.ts +1 -1
  220. package/src/prover/smt/solver/theory-pb.ts +24 -7
  221. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  222. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  223. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  224. package/src/prover/smt/solver/tseitin-cnf.ts +15 -5
  225. package/src/prover/tlapm/cache.ts +8 -8
  226. package/src/prover/zenon/index-table.ts +5 -2
  227. package/src/prover/zenon/isar-case.ts +1 -1
  228. package/src/prover/zenon/isar.ts +2 -2
  229. package/src/prover/zenon/phrase.ts +1 -1
  230. package/src/resolve.ts +1311 -268
  231. package/src/runtime.ts +21 -2
  232. package/src/sany/builtins.ts +10 -10
  233. package/src/sany/generation.ts +5 -15
  234. package/src/sany/generator-def-entries.ts +123 -36
  235. package/src/sany/generator-definitions.ts +5 -3
  236. package/src/sany/generator-expressions.ts +60 -37
  237. package/src/sany/generator-proofs.ts +19 -12
  238. package/src/sany/generator.ts +12 -6
  239. package/src/sany/lexer.ts +15 -7
  240. package/src/sany/modules.ts +4 -2
  241. package/src/sany/nodes.ts +1 -1
  242. package/src/sany/selectors.ts +12 -6
  243. package/src/sany/xml.ts +2 -3
  244. package/src/search.ts +321 -135
  245. package/src/simulate.ts +247 -185
  246. package/src/spec-description.ts +15 -7
  247. package/src/standard-definitions.ts +1 -0
  248. package/src/standard-modules.ts +56 -22
  249. package/src/subexpressions.ts +666 -147
  250. package/src/successors.ts +50 -20
  251. package/src/symmetry.ts +2 -1
  252. package/src/tlc/jar-data.ts +10 -0
  253. package/src/tlc/messages.ts +3 -3
  254. package/src/tlc/order.ts +14 -3
  255. package/src/tlc/random.ts +2 -1
  256. package/src/tlc/replay.ts +147 -46
  257. package/src/tlc/tlc-operators.ts +10 -8
  258. package/src/tlc/tlcext-operators.ts +44 -15
  259. package/src/tlc/trace-spec.ts +9 -22
  260. package/src/trace-liveness.ts +529 -0
  261. package/src/typed-tier.ts +52 -31
  262. package/src/typescript/types.ts +2 -2
  263. 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,8 +108,9 @@ import {
95
108
  type Value,
96
109
  } from "./values";
97
110
 
98
- export interface StandardInput {
111
+ export interface CliSettings {
99
112
  readLine?: () => string | undefined;
113
+ runtimeInvariants?: RuntimeInvariant[];
100
114
  }
101
115
 
102
116
  interface EnvironmentSettings
@@ -121,7 +135,7 @@ interface EnvironmentSettings
121
135
  | "isLazyValueExpanded"
122
136
  | "isViewPrinted"
123
137
  >,
124
- StandardInput {}
138
+ CliSettings {}
125
139
 
126
140
  interface NamedExpression {
127
141
  name: string;
@@ -207,14 +221,7 @@ const isLiteralDefinition = (definition: Definition) =>
207
221
 
208
222
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
209
223
  if (environment.constants.has(name)) return environment.constants.get(name);
210
- if (!isConstantLevel(definition, environment) || isLiteralDefinition(definition))
211
- return undefined;
212
- try {
213
- return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
214
- } catch (error) {
215
- if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
216
- throw error;
217
- }
224
+ return isLiteralDefinition(definition) ? undefined : getStartupValue(definition, environment);
218
225
  };
219
226
 
220
227
  const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
@@ -381,12 +388,20 @@ const getSpecification = (
381
388
  let isUntaggedFound = false;
382
389
  expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
383
390
  const conjunct = item.expression;
384
- 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;
385
400
  const variableIndex =
386
401
  conjunct.kind === "Identifier" && !isLocallyResolved(conjunct)
387
402
  ? environment.variableIndex.get(conjunct.name)
388
403
  : undefined;
389
- if (conjunct.kind === "Identifier" && variableIndex !== undefined) {
404
+ if (!isInitial && conjunct.kind === "Identifier" && variableIndex !== undefined) {
390
405
  const range = variableLocations[variableIndex].range;
391
406
  throw new TlaConfigError(
392
407
  `The operator ${conjunct.name}, which equals ${range ? formatRange(range) : conjunct.name},\ncannot be used as a spec`,
@@ -651,22 +666,28 @@ const getPredicate = (expression: Expression, environment: Environment) => {
651
666
  };
652
667
 
653
668
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
654
- named.flatMap((item) =>
655
- getConjuncts(item.expression, environment).map((expression) => {
656
- const variables =
657
- item.scope === undefined ? getReadVariables(expression, environment) : undefined;
658
- return {
659
- name: item.name,
660
- expression,
661
- scope: item.scope,
662
- variables,
663
- membership: getMembership(expression, variables, environment),
664
- predicate: getPredicate(item.expression, environment),
665
- };
666
- }),
667
- );
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
+ });
668
689
 
669
- const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
690
+ const isUnchangedFor = (stateCheck: StateCheck, state: State, parent: Value[] | undefined) => {
670
691
  const variables = stateCheck.variables;
671
692
  if (!parent || !variables) return false;
672
693
  for (let index = 0; index < variables.length; index++) {
@@ -684,31 +705,42 @@ const isWideConfigValue = (value: ConfigValue): boolean =>
684
705
  ? WIDE_CHARACTER.test(value.value)
685
706
  : value.kind === "Set" && value.elements.some(isWideConfigValue);
686
707
 
687
- const isWideExpression = (expression: Expression): boolean =>
688
- (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
689
- (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
690
- 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
+ };
691
719
 
692
720
  // TLC fingerprints a string by the low byte of each character, so it merges states whose strings differ only above U+00FF.
693
- const hasWideString = (config: ModelConfig, environment: Environment) =>
694
- config.constants.some(
695
- (constant) =>
696
- isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
697
- ) ||
698
- [...environment.definitions.values()].some(
699
- (definition) =>
700
- isWideExpression(definition.body) ||
701
- (definition.kind === "Function" &&
702
- 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
+ )
703
734
  );
735
+ };
704
736
 
705
737
  export interface Search {
706
738
  properties: Properties;
707
739
  toRecord: (state: Value[]) => Record<string, Value>;
708
740
  evaluateAlias: (
709
741
  alias: string,
710
- state: Value[],
711
- next: Value[] | undefined,
742
+ state: State,
743
+ next: State | undefined,
712
744
  isTool: boolean,
713
745
  ) => Record<string, Value>;
714
746
  spec: Specification;
@@ -733,22 +765,23 @@ export interface Search {
733
765
  }
734
766
  | undefined;
735
767
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
736
- getViolatedInvariants: (state: Value[]) => StateCheck[];
768
+ forEachViolatedInvariant: (state: Value[], onViolated: (invariant: StateCheck) => void) => void;
737
769
  checkReplayedInitialState: (
738
770
  state: Value[],
739
771
  tracing: Environment,
740
772
  addFingerprint: () => void,
741
- ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
773
+ onViolated: (violation: Pick<InitialStateViolation, "status" | "name">) => void,
774
+ ) => void;
742
775
  checkReplayedSuccessor: (
743
776
  state: Value[],
744
777
  next: Value[],
745
778
  tracing: Environment,
746
779
  addFingerprint: () => boolean,
747
780
  ) => boolean;
748
- satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
781
+ satisfiesConstraints: (state: State, parent?: Value[]) => boolean;
749
782
  findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
750
783
  findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
751
- satisfiesActionConstraints: (state: Value[], next: Value[]) => boolean;
784
+ satisfiesActionConstraints: (state: Value[], next: State) => boolean;
752
785
  getExcludingConstraints: (state: Value[], next: Value[]) => string[];
753
786
  trackStatePossible: (state: Value[]) => void;
754
787
  trackActionPossible: (state: Value[], next: Value[]) => void;
@@ -778,8 +811,8 @@ export const getIncompleteSuccessorMessage = (
778
811
 
779
812
  export const getContext = (
780
813
  environment: Environment,
781
- state: Value[] | undefined,
782
- next: Value[] | undefined,
814
+ state: State | undefined,
815
+ next: State | undefined,
783
816
  scope?: Scope,
784
817
  ) => ({ environment, scope, state, next });
785
818
 
@@ -812,7 +845,7 @@ const getExpectedBoolean = (expression: Expression, environment: Environment) =>
812
845
 
813
846
  const holdsAsConjunct = (check: StateCheck, context: Context) =>
814
847
  holdsLikeTlc(check.expression, context, (expression, environment) => {
815
- holdsLikeTlc(check.predicate, context);
848
+ if (check.predicate !== check.expression) holdsLikeTlc(check.predicate, context);
816
849
  return getExpectedBoolean(expression, environment);
817
850
  });
818
851
 
@@ -860,7 +893,12 @@ export const createCheckEnvironment = (
860
893
  isStringOrderFrozen = false,
861
894
  ) => {
862
895
  const order = createTlcOrder(options.source, options.loadModule);
863
- setStringOrder(order.getStringOrder(config));
896
+ setStringOrder(
897
+ order.getStringOrder(
898
+ config,
899
+ (options.runtimeInvariants ?? []).flatMap((invariant) => invariant.module ?? []),
900
+ ),
901
+ );
864
902
  setValueOptions(options);
865
903
  setFingerprintPolynomial(options.fingerprintPolynomial ?? 0);
866
904
  if (isStringOrderFrozen) freezeStringOrder();
@@ -883,6 +921,7 @@ export const createCheckEnvironment = (
883
921
  version: options.version,
884
922
  moduleOperators: options.moduleOperators,
885
923
  readLine: options.readLine,
924
+ runtimeInvariants: options.runtimeInvariants,
886
925
  });
887
926
  return { order, specification };
888
927
  };
@@ -895,7 +934,13 @@ export const prepareSearch = (options: CheckOptions) => {
895
934
  const created = createCheckEnvironment(config, options, options.onPrint ?? console.log);
896
935
  const specification = created.specification;
897
936
  reportStartup(specification, config, options.onProgress);
898
- 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;
899
944
  let description: SpecDescription | undefined;
900
945
  const getDescription = () =>
901
946
  (description ??= getSpecDescription(config, environment, specification.instanceActions));
@@ -908,10 +953,75 @@ export const prepareSearch = (options: CheckOptions) => {
908
953
  () => created.order.getDeclarationOrder("variable"),
909
954
  options.onProgress,
910
955
  specification.moduleOperators,
956
+ specification.runtimeInvariants,
911
957
  );
912
- 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 };
913
967
  };
914
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 };
995
+ };
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
+
915
1025
  export const reportAssumptionViolation = (
916
1026
  assumptions: Assumption[],
917
1027
  environment: Environment,
@@ -948,6 +1058,7 @@ export const createSearch = (
948
1058
  getVariableOrder: () => string[],
949
1059
  onProgress?: CheckOptions["onProgress"],
950
1060
  moduleOperators: ResolvedModuleOperator[] = [],
1061
+ runtimeInvariants: RuntimeInvariant[] = [],
951
1062
  ): Search | undefined => {
952
1063
  const getModuleOperators = (kind: ResolvedModuleOperator["kind"]) =>
953
1064
  moduleOperators
@@ -976,12 +1087,12 @@ export const createSearch = (
976
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}.`,
977
1088
  });
978
1089
  }
979
- const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
980
- const invariantPredicates = [
981
- ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
982
- ];
1090
+ const checkedInvariants = getStateChecks(
1091
+ [...configInvariants, ...properties.invariants],
1092
+ environment,
1093
+ );
983
1094
  const isCheckingBehaviors =
984
- invariants.length > 0 ||
1095
+ checkedInvariants.length > 0 ||
985
1096
  properties.actionProperties.length > 0 ||
986
1097
  properties.liveness.length > 0;
987
1098
  if (
@@ -999,6 +1110,22 @@ export const createSearch = (
999
1110
  if (spec.next === undefined && isCheckingBehaviors) {
1000
1111
  throw new TlaConfigError("The configuration file did not specify the next state predicate.");
1001
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
+ ];
1002
1129
  const namedConstraints = getNamedExpressions(
1003
1130
  "constraint",
1004
1131
  [...config.constraints, ...getModuleOperators("constraint").map((operator) => operator.name)],
@@ -1023,8 +1150,20 @@ export const createSearch = (
1023
1150
  ...getCoveredChecks("invariant", configInvariants),
1024
1151
  ...getCoveredChecks("invariant", properties.invariants, false),
1025
1152
  ];
1153
+ const coveredInvariantChecks = new Map(
1154
+ [...configInvariants, ...properties.invariants].map((item, index) => [
1155
+ getPredicate(item.expression, environment),
1156
+ coveredInvariants[index],
1157
+ ]),
1158
+ );
1026
1159
  const coveredActionConstraints = getCoveredChecks("constraint", actionConstraints);
1027
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
+ ];
1028
1167
  const coveredInitialPredicates = getCoveredChecks("implied", properties.initialPredicates, false);
1029
1168
  const coveredActionProperties = getCoveredChecks(
1030
1169
  "implied",
@@ -1034,8 +1173,8 @@ export const createSearch = (
1034
1173
  const evaluateCovered = (
1035
1174
  covered: Coverage,
1036
1175
  check: CoveredCheck,
1037
- state: Value[],
1038
- next: Value[] | undefined,
1176
+ state: State,
1177
+ next: State | undefined,
1039
1178
  ) => {
1040
1179
  try {
1041
1180
  return runAtCoverageNode(covered, check.node, () =>
@@ -1045,10 +1184,15 @@ export const createSearch = (
1045
1184
  return undefined;
1046
1185
  }
1047
1186
  };
1048
- const isCoveredHeld = (checks: CoveredCheck[], state: Value[], next?: Value[]) =>
1049
- coverage !== undefined &&
1050
- checks.every((check) => evaluateCovered(coverage, check, state, next) === true);
1051
- 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) => {
1052
1196
  if (!coverage) return undefined;
1053
1197
  for (const check of checks) {
1054
1198
  const value = evaluateCovered(coverage, check, state, next);
@@ -1103,9 +1247,15 @@ export const createSearch = (
1103
1247
  };
1104
1248
  const getViewValue = (expression: Expression, state: Value[]) =>
1105
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
+ };
1106
1257
  const getTlcStateFingerprint = (state: Value[]) => {
1107
- const representative =
1108
- symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, getTlcOrder());
1258
+ const representative = getRepresentativeState(state);
1109
1259
  return getTlcFingerprint(
1110
1260
  view === undefined
1111
1261
  ? getTlcOrder().map((index) => representative[index])
@@ -1113,15 +1263,16 @@ export const createSearch = (
1113
1263
  );
1114
1264
  };
1115
1265
  const findFailedInitialPredicate = (state: Value[]) =>
1116
- isCoveredHeld(coveredInitialPredicates, state)
1117
- ? undefined
1118
- : properties.initialPredicates.find(
1119
- (predicate) =>
1120
- !holdsLikeTlc(
1121
- predicate.expression,
1122
- getContext(environment, state, undefined, predicate.scope),
1123
- ),
1124
- );
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
+ });
1125
1276
  const violatingStates = new WeakSet<Value[]>();
1126
1277
  const isViolated = (invariant: StateCheck, state: Value[], parent: Value[] | undefined) => {
1127
1278
  const checkedParent = parent && !violatingStates.has(parent) ? parent : undefined;
@@ -1145,6 +1296,21 @@ export const createSearch = (
1145
1296
  );
1146
1297
  }
1147
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
+ };
1148
1314
  const isFingerprintedLikeTlc = hasWideString(config, environment);
1149
1315
  runtime.getFingerprint = getTlcStateFingerprint;
1150
1316
  const findUnwitnessedPossible = () => {
@@ -1180,7 +1346,7 @@ export const createSearch = (
1180
1346
  )
1181
1347
  .join("")
1182
1348
  : prettyPrint(formatValue(getViewValue(expression, state)));
1183
- const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: Value[]) =>
1349
+ const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: State) =>
1184
1350
  holdsLikeTlc(
1185
1351
  constraint.expression,
1186
1352
  getContext(environment, state, next),
@@ -1200,14 +1366,16 @@ export const createSearch = (
1200
1366
  spec,
1201
1367
  toRecord,
1202
1368
  evaluateAlias: (alias, state, next, isTool) => {
1369
+ const getStateRecord = () =>
1370
+ toRecord(state.map((value) => value ?? createModelValue("null")));
1203
1371
  try {
1204
1372
  getConfigDefinition("alias", alias, environment);
1205
1373
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
1206
1374
  const record = toAliasRecord(value);
1207
- return record === undefined ? toRecord(state) : setAliasName(record, alias);
1375
+ return record === undefined ? getStateRecord() : setAliasName(record, alias);
1208
1376
  } catch (error) {
1209
1377
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1210
- return { ...toRecord(state), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1378
+ return { ...getStateRecord(), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1211
1379
  }
1212
1380
  },
1213
1381
  isSymmetric: symmetryGroup !== undefined,
@@ -1291,64 +1459,81 @@ export const createSearch = (
1291
1459
  },
1292
1460
  getFingerprintState: (state) => {
1293
1461
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1294
- const representative =
1295
- symmetryGroup === undefined
1296
- ? state
1297
- : getRepresentative(state, symmetryGroup, getTlcOrder());
1462
+ const representative = getRepresentativeState(state);
1298
1463
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
1299
1464
  },
1300
1465
  findViolatedInvariant: (state, parent) => {
1301
- if (isCoveredHeld(coveredInvariants, state)) return undefined;
1302
- 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));
1303
1470
  if (violated) violatingStates.add(state);
1304
1471
  return violated;
1305
1472
  },
1306
- getViolatedInvariants: (state) => {
1307
- const violated = invariantPredicates.filter((predicate) =>
1308
- invariants.some(
1309
- (invariant) =>
1310
- 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,
1311
1491
  ),
1312
1492
  );
1313
- if (violated.length > 0) violatingStates.add(state);
1314
- return violated;
1315
- },
1316
- checkReplayedInitialState: (state, tracing, addFingerprint) => {
1317
- const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1318
- holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1319
- if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1320
- 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 });
1321
1498
  }
1322
- const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1323
- if (invariant) return { status: "invariant-violation", name: invariant.name };
1324
1499
  const predicate = properties.initialPredicates.find(
1325
- (check) => !holdsIn(check.expression, check.scope),
1500
+ (check, index) => !holdsIn(coveredInitialPredicates[index], check.expression, check.scope),
1326
1501
  );
1327
- return predicate && { status: "liveness-violation", name: predicate.name };
1502
+ if (predicate) onViolated({ status: "liveness-violation", name: predicate.name });
1328
1503
  },
1329
1504
  checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1330
1505
  const isInModel =
1331
- constraints.every((constraint) =>
1332
- holdsLikeTlc(
1506
+ constraintPredicates.every((constraint) =>
1507
+ holdsReplayed(
1508
+ coveredConstraintChecks.get(constraint.predicate),
1333
1509
  constraint.predicate,
1334
1510
  getContext(tracing, next, undefined, constraint.scope),
1335
1511
  ),
1336
1512
  ) &&
1337
- actionConstraints.every((constraint) =>
1338
- 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
+ ),
1339
1519
  );
1340
1520
  // TLC checks the invariants of a successor it has not seen, even outside the model.
1341
1521
  const isUnseen = isInModel ? addFingerprint() : true;
1342
1522
  return (
1343
1523
  (!isUnseen ||
1344
1524
  invariantPredicates.every((invariant) =>
1345
- holdsLikeTlc(
1525
+ holdsReplayed(
1526
+ coveredInvariantChecks.get(invariant.predicate),
1346
1527
  invariant.predicate,
1347
1528
  getContext(tracing, next, undefined, invariant.scope),
1348
1529
  ),
1349
1530
  )) &&
1350
- actionProperties.every((property) =>
1351
- 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
+ ),
1352
1537
  )
1353
1538
  );
1354
1539
  },
@@ -1361,31 +1546,32 @@ export const createSearch = (
1361
1546
  ),
1362
1547
  findFailedInitialPredicate,
1363
1548
  findViolatedActionProperty: (state, next) =>
1364
- isCoveredHeld(coveredActionProperties, state, next)
1365
- ? undefined
1366
- : actionProperties.find((property) => {
1367
- try {
1368
- return (
1369
- !holdsLikeTlc(
1370
- property.action,
1371
- getContext(environment, state, next, property.scope),
1372
- () =>
1373
- `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1374
- ) &&
1375
- !holds(
1376
- property.unchanged,
1377
- getContext(environment, state, next, property.scope),
1378
- "a subscript",
1379
- )
1380
- );
1381
- } catch (error) {
1382
- throw withHeadline(
1383
- withNextStateExitCode(error),
1384
- MESSAGE_CODE.actionPropertyEvaluationFailed,
1385
- `Evaluating action property ${property.name} failed.`,
1386
- );
1387
- }
1388
- }),
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
+ }),
1389
1575
  satisfiesActionConstraints: (state, next) =>
1390
1576
  satisfiesCovered(coveredActionConstraints, state, next) ??
1391
1577
  actionConstraints.every((constraint) => holdsActionConstraint(constraint, state, next)),