Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Uniform generation of large traces

Samy Abbes, Vincent Jugé

TL;DR

The paper advances uniform generation of large traces in trace monoids by introducing a pyramidal-decomposition framework that turns infinite-trace sampling into an i.i.d. stacking problem of pyramidal fragments, enabling on-the-fly approximations distributed according to the uniform measure at infinity. It develops two algorithmic families—one without rejection that is fast but memory-intensive, and one with rejection that uses less computation but can have slower production—plus streaming variants (Algorithms 3 and 4) that generate infinite traces with provable linear-time growth and distributional guarantees. It provides rigorous law derivations for pyramidal blocks, analyzes complexity and performance, and identifies graph classes (e.g., chordal, bounded tree-width) where the approach is notably efficient. The work yields practical, scalable methods for simulating long-running executions in concurrent systems and for validating finite-horizon properties without requiring pre-specified sample sizes.

Abstract

We introduce an algorithm for the uniform generation of infinite traces, i.e., infinite words up to commutation of some letters. The algorithm outputs on-the-fly approximations of a theoretical infinite trace, the latter being distributed according to the exact uniform probability measure. The average size of the approximation grows linearly with the time of execution of the algorithm, hence its output can be effectively used while running. Two versions of the algorithm are given. A version without rejection has a good production speed, provided that some precomputations have been done, but these may be costly. A version with rejection requires much fewer computations, at the expense of a production speed that can be small. We also show that, for some particular trace monoids, one or the other version of the algorithm can actually be very good: few computations for a good production speed.

Uniform generation of large traces

TL;DR

The paper advances uniform generation of large traces in trace monoids by introducing a pyramidal-decomposition framework that turns infinite-trace sampling into an i.i.d. stacking problem of pyramidal fragments, enabling on-the-fly approximations distributed according to the uniform measure at infinity. It develops two algorithmic families—one without rejection that is fast but memory-intensive, and one with rejection that uses less computation but can have slower production—plus streaming variants (Algorithms 3 and 4) that generate infinite traces with provable linear-time growth and distributional guarantees. It provides rigorous law derivations for pyramidal blocks, analyzes complexity and performance, and identifies graph classes (e.g., chordal, bounded tree-width) where the approach is notably efficient. The work yields practical, scalable methods for simulating long-running executions in concurrent systems and for validating finite-horizon properties without requiring pre-specified sample sizes.

Abstract

We introduce an algorithm for the uniform generation of infinite traces, i.e., infinite words up to commutation of some letters. The algorithm outputs on-the-fly approximations of a theoretical infinite trace, the latter being distributed according to the exact uniform probability measure. The average size of the approximation grows linearly with the time of execution of the algorithm, hence its output can be effectively used while running. Two versions of the algorithm are given. A version without rejection has a good production speed, provided that some precomputations have been done, but these may be costly. A version with rejection requires much fewer computations, at the expense of a production speed that can be small. We also show that, for some particular trace monoids, one or the other version of the algorithm can actually be very good: few computations for a good production speed.
Paper Structure (13 sections, 10 theorems, 45 equations, 2 figures, 4 algorithms)

This paper contains 13 sections, 10 theorems, 45 equations, 2 figures, 4 algorithms.

Table of Contents

  1. Trace monoids and probability distributions
  2. Combinatorics of traces and discrete distributions
  3. Infinite traces and uniform measure at infinity
  4. Pyramidal traces
  5. Law of pyramidal traces
  6. Random generation of traces
  7. Random generation of finite traces
  8. Random generation of finite traces, with rejection
  9. Random generation of infinite traces
  10. Which approach should be favored in practice for the random generation of large traces?
  11. Intrinsic problem difficulty
  12. Pros and cons of Algorithms 1 to 4
  13. Classes of graphs where our algorithms are efficient

Key Result

Proposition 1.3

Let $\mathcal{M}_\Sigma$ be a trace monoid and let $a_1\in\Sigma$. Every trace ${x\in\mathcal{M}_\Sigma}$ admits a unique factorization as a concatenation $u_0 \cdot \ldots \cdot u_k$, where $u_0,\dots,u_{k-1}$ are $a_1$-pyramidal traces and $u_k \in \mathcal{M}_{\Sigma\setminus\{a_1\}}$. The intege

Figures (2)

  • Figure 1: (i) Hasse diagram of the heap corresponding to the trace ${x=a\cdot b\cdot d\cdot c\cdot b\cdot a\cdot d}$ of the trace monoid $\mathcal{M}(\Sigma,\mathcal{R})$ where $\Sigma=\{a,b,c,d\}$ and where $\mathcal{R}$ is the reflexive and symmetric closure of $\{(a,b),(b,c),(c,d)\}$. (ii) Graphical representation of the same heap with pieces piled up upon each other.
  • Figure 2: (i) Heap representing the $c$-pyramidal element $b\cdot a\cdot b\cdot d\cdot d\cdot c$ in the trace monoid $\mathcal{M}_\Sigma$ , where $(\Sigma,\mathcal{R})$ is as in Figure \ref{['fig:pqjwdpoqjw']}. (ii) An element $x\in\mathcal{M}_\Sigma$ whose decomposition through $c$-pyramidal traces is $(babddc)\cdot(bdc)\cdot a$.

Theorems & Definitions (24)

  • Definition 1.1
  • Definition 1.2
  • Proposition 1.3
  • proof
  • Proposition 1.4
  • proof
  • Theorem 1.5
  • Lemma 1.6
  • proof
  • Lemma 1.7
  • ...and 14 more